19907815758

Committed 03 Dec 2025 08:27PM UTC coverage: 97.319%. Remained the same

Build # 19907815758

Build Type

push

github

Committed by

sanex3339

Commit Message

Adjust precommit hook

Run Details

1770 of 1891 branches covered (93.6%)

Branch coverage included in aggregate %.

5671 of 5755 relevant lines covered (98.54%)

34102965.58 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.45

/src/node-transformers/converting-transformers/ObjectExpressionTransformer.ts

import { inject, injectable } from 'inversify';
import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';

import * as ESTree from 'estree';

import { IOptions } from '../../interfaces/options/IOptions';
import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
import { IVisitor } from '../../interfaces/node-transformers/IVisitor';

import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';

import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
import { NodeFactory } from '../../node/NodeFactory';
import { NodeGuards } from '../../node/NodeGuards';

/**
 * replaces:
 *     var object = { PSEUDO: 1 };
 *
 * on:
 *     var object = { 'PSEUDO': 1 };
 */
@injectable()
export class ObjectExpressionTransformer extends AbstractNodeTransformer {
    /**
     * @param {IRandomGenerator} randomGenerator
     * @param {IOptions} options
     */
    public constructor(
        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
        @inject(ServiceIdentifiers.IOptions) options: IOptions
    ) {
        super(randomGenerator, options);
    }

    /**
     * @param {NodeTransformationStage} nodeTransformationStage
     * @returns {IVisitor | null}
     */
    public getVisitor(nodeTransformationStage: NodeTransformationStage): IVisitor | null {
        switch (nodeTransformationStage) {
            case NodeTransformationStage.Converting:
                return {
                    enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
                        if (parentNode && NodeGuards.isObjectExpressionNode(node)) {
                            return this.transformNode(node, parentNode);
                        }
                    }
                };

            default:
                return null;
        }
    }

    /**
     * @param {ObjectExpression} objectExpressionNode
     * @param {NodeGuards} parentNode
     * @returns {NodeGuards}
     */
    public transformNode(objectExpressionNode: ESTree.ObjectExpression, parentNode: ESTree.Node): ESTree.Node {
        objectExpressionNode.properties.forEach((property: ESTree.Property | ESTree.SpreadElement) => {
            if (!NodeGuards.isPropertyNode(property)) {
                return;
            }

            if (!property.key) {
                return;
            }

            if (property.computed) {
                this.transformComputedProperty(property);
            } else {
                this.transformBaseProperty(property);
            }
        });

        return objectExpressionNode;
    }

    /**
     * @param {Property} property
     */
    private transformComputedProperty(property: ESTree.Property): void {
        if (!NodeGuards.isLiteralNode(property.key) || !(typeof property.key.value === 'string')) {
            return;
        }

        property.key = NodeFactory.literalNode(property.key.value);
    }

    /**
     * @param {Property} property
     */
    private transformBaseProperty(property: ESTree.Property): void {
        if (property.shorthand) {
            property.shorthand = false;
        }

        if (!NodeGuards.isIdentifierNode(property.key)) {
            return;
        }

        property.key = NodeFactory.literalNode(property.key.name);
    }
}

1	import { inject, injectable } from 'inversify';	6✔
2	import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';	6✔
3
4	import * as ESTree from 'estree';
5
6	import { IOptions } from '../../interfaces/options/IOptions';
7	import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
8	import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
9
10	import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';	6✔
11
12	import { AbstractNodeTransformer } from '../AbstractNodeTransformer';	6✔
13	import { NodeFactory } from '../../node/NodeFactory';	6✔
14	import { NodeGuards } from '../../node/NodeGuards';	6✔
15
16	/**
17	* replaces:
18	* var object = { PSEUDO: 1 };
19	*
20	* on:
21	* var object = { 'PSEUDO': 1 };
22	*/
23	@injectable()
24	export class ObjectExpressionTransformer extends AbstractNodeTransformer {	6✔
25	/**
26	* @param {IRandomGenerator} randomGenerator
27	* @param {IOptions} options
28	*/
29	public constructor(
30	@inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
31	@inject(ServiceIdentifiers.IOptions) options: IOptions
32	) {
33	super(randomGenerator, options);	197,808✔
34	}
35
36	/**
37	* @param {NodeTransformationStage} nodeTransformationStage
38	* @returns {IVisitor \| null}
39	*/
40	public getVisitor(nodeTransformationStage: NodeTransformationStage): IVisitor \| null {
41	switch (nodeTransformationStage) {	1,612,710✔
42	case NodeTransformationStage.Converting:	1,612,710✔
43	return {	395,352✔
44	enter: (node: ESTree.Node, parentNode: ESTree.Node \| null): ESTree.Node \| undefined => {
45	if (parentNode && NodeGuards.isObjectExpressionNode(node)) {	34,792,232✔
46	return this.transformNode(node, parentNode);	175,806✔
47	}
48	}
49	};
50
51	default:
52	return null;	1,217,358✔
53	}
54	}
55
56	/**
57	* @param {ObjectExpression} objectExpressionNode
58	* @param {NodeGuards} parentNode
59	* @returns {NodeGuards}
60	*/
61	public transformNode(objectExpressionNode: ESTree.ObjectExpression, parentNode: ESTree.Node): ESTree.Node {
62	objectExpressionNode.properties.forEach((property: ESTree.Property \| ESTree.SpreadElement) => {	175,806✔
63	if (!NodeGuards.isPropertyNode(property)) {	1,081,982✔
64	return;	4,266✔
65	}
66
67	if (!property.key) {	1,077,716!
68	return;	×
69	}
70
71	if (property.computed) {	1,077,716✔
72	this.transformComputedProperty(property);	444✔
73	} else {
74	this.transformBaseProperty(property);	1,077,272✔
75	}
76	});
77
78	return objectExpressionNode;	175,806✔
79	}
80
81	/**
82	* @param {Property} property
83	*/
84	private transformComputedProperty(property: ESTree.Property): void {
85	if (!NodeGuards.isLiteralNode(property.key) \|\| !(typeof property.key.value === 'string')) {	444✔
86	return;	402✔
87	}
88
89	property.key = NodeFactory.literalNode(property.key.value);	42✔
90	}
91
92	/**
93	* @param {Property} property
94	*/
95	private transformBaseProperty(property: ESTree.Property): void {
96	if (property.shorthand) {	1,077,272✔
97	property.shorthand = false;	14,628✔
98	}
99
100	if (!NodeGuards.isIdentifierNode(property.key)) {	1,077,272✔
101	return;	18,282✔
102	}
103
104	property.key = NodeFactory.literalNode(property.key.name);	1,058,990✔
105	}
106	}

javascript-obfuscator / javascript-obfuscator / 19907815758

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous