Added `storeThroughName` method to the IIdentifierReplacer

dist/index.cli.js

@@ -11443,13 +11443,6 @@ let DeadCodeInjectionIdentifiersTransformer = class DeadCodeInjectionIdentifiers
     constructor(identifierReplacer, randomGenerator, scopeIdentifiersTraverser, identifierNamesCacheStorage, options) {
         super(identifierReplacer, randomGenerator, scopeIdentifiersTraverser, identifierNamesCacheStorage, options);
     }
-    transformNode(programNode, parentNode) {
-        this.scopeIdentifiersTraverser.traverseScopeThroughIdentifiers(programNode, parentNode, (data) => {
-            const { isGlobalDeclaration, reference, variableLexicalScopeNode } = data;
-            this.transformScopeThroughIdentifiers(reference, variableLexicalScopeNode, isGlobalDeclaration);
-        });
-        return programNode;
-    }
     storeIdentifierName(identifierNode, lexicalScopeNode) {
         this.identifierReplacer.storeLocalName(identifierNode, lexicalScopeNode);
     }
@@ -13349,12 +13342,6 @@ let ScopeThroughIdentifiersTransformer = class ScopeThroughIdentifiersTransforme
     transformNode(programNode, parentNode) {
         this.scopeIdentifiersTraverser.traverseScopeThroughIdentifiers(programNode, parentNode, (data) => {
             const { isGlobalDeclaration, reference, variableLexicalScopeNode } = data;
-            const identifier = reference.identifier;
-            const identifierName = identifier.name;
-            const hasIdentifierNameInIdentifierNamesCache = this.identifierNamesCacheStorage.has(identifierName);
-            if (!hasIdentifierNameInIdentifierNamesCache) {
-                return;
-            }
             this.transformScopeThroughIdentifiers(reference, variableLexicalScopeNode, isGlobalDeclaration);
         });
         return programNode;
@@ -13368,12 +13355,7 @@ let ScopeThroughIdentifiersTransformer = class ScopeThroughIdentifiersTransforme
         this.replaceIdentifierName(identifier, lexicalScopeNode, reference);
     }
     storeIdentifierName(identifierNode, lexicalScopeNode, isGlobalDeclaration) {
-        if (isGlobalDeclaration) {
-            this.identifierReplacer.storeGlobalName(identifierNode, lexicalScopeNode);
-        }
-        else {
-            this.identifierReplacer.storeLocalName(identifierNode, lexicalScopeNode);
-        }
+        this.identifierReplacer.storeThroughName(identifierNode, lexicalScopeNode);
     }
     replaceIdentifierName(identifierNode, lexicalScopeNode, reference) {
         const newIdentifier = this.identifierReplacer
@@ -13432,19 +13414,11 @@ let IdentifierReplacer = class IdentifierReplacer {
         this.identifierNamesGenerator = identifierNamesGeneratorFactory(options);
     }
     storeGlobalName(identifierNode, lexicalScopeNode) {
-        var _a;
         const identifierName = identifierNode.name;
         if (this.isReservedName(identifierName)) {
             return;
         }
-        const valueFromIdentifierNamesCache = (_a = this.identifierNamesCacheStorage.get(identifierName)) !== null && _a !== void 0 ? _a : null;
-        let newIdentifierName;
-        if (valueFromIdentifierNamesCache) {
-            newIdentifierName = valueFromIdentifierNamesCache;
-        }
-        else {
-            newIdentifierName = this.identifierNamesGenerator.generateForGlobalScope();
-        }
+        const newIdentifierName = this.identifierNamesGenerator.generateForGlobalScope();
         if (!this.blockScopesMap.has(lexicalScopeNode)) {
             this.blockScopesMap.set(lexicalScopeNode, new Map());
         }
@@ -13464,6 +13438,23 @@ let IdentifierReplacer = class IdentifierReplacer {
         const namesMap = this.blockScopesMap.get(lexicalScopeNode);
         namesMap.set(identifierName, newIdentifierName);
     }
+    storeThroughName(identifierNode, lexicalScopeNode) {
+        var _a;
+        const identifierName = identifierNode.name;
+        if (this.isReservedName(identifierName)) {
+            return;
+        }
+        const newIdentifierName = (_a = this.identifierNamesCacheStorage.get(identifierName)) !== null && _a !== void 0 ? _a : null;
+        if (!newIdentifierName) {
+            return;
+        }
+        if (!this.blockScopesMap.has(lexicalScopeNode)) {
+            this.blockScopesMap.set(lexicalScopeNode, new Map());
+        }
+        const namesMap = this.blockScopesMap.get(lexicalScopeNode);
+        namesMap.set(identifierName, newIdentifierName);
+        this.identifierNamesCacheStorage.set(identifierName, newIdentifierName);
+    }
     replace(identifierNode, lexicalScopeNode) {
         let identifierName = identifierNode.name;
         if (this.blockScopesMap.has(lexicalScopeNode)) {

dist/index.js

@@ -10528,13 +10528,6 @@ let DeadCodeInjectionIdentifiersTransformer = class DeadCodeInjectionIdentifiers
     constructor(identifierReplacer, randomGenerator, scopeIdentifiersTraverser, identifierNamesCacheStorage, options) {
         super(identifierReplacer, randomGenerator, scopeIdentifiersTraverser, identifierNamesCacheStorage, options);
     }
-    transformNode(programNode, parentNode) {
-        this.scopeIdentifiersTraverser.traverseScopeThroughIdentifiers(programNode, parentNode, (data) => {
-            const { isGlobalDeclaration, reference, variableLexicalScopeNode } = data;
-            this.transformScopeThroughIdentifiers(reference, variableLexicalScopeNode, isGlobalDeclaration);
-        });
-        return programNode;
-    }
     storeIdentifierName(identifierNode, lexicalScopeNode) {
         this.identifierReplacer.storeLocalName(identifierNode, lexicalScopeNode);
     }
@@ -12416,12 +12409,6 @@ let ScopeThroughIdentifiersTransformer = class ScopeThroughIdentifiersTransforme
     transformNode(programNode, parentNode) {
         this.scopeIdentifiersTraverser.traverseScopeThroughIdentifiers(programNode, parentNode, (data) => {
             const { isGlobalDeclaration, reference, variableLexicalScopeNode } = data;
-            const identifier = reference.identifier;
-            const identifierName = identifier.name;
-            const hasIdentifierNameInIdentifierNamesCache = this.identifierNamesCacheStorage.has(identifierName);
-            if (!hasIdentifierNameInIdentifierNamesCache) {
-                return;
-            }
             this.transformScopeThroughIdentifiers(reference, variableLexicalScopeNode, isGlobalDeclaration);
         });
         return programNode;
@@ -12435,12 +12422,7 @@ let ScopeThroughIdentifiersTransformer = class ScopeThroughIdentifiersTransforme
         this.replaceIdentifierName(identifier, lexicalScopeNode, reference);
     }
     storeIdentifierName(identifierNode, lexicalScopeNode, isGlobalDeclaration) {
-        if (isGlobalDeclaration) {
-            this.identifierReplacer.storeGlobalName(identifierNode, lexicalScopeNode);
-        }
-        else {
-            this.identifierReplacer.storeLocalName(identifierNode, lexicalScopeNode);
-        }
+        this.identifierReplacer.storeThroughName(identifierNode, lexicalScopeNode);
     }
     replaceIdentifierName(identifierNode, lexicalScopeNode, reference) {
         const newIdentifier = this.identifierReplacer
@@ -12498,19 +12480,11 @@ let IdentifierReplacer = class IdentifierReplacer {
         this.identifierNamesGenerator = identifierNamesGeneratorFactory(options);
     }
     storeGlobalName(identifierNode, lexicalScopeNode) {
-        var _a;
         const identifierName = identifierNode.name;
         if (this.isReservedName(identifierName)) {
             return;
         }
-        const valueFromIdentifierNamesCache = (_a = this.identifierNamesCacheStorage.get(identifierName)) !== null && _a !== void 0 ? _a : null;
-        let newIdentifierName;
-        if (valueFromIdentifierNamesCache) {
-            newIdentifierName = valueFromIdentifierNamesCache;
-        }
-        else {
-            newIdentifierName = this.identifierNamesGenerator.generateForGlobalScope();
-        }
+        const newIdentifierName = this.identifierNamesGenerator.generateForGlobalScope();
         if (!this.blockScopesMap.has(lexicalScopeNode)) {
             this.blockScopesMap.set(lexicalScopeNode, new Map());
         }
@@ -12530,6 +12504,23 @@ let IdentifierReplacer = class IdentifierReplacer {
         const namesMap = this.blockScopesMap.get(lexicalScopeNode);
         namesMap.set(identifierName, newIdentifierName);
     }
+    storeThroughName(identifierNode, lexicalScopeNode) {
+        var _a;
+        const identifierName = identifierNode.name;
+        if (this.isReservedName(identifierName)) {
+            return;
+        }
+        const newIdentifierName = (_a = this.identifierNamesCacheStorage.get(identifierName)) !== null && _a !== void 0 ? _a : null;
+        if (!newIdentifierName) {
+            return;
+        }
+        if (!this.blockScopesMap.has(lexicalScopeNode)) {
+            this.blockScopesMap.set(lexicalScopeNode, new Map());
+        }
+        const namesMap = this.blockScopesMap.get(lexicalScopeNode);
+        namesMap.set(identifierName, newIdentifierName);
+        this.identifierNamesCacheStorage.set(identifierName, newIdentifierName);
+    }
     replace(identifierNode, lexicalScopeNode) {
         let identifierName = identifierNode.name;
         if (this.blockScopesMap.has(lexicalScopeNode)) {

src/interfaces/node-transformers/rename-identifiers-transformers/replacer/IIdentifierReplacer.ts

@@ -15,6 +15,12 @@ export interface IIdentifierReplacer {
      */
     storeLocalName (identifierNode: ESTree.Identifier, lexicalScopeNode: TNodeWithLexicalScope): void;
 
+    /**
+     * @param {Identifier} identifierNode
+     * @param {TNodeWithLexicalScope} lexicalScopeNode
+     */
+    storeThroughName (identifierNode: ESTree.Identifier, lexicalScopeNode: TNodeWithLexicalScope): void;
+
     /**
      * @param {Node} node
      * @param {TNodeWithLexicalScope} lexicalScopeNode

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

@@ -10,7 +10,6 @@ import { IIdentifierReplacer } from '../../interfaces/node-transformers/rename-i
 import { IOptions } from '../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { IScopeIdentifiersTraverser } from '../../interfaces/node/IScopeIdentifiersTraverser';
-import { IScopeThroughIdentifiersTraverserCallbackData } from '../../interfaces/node/IScopeThroughIdentifiersTraverserCallbackData';
 
 import { ScopeThroughIdentifiersTransformer } from '../rename-identifiers-transformers/ScopeThroughIdentifiersTransformer';
 
@@ -44,35 +43,6 @@ export class DeadCodeInjectionIdentifiersTransformer extends ScopeThroughIdentif
         );
     }
 
-    /**
-     * Override parent method, because we have to transform all local scope `through` identifiers
-     *
-     * @param {VariableDeclaration} programNode
-     * @param {NodeGuards} parentNode
-     * @returns {NodeGuards}
-     */
-    public override transformNode (programNode: ESTree.Program, parentNode: ESTree.Node): ESTree.Node {
-        this.scopeIdentifiersTraverser.traverseScopeThroughIdentifiers(
-            programNode,
-            parentNode,
-            (data: IScopeThroughIdentifiersTraverserCallbackData) => {
-                const {
-                    isGlobalDeclaration,
-                    reference,
-                    variableLexicalScopeNode
-                } = data;
-
-                this.transformScopeThroughIdentifiers(
-                    reference,
-                    variableLexicalScopeNode,
-                    isGlobalDeclaration
-                );
-            }
-        );
-
-        return programNode;
-    }
-
     /**
      * Override parent method, because we have to store only local scope names
      *

src/node-transformers/rename-identifiers-transformers/ScopeThroughIdentifiersTransformer.ts

@@ -98,14 +98,6 @@ export class ScopeThroughIdentifiersTransformer extends AbstractNodeTransformer
                     variableLexicalScopeNode
                 } = data;
 
-                const identifier: ESTree.Identifier = reference.identifier;
-                const identifierName: string = identifier.name;
-                const hasIdentifierNameInIdentifierNamesCache: boolean = this.identifierNamesCacheStorage.has(identifierName);
-
-                if (!hasIdentifierNameInIdentifierNamesCache) {
-                    return;
-                }
-
                 this.transformScopeThroughIdentifiers(
                     reference,
                     variableLexicalScopeNode,
@@ -118,11 +110,6 @@ export class ScopeThroughIdentifiersTransformer extends AbstractNodeTransformer
     }
 
     /**
-     * Have to store names only for identifiers that are existing in identifier names cache
-     * All other global and local `through` identifiers are expecting to be defined in
-     * other files without using identifier names cache or in third-party packages
-     * and these identifiers should not be renamed
-     *
      * @param {Reference} reference
      * @param {TNodeWithLexicalScope} lexicalScopeNode
      * @param {boolean} isGlobalDeclaration
@@ -152,11 +139,7 @@ export class ScopeThroughIdentifiersTransformer extends AbstractNodeTransformer
         lexicalScopeNode: TNodeWithLexicalScope,
         isGlobalDeclaration: boolean
     ): void {
-        if (isGlobalDeclaration) {
-            this.identifierReplacer.storeGlobalName(identifierNode, lexicalScopeNode);
-        } else {
-            this.identifierReplacer.storeLocalName(identifierNode, lexicalScopeNode);
-        }
+        this.identifierReplacer.storeThroughName(identifierNode, lexicalScopeNode);
     }
 
     /**

src/node-transformers/rename-identifiers-transformers/replacer/IdentifierReplacer.ts

@@ -53,7 +53,7 @@ export class IdentifierReplacer implements IIdentifierReplacer {
     }
 
     /**
-     * Store `nodeName` of global identifiers as key in map with random name as value.
+     * Store identifier node `name` of global identifiers as key in map with random name as value.
      * Reserved name will be ignored.
      *
      * @param {Node} identifierNode
@@ -66,14 +66,7 @@ export class IdentifierReplacer implements IIdentifierReplacer {
             return;
         }
 
-        const valueFromIdentifierNamesCache: string | null = this.identifierNamesCacheStorage.get(identifierName) ?? null;
-        let newIdentifierName: string;
-
-        if (valueFromIdentifierNamesCache) {
-            newIdentifierName = valueFromIdentifierNamesCache;
-        } else {
-            newIdentifierName = this.identifierNamesGenerator.generateForGlobalScope();
-        }
+        const newIdentifierName: string = this.identifierNamesGenerator.generateForGlobalScope();
 
         if (!this.blockScopesMap.has(lexicalScopeNode)) {
             this.blockScopesMap.set(lexicalScopeNode, new Map());
@@ -83,11 +76,12 @@ export class IdentifierReplacer implements IIdentifierReplacer {
 
         namesMap.set(identifierName, newIdentifierName);
 
+        // Have to write all global identifier names to the identifier names cache storage
         this.identifierNamesCacheStorage.set(identifierName, newIdentifierName);
     }
 
     /**
-     * Store `nodeName` of local identifier as key in map with random name as value.
+     * Store identifier node `name` of local identifier as key in map with random name as value.
      * Reserved name will be ignored.
      *
      * @param {Identifier} identifierNode
@@ -111,6 +105,37 @@ export class IdentifierReplacer implements IIdentifierReplacer {
         namesMap.set(identifierName, newIdentifierName);
     }
 
+    /**
+     * Store identifier node `name` of `through` identifiers as key in map with value from identifier names cache.
+     * Reserved name will be ignored.
+     *
+     * @param {Node} identifierNode
+     * @param {TNodeWithLexicalScope} lexicalScopeNode
+     */
+    public storeThroughName (identifierNode: ESTree.Identifier, lexicalScopeNode: TNodeWithLexicalScope): void {
+        const identifierName: string = identifierNode.name;
+
+        if (this.isReservedName(identifierName)) {
+            return;
+        }
+
+        const newIdentifierName: string | null = this.identifierNamesCacheStorage.get(identifierName) ?? null;
+
+        if (!newIdentifierName) {
+            return;
+        }
+
+        if (!this.blockScopesMap.has(lexicalScopeNode)) {
+            this.blockScopesMap.set(lexicalScopeNode, new Map());
+        }
+
+        const namesMap: Map<string, string> = <Map<string, string>>this.blockScopesMap.get(lexicalScopeNode);
+
+        namesMap.set(identifierName, newIdentifierName);
+
+        this.identifierNamesCacheStorage.set(identifierName, newIdentifierName);
+    }
+
     /**
      * @param {Identifier} identifierNode
      * @param {TNodeWithLexicalScope} lexicalScopeNode