13621494893

Committed 15 Jun 2024 05:29PM UTC coverage: 97.297%. Remained the same

Build # 13621494893

Build Type

push

github

Committed by

web-flow

Commit Message

Update CHANGELOG.md

Run Details

2238 of 2373 branches covered (94.31%)

Branch coverage included in aggregate %.

5645 of 5729 relevant lines covered (98.53%)

33055580.69 hits per line

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

89.19

/src/node-transformers/NodeTransformersRunner.ts

import { inject, injectable } from 'inversify';

import { ServiceIdentifiers } from '../container/ServiceIdentifiers';

import * as estraverse from '@javascript-obfuscator/estraverse';
import * as ESTree from 'estree';

import { TNodeTransformerFactory } from '../types/container/node-transformers/TNodeTransformerFactory';
import { TDictionary } from '../types/TDictionary';
import { TVisitorDirection } from '../types/node-transformers/TVisitorDirection';
import { TVisitorFunction } from '../types/node-transformers/TVisitorFunction';
import { TVisitorResult } from '../types/node-transformers/TVisitorResult';

import { INodeTransformer } from '../interfaces/node-transformers/INodeTransformer';
import { INodeTransformersRunner } from '../interfaces/node-transformers/INodeTransformersRunner';
import { ITransformerNamesGroupsBuilder } from '../interfaces/utils/ITransformerNamesGroupsBuilder';
import { IVisitor } from '../interfaces/node-transformers/IVisitor';

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

import { NodeGuards } from '../node/NodeGuards';
import { NodeMetadata } from '../node/NodeMetadata';

@injectable()
export class NodeTransformersRunner implements INodeTransformersRunner {
    /**
     * @type {TNodeTransformerFactory}
     */
    private readonly nodeTransformerFactory: TNodeTransformerFactory;

    /**
     * @type {ITransformerNamesGroupsBuilder}
     */
    private readonly nodeTransformerNamesGroupsBuilder: ITransformerNamesGroupsBuilder<
        NodeTransformer,
        INodeTransformer
    >;

    /**
     * @param {TNodeTransformerFactory} nodeTransformerFactory
     * @param {ITransformerNamesGroupsBuilder} nodeTransformerNamesGroupsBuilder
     */
    public constructor (
        @inject(ServiceIdentifiers.Factory__INodeTransformer)
            nodeTransformerFactory: TNodeTransformerFactory,
        @inject(ServiceIdentifiers.INodeTransformerNamesGroupsBuilder)
            nodeTransformerNamesGroupsBuilder: ITransformerNamesGroupsBuilder<
                NodeTransformer,
                INodeTransformer
            >,
    ) {
        this.nodeTransformerFactory = nodeTransformerFactory;
        this.nodeTransformerNamesGroupsBuilder = nodeTransformerNamesGroupsBuilder;
    }

    /**
     * @param {T} astTree
     * @param {NodeTransformer[]} nodeTransformerNames
     * @param {NodeTransformationStage} nodeTransformationStage
     * @returns {T}
     */
    public transform <T extends ESTree.Node = ESTree.Program> (
        astTree: T,
        nodeTransformerNames: NodeTransformer[],
        nodeTransformationStage: NodeTransformationStage
    ): T {
        if (!nodeTransformerNames.length) {
            return astTree;
        }

        const normalizedNodeTransformers: TDictionary<INodeTransformer> =
            this.buildNormalizedNodeTransformers(nodeTransformerNames, nodeTransformationStage);
        const nodeTransformerNamesGroups: NodeTransformer[][] =
            this.nodeTransformerNamesGroupsBuilder.build(normalizedNodeTransformers);

        for (const nodeTransformerNamesGroup of nodeTransformerNamesGroups) {
            const enterVisitors: IVisitor[] = [];
            const leaveVisitors: IVisitor[] = [];

            for (const nodeTransformerName of nodeTransformerNamesGroup) {
                const nodeTransformer: INodeTransformer = normalizedNodeTransformers[nodeTransformerName];
                const visitor: IVisitor | null = nodeTransformer.getVisitor(nodeTransformationStage);

                if (!visitor) {
                    continue;
                }

                if (visitor.enter) {
                    enterVisitors.push({ enter: visitor.enter });
                }

                if (visitor.leave) {
                    leaveVisitors.push({ leave: visitor.leave });
                }
            }

            if (!enterVisitors.length && !leaveVisitors.length) {
                continue;
            }

            estraverse.replace(astTree, {
                enter: this.mergeVisitorsForDirection(enterVisitors, VisitorDirection.Enter),
                leave: this.mergeVisitorsForDirection(leaveVisitors, VisitorDirection.Leave)
            });
        }

        return astTree;
    }

