@esportsplus/typescript 0.25.2 → 0.26.1

package/build/compiler/code.d.ts

@@ -1,5 +1,5 @@
-import type { Replacement } from './types.js';
-declare const _default: {
-    replaceReverse: (code: string, replacements: Replacement[]) => string;
+declare const code: {
+    (literals: TemplateStringsArray, ...values: unknown[]): string;
+    escape(str: string): string;
 };
-export default _default;
+export default code;

package/build/compiler/code.js

@@ -1,13 +1,15 @@
-const replaceReverse = (code, replacements) => {
-    if (replacements.length === 0) {
-        return code;
+const SINGLE_QUOTE_REGEX = /'/g;
+const code = (literals, ...values) => {
+    let buffer = '';
+    for (let i = 0, n = literals.length; i < n; i++) {
+        buffer += literals[i];
+        if (values[i] !== undefined) {
+            buffer += values[i];
+        }
     }
-    replacements.sort((a, b) => b.start - a.start);
-    let result = code;
-    for (let i = 0, n = replacements.length; i < n; i++) {
-        let r = replacements[i];
-        result = result.substring(0, r.start) + r.newText + result.substring(r.end);
-    }
-    return result;
+    return buffer;
+};
+code.escape = (str) => {
+    return str.replace(SINGLE_QUOTE_REGEX, "\\'");
 };
-export default { replaceReverse };
+export default code;

package/build/compiler/coordinator.js

@@ -1,11 +1,10 @@
 import { ts } from '../index.js';
-import code from './code.js';
 import imports from './imports.js';
 function applyImports(sourceCode, sourceFile, intents) {
     let result = sourceCode;
     for (let i = 0, n = intents.length; i < n; i++) {
         let intent = intents[i];
-        result = imports.modify(result, sourceFile, intent.package, {
+        result = modify(result, sourceFile, intent.package, {
             add: intent.add,
             namespace: intent.namespace,
             remove: intent.remove
@@ -20,12 +19,11 @@ function applyIntents(sourceCode, sourceFile, intents) {
     if (intents.length === 0) {
         return sourceCode;
     }
-    let replacements = intents.map(intent => ({
+    return replaceReverse(sourceCode, intents.map(intent => ({
         end: intent.node.end,
         newText: intent.generate(sourceFile),
         start: intent.node.getStart(sourceFile)
-    }));
-    return code.replaceReverse(sourceCode, replacements);
+    })));
 }
 function applyPrepend(sourceCode, sourceFile, prepend) {
     if (prepend.length === 0) {
@@ -58,6 +56,67 @@ function hasPattern(sourceCode, patterns) {
     }
     return false;
 }
+const modify = (sourceCode, sourceFile, packageName, options) => {
+    let { namespace } = options;
+    if (!options.add && !options.namespace && !options.remove) {
+        return sourceCode;
+    }
+    let add = options.add ? new Set(options.add) : null, found = imports.find(sourceFile, packageName), remove = options.remove ? new Set(options.remove) : null;
+    if (found.length === 0) {
+        let statements = [];
+        if (namespace) {
+            statements.push(`import * as ${namespace} from '${packageName}';`);
+        }
+        if (add && add.size > 0) {
+            statements.push(`import { ${[...add].sort().join(', ')} } from '${packageName}';`);
+        }
+        if (statements.length === 0) {
+            return sourceCode;
+        }
+        return statements.join('\n') + '\n' + sourceCode;
+    }
+    let specifiers = new Set();
+    for (let i = 0, n = found.length; i < n; i++) {
+        for (let [name, alias] of found[i].specifiers) {
+            if (!remove || (!remove.has(name) && !remove.has(alias))) {
+                specifiers.add(name === alias ? name : `${name} as ${alias}`);
+            }
+        }
+    }
+    if (add) {
+        for (let name of add) {
+            specifiers.add(name);
+        }
+    }
+    let statements = [];
+    if (namespace) {
+        statements.push(`import * as ${namespace} from '${packageName}';`);
+    }
+    if (specifiers.size > 0) {
+        statements.push(`import { ${[...specifiers].sort().join(', ')} } from '${packageName}';`);
+    }
+    let replacements = [];
+    for (let i = 0, n = found.length; i < n; i++) {
+        replacements.push({
+            end: found[i].end,
+            newText: i === 0 ? statements.join('\n') : '',
+            start: found[i].start
+        });
+    }
+    return replaceReverse(sourceCode, replacements);
+};
+const replaceReverse = (code, replacements) => {
+    if (replacements.length === 0) {
+        return code;
+    }
+    replacements.sort((a, b) => b.start - a.start);
+    let result = code;
+    for (let i = 0, n = replacements.length; i < n; i++) {
+        let r = replacements[i];
+        result = result.substring(0, r.start) + r.newText + result.substring(r.end);
+    }
+    return result;
+};
 const transform = (plugins, sourceCode, sourceFile, program, shared) => {
     if (plugins.length === 0) {
         return { changed: false, code: sourceCode, sourceFile };

package/build/compiler/imports.d.ts

@@ -11,9 +11,7 @@ type ModifyOptions = {
 };
 declare const _default: {
     find: (sourceFile: ts.SourceFile, packageName: string) => ImportInfo[];
-    isFromPackage: (checker: ts.TypeChecker, node: ts.Node, packageName: string, symbolName?: string) => boolean;
-    modify: (sourceCode: string, sourceFile: ts.SourceFile, packageName: string, options: ModifyOptions) => string;
-    trace: (node: ts.Identifier, checker: ts.TypeChecker) => string | null;
+    inPackage: (checker: ts.TypeChecker, node: ts.Node, pkg: string, symbolName?: string, packageImports?: Set<string>) => boolean;
 };
 export default _default;
 export type { ImportInfo, ModifyOptions };

package/build/compiler/imports.js

@@ -1,5 +1,4 @@
 import { ts } from '../index.js';
-import code from './code.js';
 const find = (sourceFile, packageName) => {
     let imports = [];
     for (let i = 0, n = sourceFile.statements.length; i < n; i++) {
@@ -22,89 +21,34 @@ const find = (sourceFile, packageName) => {
     }
     return imports;
 };
-const isFromPackage = (checker, node, packageName, symbolName) => {
+const inPackage = (checker, node, pkg, symbolName, packageImports) => {
+    if (packageImports && ts.isIdentifier(node) && packageImports.has(node.text)) {
+        if (!symbolName || node.text === symbolName) {
+            return true;
+        }
+    }
     let symbol = checker.getSymbolAtLocation(node);
     if (!symbol) {
+        if (packageImports && ts.isIdentifier(node) && packageImports.has(node.text)) {
+            return true;
+        }
         return false;
     }
     if (symbol.flags & ts.SymbolFlags.Alias) {
         symbol = checker.getAliasedSymbol(symbol);
     }
     if (symbolName && symbol.name !== symbolName) {
-        return false;
+        return packageImports ? ts.isIdentifier(node) && packageImports.has(node.text) : false;
     }
     let declarations = symbol.getDeclarations();
     if (!declarations || declarations.length === 0) {
-        return false;
+        return packageImports ? ts.isIdentifier(node) && packageImports.has(node.text) : false;
     }
     for (let i = 0, n = declarations.length; i < n; i++) {
-        if (declarations[i].getSourceFile().fileName.includes(packageName)) {
+        if (declarations[i].getSourceFile().fileName.includes(pkg)) {
             return true;
         }
     }
-    return false;
-};
-const modify = (sourceCode, sourceFile, packageName, options) => {
-    let { namespace } = options;
-    if (!options.add && !options.namespace && !options.remove) {
-        return sourceCode;
-    }
-    let add = options.add ? new Set(options.add) : null, imports = find(sourceFile, packageName), remove = options.remove ? new Set(options.remove) : null;
-    if (imports.length === 0) {
-        let statements = [];
-        if (namespace) {
-            statements.push(`import * as ${namespace} from '${packageName}';`);
-        }
-        if (add && add.size > 0) {
-            statements.push(`import { ${[...add].sort().join(', ')} } from '${packageName}';`);
-        }
-        if (statements.length === 0) {
-            return sourceCode;
-        }
-        return statements.join('\n') + '\n' + sourceCode;
-    }
-    let specifiers = new Set();
-    for (let i = 0, n = imports.length; i < n; i++) {
-        for (let [name, alias] of imports[i].specifiers) {
-            if (!remove || (!remove.has(name) && !remove.has(alias))) {
-                specifiers.add(name === alias ? name : `${name} as ${alias}`);
-            }
-        }
-    }
-    if (add) {
-        for (let name of add) {
-            specifiers.add(name);
-        }
-    }
-    let statements = [];
-    if (namespace) {
-        statements.push(`import * as ${namespace} from '${packageName}';`);
-    }
-    if (specifiers.size > 0) {
-        statements.push(`import { ${[...specifiers].sort().join(', ')} } from '${packageName}';`);
-    }
-    let replacements = [];
-    for (let i = 0, n = imports.length; i < n; i++) {
-        replacements.push({
-            end: imports[i].end,
-            newText: i === 0 ? statements.join('\n') : '',
-            start: imports[i].start
-        });
-    }
-    return code.replaceReverse(sourceCode, replacements);
-};
-const trace = (node, checker) => {
-    let symbol = checker.getSymbolAtLocation(node);
-    if (!symbol) {
-        return null;
-    }
-    if (symbol.flags & ts.SymbolFlags.Alias) {
-        symbol = checker.getAliasedSymbol(symbol);
-    }
-    let declarations = symbol.getDeclarations();
-    if (!declarations || declarations.length === 0) {
-        return null;
-    }
-    return declarations[0].getSourceFile().fileName;
+    return packageImports ? ts.isIdentifier(node) && packageImports.has(node.text) : false;
 };
-export default { find, isFromPackage, modify, trace };
+export default { find, inPackage };

package/package.json

@@ -37,7 +37,7 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.25.2",
+  "version": "0.26.1",
   "scripts": {
     "build": "tsc && tsc-alias",
     "-": "-"

package/src/compiler/code.ts

@@ -1,23 +1,23 @@
-import type { Replacement } from './types';
+const SINGLE_QUOTE_REGEX = /'/g;
 
 
-const replaceReverse = (code: string, replacements: Replacement[]): string => {
-    if (replacements.length === 0) {
-        return code;
-    }
-
-    replacements.sort((a, b) => b.start - a.start);
-
-    let result = code;
+const code = (literals: TemplateStringsArray, ...values: unknown[]): string => {
+    let buffer = '';
 
-    for (let i = 0, n = replacements.length; i < n; i++) {
-        let r = replacements[i];
+    for (let i = 0, n = literals.length; i < n; i++) {
+        buffer += literals[i];
 
-        result = result.substring(0, r.start) + r.newText + result.substring(r.end);
+        if (values[i] !== undefined) {
+            buffer += values[i];
+        }
     }
 
-    return result;
+    return buffer;
+};
+
+code.escape = (str: string): string => {
+    return str.replace(SINGLE_QUOTE_REGEX, "\\'");
 };
 
 
-export default { replaceReverse };
+export default code;

package/src/compiler/coordinator.ts

@@ -1,7 +1,6 @@
-import type { ImportIntent, Plugin, ReplacementIntent, SharedContext } from './types';
+import type { ImportIntent, Plugin, Replacement, ReplacementIntent, SharedContext } from './types';
 import { ts } from '~/index';
-import code from './code';
-import imports from './imports';
+import imports, { ModifyOptions } from './imports';
 
 
 type CoordinatorResult = {
@@ -21,7 +20,7 @@ function applyImports(
     for (let i = 0, n = intents.length; i < n; i++) {
         let intent = intents[i];
 
-        result = imports.modify(result, sourceFile, intent.package, {
+        result = modify(result, sourceFile, intent.package, {
             add: intent.add,
             namespace: intent.namespace,
             remove: intent.remove
@@ -49,13 +48,14 @@ function applyIntents(
         return sourceCode;
     }
 
-    let replacements = intents.map(intent => ({
-        end: intent.node.end,
-        newText: intent.generate(sourceFile),
-        start: intent.node.getStart(sourceFile)
-    }));
-
-    return code.replaceReverse(sourceCode, replacements);
+    return replaceReverse(
+        sourceCode,
+        intents.map(intent => ({
+            end: intent.node.end,
+            newText: intent.generate(sourceFile),
+            start: intent.node.getStart(sourceFile)
+        }))
+    );
 }
 
 function applyPrepend(sourceCode: string, sourceFile: ts.SourceFile, prepend: string[]): string {
@@ -100,6 +100,101 @@ function hasPattern(sourceCode: string, patterns: string[]): boolean {
     return false;
 }
 
+const modify = (
+    sourceCode: string,
+    sourceFile: ts.SourceFile,
+    packageName: string,
+    options: ModifyOptions
+): string => {
+    let { namespace } = options;
+
+    // Fast path: nothing to change
+    if (!options.add && !options.namespace && !options.remove) {
+        return sourceCode;
+    }
+
+    let add = options.add ? new Set(options.add) : null,
+        found = imports.find(sourceFile, packageName),
+        remove = options.remove ? new Set(options.remove) : null;
+
+    if (found.length === 0) {
+        let statements: string[] = [];
+
+        if (namespace) {
+            statements.push(`import * as ${namespace} from '${packageName}';`);
+        }
+
+        if (add && add.size > 0) {
+            statements.push(`import { ${[...add].sort().join(', ')} } from '${packageName}';`);
+        }
+
+        if (statements.length === 0) {
+            return sourceCode;
+        }
+
+        return statements.join('\n') + '\n' + sourceCode;
+    }
+
+    // Collect all non-removed specifiers from existing imports
+    let specifiers = new Set<string>();
+
+    for (let i = 0, n = found.length; i < n; i++) {
+        for (let [name, alias] of found[i].specifiers) {
+            if (!remove || (!remove.has(name) && !remove.has(alias))) {
+                specifiers.add(name === alias ? name : `${name} as ${alias}`);
+            }
+        }
+    }
+
+    if (add) {
+        for (let name of add) {
+            specifiers.add(name);
+        }
+    }
+
+    // Build replacement text - namespace import first, then named imports
+    let statements: string[] = [];
+
+    if (namespace) {
+        statements.push(`import * as ${namespace} from '${packageName}';`);
+    }
+
+    if (specifiers.size > 0) {
+        statements.push(`import { ${[...specifiers].sort().join(', ')} } from '${packageName}';`);
+    }
+
+    // Build replacements - replace first import, remove others
+    let replacements: Replacement[] = [];
+
+    for (let i = 0, n = found.length; i < n; i++) {
+        replacements.push({
+            end: found[i].end,
+            newText: i === 0 ? statements.join('\n') : '',
+            start: found[i].start
+        });
+    }
+
+    return replaceReverse(sourceCode, replacements);
+};
+
+const replaceReverse = (code: string, replacements: Replacement[]): string => {
+    if (replacements.length === 0) {
+        return code;
+    }
+
+    replacements.sort((a, b) => b.start - a.start);
+
+    let result = code;
+
+    for (let i = 0, n = replacements.length; i < n; i++) {
+        let r = replacements[i];
+
+        result = result.substring(0, r.start) + r.newText + result.substring(r.end);
+    }
+
+    return result;
+};
+
 
 /**
  * Transform source through all plugins sequentially.

package/src/compiler/imports.ts

@@ -1,6 +1,4 @@
-import type { Replacement } from './types';
 import { ts } from '~/index';
-import code from './code';
 
 
 type ImportInfo = {
@@ -53,15 +51,28 @@ const find = (sourceFile: ts.SourceFile, packageName: string): ImportInfo[] => {
 };
 
 // Check if node's symbol originates from a specific package (with optional symbol name validation)
-const isFromPackage = (
+const inPackage = (
     checker: ts.TypeChecker,
     node: ts.Node,
-    packageName: string,
-    symbolName?: string
+    pkg: string,
+    symbolName?: string,
+    packageImports?: Set<string>
 ): boolean => {
+    // Fast path: identifier matches known import and expected name
+    if (packageImports && ts.isIdentifier(node) && packageImports.has(node.text)) {
+        if (!symbolName || node.text === symbolName) {
+            return true;
+        }
+    }
+
     let symbol = checker.getSymbolAtLocation(node);
 
     if (!symbol) {
+        // Fallback: aliased import - check if local name is in imports
+        if (packageImports && ts.isIdentifier(node) && packageImports.has(node.text)) {
+            return true;
+        }
+
         return false;
     }
 
@@ -72,124 +83,25 @@ const isFromPackage = (
 
     // Check symbol name if specified
     if (symbolName && symbol.name !== symbolName) {
-        return false;
+        return packageImports ? ts.isIdentifier(node) && packageImports.has(node.text) : false;
     }
 
     let declarations = symbol.getDeclarations();
 
     if (!declarations || declarations.length === 0) {
-        return false;
+        return packageImports ? ts.isIdentifier(node) && packageImports.has(node.text) : false;
     }
 
     // Check if any declaration is from the expected package
     for (let i = 0, n = declarations.length; i < n; i++) {
-        if (declarations[i].getSourceFile().fileName.includes(packageName)) {
+        if (declarations[i].getSourceFile().fileName.includes(pkg)) {
             return true;
         }
     }
 
-    return false;
-};
-
-// Modify imports: remove specified, add needed, delete if empty
-const modify = (
-    sourceCode: string,
-    sourceFile: ts.SourceFile,
-    packageName: string,
-    options: ModifyOptions
-): string => {
-    let { namespace } = options;
-
-    // Fast path: nothing to change
-    if (!options.add && !options.namespace && !options.remove) {
-        return sourceCode;
-    }
-
-    let add = options.add ? new Set(options.add) : null,
-        imports = find(sourceFile, packageName),
-        remove = options.remove ? new Set(options.remove) : null;
-
-    if (imports.length === 0) {
-        let statements: string[] = [];
-
-        if (namespace) {
-            statements.push(`import * as ${namespace} from '${packageName}';`);
-        }
-
-        if (add && add.size > 0) {
-            statements.push(`import { ${[...add].sort().join(', ')} } from '${packageName}';`);
-        }
-
-        if (statements.length === 0) {
-            return sourceCode;
-        }
-
-        return statements.join('\n') + '\n' + sourceCode;
-    }
-
-    // Collect all non-removed specifiers from existing imports
-    let specifiers = new Set<string>();
-
-    for (let i = 0, n = imports.length; i < n; i++) {
-        for (let [name, alias] of imports[i].specifiers) {
-            if (!remove || (!remove.has(name) && !remove.has(alias))) {
-                specifiers.add(name === alias ? name : `${name} as ${alias}`);
-            }
-        }
-    }
-
-    if (add) {
-        for (let name of add) {
-            specifiers.add(name);
-        }
-    }
-
-    // Build replacement text - namespace import first, then named imports
-    let statements: string[] = [];
-
-    if (namespace) {
-        statements.push(`import * as ${namespace} from '${packageName}';`);
-    }
-
-    if (specifiers.size > 0) {
-        statements.push(`import { ${[...specifiers].sort().join(', ')} } from '${packageName}';`);
-    }
-
-    // Build replacements - replace first import, remove others
-    let replacements: Replacement[] = [];
-
-    for (let i = 0, n = imports.length; i < n; i++) {
-        replacements.push({
-            end: imports[i].end,
-            newText: i === 0 ? statements.join('\n') : '',
-            start: imports[i].start
-        });
-    }
-
-    return code.replaceReverse(sourceCode, replacements);
-};
-
-// Trace symbol through re-exports to find original declaration source file
-const trace = (node: ts.Identifier, checker: ts.TypeChecker): string | null => {
-    let symbol = checker.getSymbolAtLocation(node);
-
-    if (!symbol) {
-        return null;
-    }
-
-    if (symbol.flags & ts.SymbolFlags.Alias) {
-        symbol = checker.getAliasedSymbol(symbol);
-    }
-
-    let declarations = symbol.getDeclarations();
-
-    if (!declarations || declarations.length === 0) {
-        return null;
-    }
-
-    return declarations[0].getSourceFile().fileName;
+    return packageImports ? ts.isIdentifier(node) && packageImports.has(node.text) : false;
 };
 
 
-export default { find, isFromPackage, modify, trace };
+export default { find, inPackage };
 export type { ImportInfo, ModifyOptions };