Code transformers #1

src/JavaScriptObfuscator.ts

@@ -106,7 +106,7 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
      * @param {IOptions} options
      */
     public constructor (
-        @inject(ServiceIdentifiers.ITransformersRunner) transformersRunner: INodeTransformersRunner,
+        @inject(ServiceIdentifiers.INodeTransformersRunner) transformersRunner: INodeTransformersRunner,
         @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
         @inject(ServiceIdentifiers.Factory__IObfuscatedCode) obfuscatedCodeFactory: TObfuscatedCodeFactory,
         @inject(ServiceIdentifiers.ILogger) logger: ILogger,

src/code-transformers/AbstractCodeTransformer.ts

@@ -0,0 +1,46 @@
+import { inject, injectable } from 'inversify';
+import { ServiceIdentifiers } from '../container/ServiceIdentifiers';
+
+import { ICodeTransformer } from '../interfaces/code-transformers/ICodeTransformer';
+import { IOptions } from '../interfaces/options/IOptions';
+import { IRandomGenerator } from '../interfaces/utils/IRandomGenerator';
+
+import { CodeTransformer } from '../enums/code-transformers/CodeTransformer';
+import { CodeTransformationStage } from '../enums/code-transformers/CodeTransformationStage';
+
+@injectable()
+export abstract class AbstractCodeTransformer implements ICodeTransformer {
+    /**
+     * @type {IOptions}
+     */
+    protected readonly options: IOptions;
+
+    /**
+     * @type {IRandomGenerator}
+     */
+    protected readonly randomGenerator: IRandomGenerator;
+
+    /**
+     * @type {CodeTransformer[]}
+     */
+    public readonly abstract runAfter: CodeTransformer[];
+
+    /**
+     * @param {IRandomGenerator} randomGenerator
+     * @param {IOptions} options
+     */
+    protected constructor (
+        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
+        @inject(ServiceIdentifiers.IOptions) options: IOptions
+    ) {
+        this.randomGenerator = randomGenerator;
+        this.options = options;
+    }
+
+    /**
+     * @param {string} code
+     * @param {CodeTransformationStage} codeTransformationStage
+     * @returns {string}
+     */
+    public abstract transformCode (code: string, codeTransformationStage: CodeTransformationStage): string;
+}

src/code-transformers/CodeTransformerNamesGroupsBuilder.ts

@@ -0,0 +1,13 @@
+import { injectable } from 'inversify';
+
+import { ICodeTransformer } from '../interfaces/code-transformers/ICodeTransformer';
+
+import { CodeTransformer } from '../enums/code-transformers/CodeTransformer';
+
+import { AbstractTransformerNamesGroupsBuilder } from '../utils/AbstractTransformerNamesGroupsBuilder';
+
+@injectable()
+export class CodeTransformerNamesGroupsBuilder extends AbstractTransformerNamesGroupsBuilder<
+    CodeTransformer,
+    ICodeTransformer
+> {}

src/container/InversifyContainerFacade.ts

@@ -2,6 +2,7 @@ import { Container, interfaces } from 'inversify';
 import { ServiceIdentifiers } from './ServiceIdentifiers';
 
 import { analyzersModule } from './modules/analyzers/AnalyzersModule';
+import { codeTransformersModule } from './modules/code-transformers/CodeTransformersModule';
 import { controlFlowTransformersModule } from './modules/node-transformers/ControlFlowTransformersModule';
 import { convertingTransformersModule } from './modules/node-transformers/ConvertingTransformersModule';
 import { customCodeHelpersModule } from './modules/custom-code-helpers/CustomCodeHelpersModule';
@@ -166,7 +167,7 @@ export class InversifyContainerFacade implements IInversifyContainerFacade {
             .inSingletonScope();
 
         this.container
-            .bind<INodeTransformersRunner>(ServiceIdentifiers.ITransformersRunner)
+            .bind<INodeTransformersRunner>(ServiceIdentifiers.INodeTransformersRunner)
             .to(NodeTransformersRunner)
             .inSingletonScope();
 
@@ -194,6 +195,7 @@ export class InversifyContainerFacade implements IInversifyContainerFacade {
 
         // modules
         this.container.load(analyzersModule);
+        this.container.load(codeTransformersModule);
         this.container.load(controlFlowTransformersModule);
         this.container.load(convertingTransformersModule);
         this.container.load(customCodeHelpersModule);

src/container/ServiceIdentifiers.ts

@@ -1,5 +1,6 @@
 export enum ServiceIdentifiers {
     Factory__ICalleeDataExtractor = 'Factory<ICalleeDataExtractor>',
+    Factory__ICodeTransformer = 'Factory<ICodeTransformer[]>',
     Factory__IControlFlowCustomNode = 'Factory<IControlFlowCustomNode>',
     Factory__IControlFlowReplacer = 'Factory<IControlFlowReplacer>',
     Factory__ICustomCodeHelper = 'Factory<ICustomCodeHelper>',
@@ -17,6 +18,8 @@ export enum ServiceIdentifiers {
     IArrayUtils = 'IArrayUtils',
     ICalleeDataExtractor = 'ICalleeDataExtractor',
     ICallsGraphAnalyzer = 'ICallsGraphAnalyzer',
+    ICodeTransformer = 'ICodeTransformer',
+    ICodeTransformerNamesGroupsBuilder = 'ICodeTransformerNamesGroupsBuilder',
     ICryptUtils = 'ICryptUtils',
     ICustomCodeHelper = 'ICustomCodeHelper',
     ICustomCodeHelperGroup = 'ICustomCodeHelperGroup',
@@ -45,7 +48,7 @@ export enum ServiceIdentifiers {
     IScopeAnalyzer = 'IScopeAnalyzer',
     IStringArrayStorage = 'IStringArrayStorage',
     IStringArrayStorageAnalyzer = 'IStringArrayStorageAnalyzer',
-    ITransformersRunner = 'ITransformersRunner',
+    INodeTransformersRunner = 'INodeTransformersRunner',
     Newable__ICustomNode = 'Newable<ICustomNode>',
     Newable__TControlFlowStorage = 'Newable<TControlFlowStorage>',
     TCustomNodeGroupStorage = 'TCustomNodeGroupStorage',

src/container/modules/code-transformers/CodeTransformersModule.ts

@@ -0,0 +1,22 @@
+import { InversifyContainerFacade } from '../../InversifyContainerFacade';
+import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { ICodeTransformer } from '../../../interfaces/code-transformers/ICodeTransformer';
+import { ITransformerNamesGroupsBuilder } from '../../../interfaces/utils/ITransformerNamesGroupsBuilder';
+
+import { CodeTransformer } from '../../../enums/code-transformers/CodeTransformer';
+
+import { CodeTransformerNamesGroupsBuilder } from '../../../code-transformers/CodeTransformerNamesGroupsBuilder';
+
+export const codeTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // code transformers factory
+    bind<ICodeTransformer>(ServiceIdentifiers.Factory__ICodeTransformer)
+        .toFactory<ICodeTransformer>(InversifyContainerFacade
+            .getCacheFactory<CodeTransformer, ICodeTransformer>(ServiceIdentifiers.ICodeTransformer));
+
+    // code transformer names groups builder
+    bind<ITransformerNamesGroupsBuilder<CodeTransformer, ICodeTransformer>>(ServiceIdentifiers.ICodeTransformerNamesGroupsBuilder)
+        .to(CodeTransformerNamesGroupsBuilder)
+        .inSingletonScope();
+});

src/container/modules/node-transformers/NodeTransformersModule.ts

@@ -3,12 +3,20 @@ import { ContainerModule, interfaces } from 'inversify';
 import { ServiceIdentifiers } from '../../ServiceIdentifiers';
 
 import { INodeTransformer } from '../../../interfaces/node-transformers/INodeTransformer';
+import { ITransformerNamesGroupsBuilder } from '../../../interfaces/utils/ITransformerNamesGroupsBuilder';
 
 import { NodeTransformer } from '../../../enums/node-transformers/NodeTransformer';
 
+import { NodeTransformerNamesGroupsBuilder } from '../../../node-transformers/NodeTransformerNamesGroupsBuilder';
+
 export const nodeTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
     // node transformers factory
     bind<INodeTransformer>(ServiceIdentifiers.Factory__INodeTransformer)
         .toFactory<INodeTransformer>(InversifyContainerFacade
             .getCacheFactory<NodeTransformer, INodeTransformer>(ServiceIdentifiers.INodeTransformer));
+
+    // node transformer names groups builder
+    bind<ITransformerNamesGroupsBuilder<NodeTransformer, INodeTransformer>>(ServiceIdentifiers.INodeTransformerNamesGroupsBuilder)
+        .to(NodeTransformerNamesGroupsBuilder)
+        .inSingletonScope();
 });

src/container/modules/utils/UtilsModule.ts

@@ -5,14 +5,12 @@ import { IArrayUtils } from '../../../interfaces/utils/IArrayUtils';
 import { ICryptUtils } from '../../../interfaces/utils/ICryptUtils';
 import { IEscapeSequenceEncoder } from '../../../interfaces/utils/IEscapeSequenceEncoder';
 import { ILevelledTopologicalSorter } from '../../../interfaces/utils/ILevelledTopologicalSorter';
-import { INodeTransformerNamesGroupsBuilder } from '../../../interfaces/utils/INodeTransformerNamesGroupsBuilder';
 import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
 
 import { ArrayUtils } from '../../../utils/ArrayUtils';
 import { CryptUtils } from '../../../utils/CryptUtils';
 import { EscapeSequenceEncoder } from '../../../utils/EscapeSequenceEncoder';
 import { LevelledTopologicalSorter } from '../../../utils/LevelledTopologicalSorter';
-import { NodeTransformerNamesGroupsBuilder } from '../../../utils/NodeTransformerNamesGroupsBuilder';
 import { RandomGenerator } from '../../../utils/RandomGenerator';
 
 export const utilsModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
@@ -39,9 +37,4 @@ export const utilsModule: interfaces.ContainerModule = new ContainerModule((bind
     // levelled topological sorter
     bind<ILevelledTopologicalSorter>(ServiceIdentifiers.ILevelledTopologicalSorter)
         .to(LevelledTopologicalSorter);
-
-    // node transformer names groups builder
-    bind<INodeTransformerNamesGroupsBuilder>(ServiceIdentifiers.INodeTransformerNamesGroupsBuilder)
-        .to(NodeTransformerNamesGroupsBuilder)
-        .inSingletonScope();
 });

src/enums/code-transformers/CodeTransformationStage.ts

@@ -0,0 +1,4 @@
+export enum CodeTransformationStage {
+    BeforeNodeTransformers = 'BeforeNodeTransformers',
+    AfterNodeTransformers = 'AfterNodeTransformers',
+}

src/enums/code-transformers/CodeTransformer.ts

@@ -0,0 +1,3 @@
+export enum CodeTransformer {
+    HashbangOperatorTransformer = 'HashbangOperatorTransformer'
+}

src/interfaces/ITransformer.ts

@@ -0,0 +1,6 @@
+export interface ITransformer <TTransformerName extends string> {
+    /**
+     * @type {TTransformerName[] | undefined}
+     */
+    runAfter?: TTransformerName[];
+}

src/interfaces/code-transformers/ICodeTransformer.ts

@@ -0,0 +1,13 @@
+import { ITransformer } from '../ITransformer';
+
+import { CodeTransformer } from '../../enums/code-transformers/CodeTransformer';
+import { CodeTransformationStage } from '../../enums/code-transformers/CodeTransformationStage';
+
+export interface ICodeTransformer extends ITransformer <CodeTransformer> {
+    /**
+     * @param {string} code
+     * @param {CodeTransformationStage} codeTransformationStage
+     * @returns {string}
+     */
+    transformCode (code: string, codeTransformationStage: CodeTransformationStage): string;
+}

src/interfaces/node-transformers/INodeTransformer.ts

@@ -1,17 +1,13 @@
 import * as estraverse from 'estraverse';
 import * as ESTree from 'estree';
 
+import { ITransformer } from '../ITransformer';
 import { IVisitor } from './IVisitor';
 
 import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';
 import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
 
-export interface INodeTransformer {
-    /**
-     * @type {NodeTransformer[] | undefined}
-     */
-    runAfter?: NodeTransformer[];
-
+export interface INodeTransformer extends ITransformer <NodeTransformer> {
     /**
      * @param {NodeTransformationStage} nodeTransformationStage
      * @returns {IVisitor | null}

src/interfaces/utils/INodeTransformerNamesGroupsBuilder.ts

@@ -1,11 +0,0 @@
-import { TNormalizedNodeTransformers } from '../../types/node-transformers/TNormalizedNodeTransformers';
-
-import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';
-
-export interface INodeTransformerNamesGroupsBuilder {
-    /**
-     * @param {TNormalizedNodeTransformers} normalizedNodeTransformers
-     * @returns {NodeTransformer[][]}
-     */
-    build (normalizedNodeTransformers: TNormalizedNodeTransformers): NodeTransformer[][];
-}

src/interfaces/utils/ITransformerNamesGroupsBuilder.ts

@@ -0,0 +1,12 @@
+import { TObject } from '../../types/TObject';
+
+export interface ITransformerNamesGroupsBuilder <
+    TTransformerName extends string,
+    TTransformer
+> {
+    /**
+     * @param {TObject<TTransformer>} normalizedTransformers
+     * @returns {TTransformerName[][]}
+     */
+    build (normalizedTransformers: TObject<TTransformer>): TTransformerName[][];
+}

src/node-transformers/NodeTransformerNamesGroupsBuilder.ts

@@ -0,0 +1,13 @@
+import { injectable } from 'inversify';
+
+import { INodeTransformer } from '../interfaces/node-transformers/INodeTransformer';
+
+import { NodeTransformer } from '../enums/node-transformers/NodeTransformer';
+
+import { AbstractTransformerNamesGroupsBuilder } from '../utils/AbstractTransformerNamesGroupsBuilder';
+
+@injectable()
+export class NodeTransformerNamesGroupsBuilder extends AbstractTransformerNamesGroupsBuilder<
+    NodeTransformer,
+    INodeTransformer
+> {}

src/node-transformers/NodeTransformersRunner.ts

@@ -6,14 +6,14 @@ import * as estraverse from 'estraverse';
 import * as ESTree from 'estree';
 
 import { TNodeTransformerFactory } from '../types/container/node-transformers/TNodeTransformerFactory';
-import { TNormalizedNodeTransformers } from '../types/node-transformers/TNormalizedNodeTransformers';
+import { TObject } from '../types/TObject';
 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 { INodeTransformerNamesGroupsBuilder } from '../interfaces/utils/INodeTransformerNamesGroupsBuilder';
 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';
@@ -31,19 +31,25 @@ export class NodeTransformersRunner implements INodeTransformersRunner {
     private readonly nodeTransformerFactory: TNodeTransformerFactory;
 
     /**
-     * @type {INodeTransformerNamesGroupsBuilder}
+     * @type {ITransformerNamesGroupsBuilder}
      */
-    private readonly nodeTransformerNamesGroupsBuilder: INodeTransformerNamesGroupsBuilder;
+    private readonly nodeTransformerNamesGroupsBuilder: ITransformerNamesGroupsBuilder<
+        NodeTransformer,
+        INodeTransformer
+    >;
 
     /**
      * @param {TNodeTransformerFactory} nodeTransformerFactory
-     * @param {INodeTransformerNamesGroupsBuilder} nodeTransformerNamesGroupsBuilder
+     * @param {ITransformerNamesGroupsBuilder} nodeTransformerNamesGroupsBuilder
      */
     public constructor (
         @inject(ServiceIdentifiers.Factory__INodeTransformer)
             nodeTransformerFactory: TNodeTransformerFactory,
         @inject(ServiceIdentifiers.INodeTransformerNamesGroupsBuilder)
-            nodeTransformerNamesGroupsBuilder: INodeTransformerNamesGroupsBuilder,
+            nodeTransformerNamesGroupsBuilder: ITransformerNamesGroupsBuilder<
+                NodeTransformer,
+                INodeTransformer
+            >,
     ) {
         this.nodeTransformerFactory = nodeTransformerFactory;
         this.nodeTransformerNamesGroupsBuilder = nodeTransformerNamesGroupsBuilder;
@@ -64,7 +70,7 @@ export class NodeTransformersRunner implements INodeTransformersRunner {
             return astTree;
         }
 
-        const normalizedNodeTransformers: TNormalizedNodeTransformers =
+        const normalizedNodeTransformers: TObject<INodeTransformer> =
             this.buildNormalizedNodeTransformers(nodeTransformerNames, nodeTransformationStage);
         const nodeTransformerNamesGroups: NodeTransformer[][] =
             this.nodeTransformerNamesGroupsBuilder.build(normalizedNodeTransformers);
@@ -106,15 +112,15 @@ export class NodeTransformersRunner implements INodeTransformersRunner {
     /**
      * @param {NodeTransformer[]} nodeTransformerNames
      * @param {NodeTransformationStage} nodeTransformationStage
-     * @returns {TNormalizedNodeTransformers}
+     * @returns {TObject<INodeTransformer>}
      */
     private buildNormalizedNodeTransformers (
         nodeTransformerNames: NodeTransformer[],
         nodeTransformationStage: NodeTransformationStage
-    ): TNormalizedNodeTransformers {
+    ): TObject<INodeTransformer> {
         return nodeTransformerNames
-            .reduce<TNormalizedNodeTransformers>(
-                (acc: TNormalizedNodeTransformers, nodeTransformerName: NodeTransformer) => {
+            .reduce<TObject<INodeTransformer>>(
+                (acc: TObject<INodeTransformer>, nodeTransformerName: NodeTransformer) => {
                     const nodeTransformer: INodeTransformer = this.nodeTransformerFactory(nodeTransformerName);
 
                     if (!nodeTransformer.getVisitor(nodeTransformationStage)) {

src/node-transformers/dead-code-injection-transformers/DeadCodeInjectionTransformer.ts

@@ -85,7 +85,7 @@ export class DeadCodeInjectionTransformer extends AbstractNodeTransformer {
     public constructor (
         @inject(ServiceIdentifiers.Factory__IDeadCodeInjectionCustomNode)
             deadCodeInjectionCustomNodeFactory: TDeadNodeInjectionCustomNodeFactory,
-        @inject(ServiceIdentifiers.ITransformersRunner) transformersRunner: INodeTransformersRunner,
+        @inject(ServiceIdentifiers.INodeTransformersRunner) transformersRunner: INodeTransformersRunner,
         @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
         @inject(ServiceIdentifiers.IOptions) options: IOptions
     ) {

src/types/node-transformers/TNodeTransformersRelationEdge.ts

@@ -1,3 +0,0 @@
-import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';
-
-export type TNodeTransformersRelationEdge = [NodeTransformer, NodeTransformer | null];

src/types/node-transformers/TNormalizedNodeTransformers.ts

@@ -1,5 +0,0 @@
-import { TObject } from '../TObject';
-
-import { INodeTransformer } from '../../interfaces/node-transformers/INodeTransformer';
-
-export type TNormalizedNodeTransformers = TObject<INodeTransformer>;

src/types/utils/TTransformersRelationEdge.ts

@@ -0,0 +1 @@
+export type TTransformersRelationEdge <TTransformerName extends string> = [TTransformerName, TTransformerName | null];

src/utils/AbstractTransformerNamesGroupsBuilder.ts

@@ -0,0 +1,102 @@
+import { inject, injectable } from 'inversify';
+import { ServiceIdentifiers } from '../container/ServiceIdentifiers';
+
+import { TObject } from '../types/TObject';
+import { TTransformersRelationEdge } from '../types/utils/TTransformersRelationEdge';
+
+import { ILevelledTopologicalSorter } from '../interfaces/utils/ILevelledTopologicalSorter';
+import { ITransformer } from '../interfaces/ITransformer';
+import { ITransformerNamesGroupsBuilder } from '../interfaces/utils/ITransformerNamesGroupsBuilder';
+
+@injectable()
+export abstract class AbstractTransformerNamesGroupsBuilder <
+    TTransformerName extends string,
+    TTransformer extends ITransformer<TTransformerName>
+> implements ITransformerNamesGroupsBuilder <
+    TTransformerName,
+    TTransformer
+> {
+    /**
+     * @type {ILevelledTopologicalSorter<TTransformerName>}
+     */
+    private readonly levelledTopologicalSorter: ILevelledTopologicalSorter<TTransformerName>;
+
+    public constructor (
+        @inject(ServiceIdentifiers.ILevelledTopologicalSorter)
+            levelledTopologicalSorter: ILevelledTopologicalSorter<TTransformerName>
+    ) {
+        this.levelledTopologicalSorter = levelledTopologicalSorter;
+    }
+
+    /**
+     * Builds sorted transformer names by topological sort with levels
+     *
+     * For example, if SplitString transformer has following dependencies inside `runAfter` property:
+     *  - NodeTransformer.ObjectExpressionKeysTransformer,
+     *  - NodeTransformer.TemplateLiteralTransformer
+     *
+     *  Than result node transformer names groups will be like:
+     *  [
+     *      [
+     *          SomeTransformerA,
+     *          ObjectExpressionKeysTransformer,
+     *          TemplateLiteralTransformer,
+     *          SomeTransformerB
+     *      ],
+     *      [
+     *          SplitStringTransformer
+     *      ]
+     *  ]
+     *
+     * @param {TObject<TTransformer>} normalizedTransformers
+     * @returns {TTransformerName[][]}
+     */
+    public build (normalizedTransformers: TObject<TTransformer>): TTransformerName[][] {
+        const transformerNames: TTransformerName[] = <TTransformerName[]>Object.keys(normalizedTransformers);
+        const relationEdges: TTransformersRelationEdge<TTransformerName>[] = this.buildTransformersRelationEdges(
+            transformerNames,
+            normalizedTransformers
+        );
+
+        for (const [precedent, consequent] of relationEdges) {
+            this.levelledTopologicalSorter.add(precedent, consequent);
+        }
+
+        return this.levelledTopologicalSorter.sortByGroups();
+    }
+
+    /**
+     * @param {TTransformerName[]} transformerNames
+     * @param {TObject<TTransformer>} normalizedTransformers
+     * @returns {TTransformersRelationEdge<TTransformerName>[]}
+     */
+    private buildTransformersRelationEdges (
+        transformerNames: TTransformerName[],
+        normalizedTransformers: TObject<TTransformer>
+    ): TTransformersRelationEdge<TTransformerName>[] {
+        const relationEdges: TTransformersRelationEdge<TTransformerName>[] = [];
+
+        for (const transformerName of transformerNames) {
+            const transformer: TTransformer = normalizedTransformers[transformerName];
+            const runAfterRelations: TTransformerName[] | undefined = transformer.runAfter;
+
+            if (!runAfterRelations || !runAfterRelations.length) {
+                relationEdges.push([transformerName, null]);
+                continue;
+            }
+
+            for (const runAfterRelation of runAfterRelations) {
+                const isUnknownRelation: boolean = normalizedTransformers[runAfterRelation] === undefined;
+
+                if (isUnknownRelation) {
+                    relationEdges.push([transformerName, null]);
+                    continue;
+                }
+
+                relationEdges.push([runAfterRelation, transformerName]);
+            }
+        }
+
+        return relationEdges;
+    }
+}

src/utils/NodeTransformerNamesGroupsBuilder.ts

@@ -1,98 +0,0 @@
-import { inject, injectable } from 'inversify';
-import { ServiceIdentifiers } from '../container/ServiceIdentifiers';
-
-import { TNodeTransformersRelationEdge } from '../types/node-transformers/TNodeTransformersRelationEdge';
-import { TNormalizedNodeTransformers } from '../types/node-transformers/TNormalizedNodeTransformers';
-
-import { ILevelledTopologicalSorter } from '../interfaces/utils/ILevelledTopologicalSorter';
-import { INodeTransformer } from '../interfaces/node-transformers/INodeTransformer';
-import { INodeTransformerNamesGroupsBuilder } from '../interfaces/utils/INodeTransformerNamesGroupsBuilder';
-
-import { NodeTransformer } from '../enums/node-transformers/NodeTransformer';
-
-@injectable()
-export class NodeTransformerNamesGroupsBuilder implements INodeTransformerNamesGroupsBuilder {
-    /**
-     * @type {ILevelledTopologicalSorter<NodeTransformer>}
-     */
-    private readonly levelledTopologicalSorter: ILevelledTopologicalSorter<NodeTransformer>;
-
-    public constructor (
-        @inject(ServiceIdentifiers.ILevelledTopologicalSorter)
-            levelledTopologicalSorter: ILevelledTopologicalSorter<NodeTransformer>
-    ) {
-        this.levelledTopologicalSorter = levelledTopologicalSorter;
-    }
-
-    /**
-     * Builds sorted NodeTransformer names by topological sort with levels
-     *
-     * For example, if SplitString transformer has following dependencies inside `runAfter` property:
-     *  - NodeTransformer.ObjectExpressionKeysTransformer,
-     *  - NodeTransformer.TemplateLiteralTransformer
-     *
-     *  Than result node transformer names groups will be like:
-     *  [
-     *      [
-     *          SomeTransformerA,
-     *          ObjectExpressionKeysTransformer,
-     *          TemplateLiteralTransformer,
-     *          SomeTransformerB
-     *      ],
-     *      [
-     *          SplitStringTransformer
-     *      ]
-     *  ]
-     *
-     * @param {TNormalizedNodeTransformers} normalizedNodeTransformers
-     * @returns {NodeTransformer[][]}
-     */
-    public build (normalizedNodeTransformers: TNormalizedNodeTransformers): NodeTransformer[][] {
-        const nodeTransformerNames: NodeTransformer[] = <NodeTransformer[]>Object.keys(normalizedNodeTransformers);
-        const relationEdges: TNodeTransformersRelationEdge[] = this.buildNodeTransformersRelationEdges(
-            nodeTransformerNames,
-            normalizedNodeTransformers
-        );
-
-        for (const [precedent, consequent] of relationEdges) {
-            this.levelledTopologicalSorter.add(precedent, consequent);
-        }
-
-        return this.levelledTopologicalSorter.sortByGroups();
-    }
-
-    /**
-     * @param {NodeTransformer[]} nodeTransformerNames
-     * @param {TNormalizedNodeTransformers} normalizedNodeTransformers
-     * @returns {[NodeTransformer, NodeTransformer][]}
-     */
-    private buildNodeTransformersRelationEdges (
-        nodeTransformerNames: NodeTransformer[],
-        normalizedNodeTransformers: TNormalizedNodeTransformers
-    ): TNodeTransformersRelationEdge[] {
-        const relationEdges: TNodeTransformersRelationEdge[] = [];
-
-        for (const nodeTransformerName of nodeTransformerNames) {
-            const nodeTransformer: INodeTransformer = normalizedNodeTransformers[nodeTransformerName];
-            const runAfterRelations: NodeTransformer[] | undefined = nodeTransformer.runAfter;
-
-            if (!runAfterRelations || !runAfterRelations.length) {
-                relationEdges.push([nodeTransformerName, null]);
-                continue;
-            }
-
-            for (const runAfterRelation of runAfterRelations) {
-                const isUnknownRelation: boolean = normalizedNodeTransformers[runAfterRelation] === undefined;
-
-                if (isUnknownRelation) {
-                    relationEdges.push([nodeTransformerName, null]);
-                    continue;
-                }
-
-                relationEdges.push([runAfterRelation, nodeTransformerName]);
-            }
-        }
-
-        return relationEdges;
-    }
-}