fixed node transformers factory performance

src/container/InversifyContainerFacade.ts

@@ -1,12 +1,10 @@
 import { Container, interfaces } from 'inversify';
 import { ServiceIdentifiers } from './ServiceIdentifiers';
 
-import { nodeControlFlowTransformersModule } from './modules/NodeControlFlowTransformersModule';
-import { nodeObfuscatorsModule } from './modules/NodeObfuscatorsModule';
+import { nodeTransformersModule } from './modules/NodeTransformersModule';
 
 import { ICustomNode } from '../interfaces/custom-nodes/ICustomNode';
 import { IInputOptions } from '../interfaces/IInputOptions';
-import { INodeTransformer } from '../interfaces/INodeTransformer';
 import { IObfuscationEventEmitter } from '../interfaces/IObfuscationEventEmitter';
 import { IObfuscator } from '../interfaces/IObfuscator';
 import { IOptions } from '../interfaces/IOptions';
@@ -31,9 +29,6 @@ export class InversifyContainerFacade {
     constructor (options: IInputOptions) {
         this.container = new Container();
 
-        this.container.load(nodeControlFlowTransformersModule);
-        this.container.load(nodeObfuscatorsModule);
-
         this.container
             .bind<IOptions>(ServiceIdentifiers.IOptions)
             .toDynamicValue(() => {
@@ -61,22 +56,8 @@ export class InversifyContainerFacade {
             .to(CustomNodesStorage)
             .inSingletonScope();
 
-        this.container
-            .bind<INodeTransformer[]>(ServiceIdentifiers['Factory<INodeTransformer[]>'])
-            .toFactory<INodeTransformer[]>((context: interfaces.Context) => {
-                return (nodeTransformersMap: Map<string, string[]>) => (nodeType: string) => {
-                    const nodeTransformers: string[] = nodeTransformersMap.get(nodeType) || [];
-                    const instancesArray: INodeTransformer[] = [];
-
-                    nodeTransformers.forEach((transformer: string) => {
-                        instancesArray.push(
-                            context.container.getNamed<INodeTransformer>('INodeTransformer', transformer)
-                        );
-                    });
-
-                    return instancesArray;
-                };
-            });
+        // modules
+        this.container.load(nodeTransformersModule);
     }
 
     /**

src/container/modules/NodeControlFlowTransformersModule.ts

@@ -1,12 +0,0 @@
-import { ContainerModule, interfaces } from 'inversify';
-
-import { INodeTransformer } from '../../interfaces/INodeTransformer';
-
-import { FunctionControlFlowTransformer } from '../../node-transformers/node-control-flow-transformers/FunctionControlFlowTransformer';
-
-export const nodeControlFlowTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
-    bind<INodeTransformer>('INodeTransformer')
-        .to(FunctionControlFlowTransformer)
-        .inSingletonScope()
-        .whenTargetNamed('FunctionControlFlowTransformer');
-});

src/container/modules/NodeObfuscatorsModule.ts → src/container/modules/NodeTransformersModule.ts

@@ -1,7 +1,10 @@
 import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../ServiceIdentifiers';
 
 import { INodeTransformer } from '../../interfaces/INodeTransformer';
 
+import { FunctionControlFlowTransformer } from '../../node-transformers/node-control-flow-transformers/FunctionControlFlowTransformer';
+
 import { CatchClauseObfuscator } from '../../node-transformers/node-obfuscators/CatchClauseObfuscator';
 import { FunctionDeclarationObfuscator } from '../../node-transformers/node-obfuscators/FunctionDeclarationObfuscator';
 import { FunctionObfuscator } from '../../node-transformers/node-obfuscators/FunctionObfuscator';
@@ -12,7 +15,12 @@ import { MethodDefinitionObfuscator } from '../../node-transformers/node-obfusca
 import { ObjectExpressionObfuscator } from '../../node-transformers/node-obfuscators/ObjectExpressionObfuscator';
 import { VariableDeclarationObfuscator } from '../../node-transformers/node-obfuscators/VariableDeclarationObfuscator';
 
-export const nodeObfuscatorsModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+export const nodeTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    bind<INodeTransformer>('INodeTransformer')
+        .to(FunctionControlFlowTransformer)
+        .inSingletonScope()
+        .whenTargetNamed('FunctionControlFlowTransformer');
+
     bind<INodeTransformer>('INodeTransformer')
         .to(CatchClauseObfuscator)
         .inSingletonScope()
@@ -57,4 +65,29 @@ export const nodeObfuscatorsModule: interfaces.ContainerModule = new ContainerMo
         .to(VariableDeclarationObfuscator)
         .inSingletonScope()
         .whenTargetNamed('VariableDeclarationObfuscator');
+
+    bind<INodeTransformer[]>(ServiceIdentifiers['Factory<INodeTransformer[]>'])
+        .toFactory<INodeTransformer[]>((context: interfaces.Context) => {
+            const cache: Map <string, INodeTransformer> = new Map <string, INodeTransformer> ();
+
+            return (nodeTransformersMap: Map<string, string[]>) => (nodeType: string) => {
+                const nodeTransformers: string[] = nodeTransformersMap.get(nodeType) || [];
+                const instancesArray: INodeTransformer[] = [];
+
+                nodeTransformers.forEach((transformer: string) => {
+                    let nodeTransformer: INodeTransformer;
+
+                    if (!cache.has(transformer)) {
+                        nodeTransformer = context.container.getNamed<INodeTransformer>('INodeTransformer', transformer);
+                        cache.set(transformer, nodeTransformer);
+                    } else {
+                        nodeTransformer = <INodeTransformer>cache.get(transformer);
+                    }
+
+                    instancesArray.push(nodeTransformer);
+                });
+
+                return instancesArray;
+            };
+        });
 });