    /**
     * @param {NodeTransformer[]} nodeTransformerNames
     * @param {NodeTransformationStage} nodeTransformationStage
     * @returns {TDictionary<INodeTransformer>}
     */
    private buildNormalizedNodeTransformers (
        nodeTransformerNames: NodeTransformer[],
        nodeTransformationStage: NodeTransformationStage
    ): TDictionary<INodeTransformer> {
        return nodeTransformerNames
            .reduce<TDictionary<INodeTransformer>>(
                (acc: TDictionary<INodeTransformer>, nodeTransformerName: NodeTransformer) => {
                    const nodeTransformer: INodeTransformer = this.nodeTransformerFactory(nodeTransformerName);

                    if (!nodeTransformer.getVisitor(nodeTransformationStage)) {
                        return acc;
                    }

                    return <TDictionary<INodeTransformer>>{
                        ...acc,
                        [nodeTransformerName]: nodeTransformer
                    };
                },
                {}
            );
    }

    /**
     * @param {IVisitor[]} visitors
     * @param {TVisitorDirection} direction
     * @returns {TVisitorFunction}
     */
    private mergeVisitorsForDirection (visitors: IVisitor[], direction: TVisitorDirection): TVisitorFunction {
        const visitorsLength: number = visitors.length;

        if (!visitorsLength) {
            return (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node => node;
        }

        return (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | estraverse.VisitorOption => {
            if (NodeMetadata.isIgnoredNode(node)) {
                return estraverse.VisitorOption.Skip;
            }

            for (let i: number = 0; i < visitorsLength; i++) {
                const visitorFunction: TVisitorFunction | undefined = visitors[i][direction];

                if (!visitorFunction) {
                    continue;
                }

                const visitorResult: TVisitorResult = visitorFunction(node, parentNode);
                const isValidVisitorResult = visitorResult && NodeGuards.isNode(visitorResult);

                if (!isValidVisitorResult) {
                    continue;
                }

                node = visitorResult;
            }

            return node;
        };
    }
}

1	import { inject, injectable } from 'inversify';	6✔
2
3	import { ServiceIdentifiers } from '../container/ServiceIdentifiers';	6✔
4
5	import * as estraverse from '@javascript-obfuscator/estraverse';	6✔
6	import * as ESTree from 'estree';
7
8	import { TNodeTransformerFactory } from '../types/container/node-transformers/TNodeTransformerFactory';
9	import { TDictionary } from '../types/TDictionary';
10	import { TVisitorDirection } from '../types/node-transformers/TVisitorDirection';
11	import { TVisitorFunction } from '../types/node-transformers/TVisitorFunction';
12	import { TVisitorResult } from '../types/node-transformers/TVisitorResult';
13
14	import { INodeTransformer } from '../interfaces/node-transformers/INodeTransformer';
15	import { INodeTransformersRunner } from '../interfaces/node-transformers/INodeTransformersRunner';
16	import { ITransformerNamesGroupsBuilder } from '../interfaces/utils/ITransformerNamesGroupsBuilder';
17	import { IVisitor } from '../interfaces/node-transformers/IVisitor';
18
19	import { NodeTransformer } from '../enums/node-transformers/NodeTransformer';
20	import { NodeTransformationStage } from '../enums/node-transformers/NodeTransformationStage';
21	import { VisitorDirection } from '../enums/node-transformers/VisitorDirection';	6✔
22
23	import { NodeGuards } from '../node/NodeGuards';	6✔
24	import { NodeMetadata } from '../node/NodeMetadata';	6✔
25
26	@injectable()
27	export class NodeTransformersRunner implements INodeTransformersRunner {	6✔
28	/**
29	* @type {TNodeTransformerFactory}
30	*/
31	private readonly nodeTransformerFactory: TNodeTransformerFactory;
32
33	/**
34	* @type {ITransformerNamesGroupsBuilder}
35	*/
36	private readonly nodeTransformerNamesGroupsBuilder: ITransformerNamesGroupsBuilder<
37	NodeTransformer,
38	INodeTransformer
39	>;
40
41	/**
42	* @param {TNodeTransformerFactory} nodeTransformerFactory
43	* @param {ITransformerNamesGroupsBuilder} nodeTransformerNamesGroupsBuilder
44	*/
45	public constructor (
46	@inject(ServiceIdentifiers.Factory__INodeTransformer)
47	nodeTransformerFactory: TNodeTransformerFactory,
48	@inject(ServiceIdentifiers.INodeTransformerNamesGroupsBuilder)
49	nodeTransformerNamesGroupsBuilder: ITransformerNamesGroupsBuilder<
50	NodeTransformer,
51	INodeTransformer
52	>,
53	) {
54	this.nodeTransformerFactory = nodeTransformerFactory;	197,752✔
55	this.nodeTransformerNamesGroupsBuilder = nodeTransformerNamesGroupsBuilder;	197,752✔
56	}
57
58	/**
59	* @param {T} astTree
60	* @param {NodeTransformer[]} nodeTransformerNames
61	* @param {NodeTransformationStage} nodeTransformationStage
62	* @returns {T}
63	*/
64	public transform <T extends ESTree.Node = ESTree.Program> (
65	astTree: T,
66	nodeTransformerNames: NodeTransformer[],
67	nodeTransformationStage: NodeTransformationStage
68	): T {
69	if (!nodeTransformerNames.length) {	1,637,865!
70	return astTree;	×
71	}
72
73	const normalizedNodeTransformers: TDictionary<INodeTransformer> =
74	this.buildNormalizedNodeTransformers(nodeTransformerNames, nodeTransformationStage);	1,637,865✔
75	const nodeTransformerNamesGroups: NodeTransformer[][] =
76	this.nodeTransformerNamesGroupsBuilder.build(normalizedNodeTransformers);	1,637,865✔
77
78	for (const nodeTransformerNamesGroup of nodeTransformerNamesGroups) {	1,637,865✔
79	const enterVisitors: IVisitor[] = [];	3,047,551✔
80	const leaveVisitors: IVisitor[] = [];	3,047,551✔
81
82	for (const nodeTransformerName of nodeTransformerNamesGroup) {	3,047,551✔
83	const nodeTransformer: INodeTransformer = normalizedNodeTransformers[nodeTransformerName];	7,504,229✔
84	const visitor: IVisitor \| null = nodeTransformer.getVisitor(nodeTransformationStage);	7,504,229✔
85
86	if (!visitor) {	7,504,229!
87	continue;	×
88	}
89
90	if (visitor.enter) {	7,504,229✔
91	enterVisitors.push({ enter: visitor.enter });	5,343,767✔
92	}
93
94	if (visitor.leave) {	7,504,229✔
95	leaveVisitors.push({ leave: visitor.leave });	2,198,144✔
96	}
97	}
98
99	if (!enterVisitors.length && !leaveVisitors.length) {	3,047,551!
100	continue;	×
101	}
102
103	estraverse.replace(astTree, {	3,047,551✔
104	enter: this.mergeVisitorsForDirection(enterVisitors, VisitorDirection.Enter),
105	leave: this.mergeVisitorsForDirection(leaveVisitors, VisitorDirection.Leave)
106	});
107	}
108
109	return astTree;	1,637,865✔
110	}
111
112	/**
113	* @param {NodeTransformer[]} nodeTransformerNames
114	* @param {NodeTransformationStage} nodeTransformationStage
115	* @returns {TDictionary<INodeTransformer>}
116	*/
117	private buildNormalizedNodeTransformers (
118	nodeTransformerNames: NodeTransformer[],
119	nodeTransformationStage: NodeTransformationStage
120	): TDictionary<INodeTransformer> {
121	return nodeTransformerNames	1,637,865✔
122	.reduce<TDictionary<INodeTransformer>>(
123	(acc: TDictionary<INodeTransformer>, nodeTransformerName: NodeTransformer) => {
124	const nodeTransformer: INodeTransformer = this.nodeTransformerFactory(nodeTransformerName);	50,381,019✔
125
126	if (!nodeTransformer.getVisitor(nodeTransformationStage)) {	50,381,019✔
127	return acc;	42,876,790✔
128	}
129
130	return <TDictionary<INodeTransformer>>{	7,504,229✔
131	...acc,
132	[nodeTransformerName]: nodeTransformer
133	};
134	},
135	{}
136	);
137	}
138
139	/**
140	* @param {IVisitor[]} visitors
141	* @param {TVisitorDirection} direction
142	* @returns {TVisitorFunction}
143	*/
144	private mergeVisitorsForDirection (visitors: IVisitor[], direction: TVisitorDirection): TVisitorFunction {
145	const visitorsLength: number = visitors.length;	6,095,102✔
146
147	if (!visitorsLength) {	6,095,102✔
148	return (node: ESTree.Node, parentNode: ESTree.Node \| null): ESTree.Node => node;	2,128,949,780✔
149	}
150
151	return (node: ESTree.Node, parentNode: ESTree.Node \| null): ESTree.Node \| estraverse.VisitorOption => {	3,468,983✔
152	if (NodeMetadata.isIgnoredNode(node)) {	2,592,615,343✔
153	return estraverse.VisitorOption.Skip;	523,336✔
154	}
155
156	for (let i: number = 0; i < visitorsLength; i++) {	2,592,092,007✔
157	const visitorFunction: TVisitorFunction \| undefined = visitors[i][direction];	5,064,237,466✔
158
159	if (!visitorFunction) {	5,064,237,466!
160	continue;	×
161	}
162
163	const visitorResult: TVisitorResult = visitorFunction(node, parentNode);	5,064,237,466✔
164	const isValidVisitorResult = visitorResult && NodeGuards.isNode(visitorResult);	5,064,237,466✔
165
166	if (!isValidVisitorResult) {	5,064,237,466✔
167	continue;	3,542,987,834✔
168	}
169
170	node = visitorResult;	1,521,249,632✔
171	}
172
173	return node;	2,592,092,007✔
174	};
175	}
176	}

javascript-obfuscator / javascript-obfuscator / 13621494893

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