@esportsplus/typescript 0.10.2 → 0.12.0

package/build/transformer/constants.d.ts

@@ -0,0 +1,4 @@
+declare const BRACES_CONTENT_REGEX: RegExp;
+declare const REGEX_ESCAPE_PATTERN: RegExp;
+declare const UUID_DASH_REGEX: RegExp;
+export { BRACES_CONTENT_REGEX, REGEX_ESCAPE_PATTERN, UUID_DASH_REGEX };

package/build/transformer/constants.js

@@ -0,0 +1,4 @@
+const BRACES_CONTENT_REGEX = /\{([^}]*)\}/;
+const REGEX_ESCAPE_PATTERN = /[.*+?^${}()|[\]\\]/g;
+const UUID_DASH_REGEX = /-/g;
+export { BRACES_CONTENT_REGEX, REGEX_ESCAPE_PATTERN, UUID_DASH_REGEX };

package/build/transformer/index.d.ts

@@ -0,0 +1,14 @@
+import ts from 'typescript';
+import type { ImportModification, NodeMatch, QuickCheckPattern, Replacement, VisitorCallback, VisitorPredicate } from './types.js';
+import program from './program.js';
+declare const addImport: (code: string, module: string, specifiers: string[]) => string;
+declare const applyReplacements: (code: string, replacements: Replacement[]) => string;
+declare const applyReplacementsReverse: (code: string, replacements: Replacement[]) => string;
+declare const collectNodes: <T>(sourceFile: ts.SourceFile, predicate: (node: ts.Node) => T | null) => NodeMatch<T>[];
+declare const mightNeedTransform: (code: string, check: QuickCheckPattern) => boolean;
+declare const uid: (prefix?: string) => string;
+declare const updateImports: (code: string, modification: ImportModification) => string;
+declare const visitAst: <T>(sourceFile: ts.SourceFile, callback: VisitorCallback<T>, state: T, predicate?: VisitorPredicate) => T;
+declare const visitAstWithDepth: <T>(sourceFile: ts.SourceFile, callback: (node: ts.Node, depth: number, state: T) => void, state: T, depthTrigger: (node: ts.Node) => boolean) => T;
+export { addImport, applyReplacements, applyReplacementsReverse, collectNodes, mightNeedTransform, program, uid, updateImports, visitAst, visitAstWithDepth };
+export type { ImportModification, NodeMatch, QuickCheckPattern, Replacement, VisitorCallback, VisitorPredicate };

package/build/transformer/index.js

@@ -0,0 +1,158 @@
+import { uuid } from '@esportsplus/utilities';
+import ts from 'typescript';
+import { BRACES_CONTENT_REGEX, REGEX_ESCAPE_PATTERN, UUID_DASH_REGEX } from './constants.js';
+import program from './program.js';
+function buildImportRegex(escapedModule) {
+    return new RegExp(`(import\\s*\\{[^}]*\\}\\s*from\\s*['"]${escapedModule}['"])`);
+}
+function mergeAndSort(a, b) {
+    let combined = new Array(a.length + b.size), idx = 0, n = a.length;
+    for (let i = 0; i < n; i++) {
+        if (a[i]) {
+            combined[idx++] = a[i];
+        }
+    }
+    for (let item of b) {
+        if (item) {
+            combined[idx++] = item;
+        }
+    }
+    combined.length = idx;
+    combined.sort();
+    return combined.join(', ');
+}
+function parseSpecifiers(str) {
+    let parts = str.split(','), result = new Set();
+    for (let i = 0, n = parts.length; i < n; i++) {
+        let trimmed = parts[i].trim();
+        if (trimmed) {
+            result.add(trimmed);
+        }
+    }
+    return result;
+}
+function updateImportsWithRegex(code, specifiers, importRegex) {
+    let match = code.match(importRegex);
+    if (!match) {
+        return code;
+    }
+    let bracesMatch = match[1].match(BRACES_CONTENT_REGEX), existing = bracesMatch?.[1] ? parseSpecifiers(bracesMatch[1]) : new Set(), toAdd = [];
+    for (let spec of specifiers) {
+        if (!existing.has(spec)) {
+            toAdd.push(spec);
+        }
+    }
+    if (toAdd.length === 0) {
+        return code;
+    }
+    return code.replace(match[1], match[1].replace(BRACES_CONTENT_REGEX, `{ ${mergeAndSort(toAdd, existing)} }`));
+}
+const addImport = (code, module, specifiers) => {
+    if (specifiers.length === 0) {
+        return code;
+    }
+    let regex = buildImportRegex(module.replace(REGEX_ESCAPE_PATTERN, '\\$&'));
+    if (regex.test(code)) {
+        return updateImportsWithRegex(code, new Set(specifiers), regex);
+    }
+    let adding = `import { ${specifiers.sort().join(', ')} } from '${module}';\n`, first = code.indexOf('import ');
+    if (first === -1) {
+        return adding + code;
+    }
+    return code.substring(0, first) + adding + code.substring(first);
+};
+const applyReplacements = (code, replacements) => {
+    if (replacements.length === 0) {
+        return code;
+    }
+    replacements.sort((a, b) => a.start - b.start);
+    let parts = [], pos = 0;
+    for (let i = 0, n = replacements.length; i < n; i++) {
+        let r = replacements[i];
+        if (r.start > pos) {
+            parts.push(code.substring(pos, r.start));
+        }
+        parts.push(r.newText);
+        pos = r.end;
+    }
+    if (pos < code.length) {
+        parts.push(code.substring(pos));
+    }
+    return parts.join('');
+};
+const applyReplacementsReverse = (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 collectNodes = (sourceFile, predicate) => {
+    let matches = [];
+    function visit(node) {
+        let data = predicate(node);
+        if (data !== null) {
+            matches.push({
+                data,
+                end: node.end,
+                node,
+                start: node.getStart(sourceFile)
+            });
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return matches;
+};
+const mightNeedTransform = (code, check) => {
+    if (check.regex) {
+        return check.regex.test(code);
+    }
+    if (check.patterns) {
+        for (let i = 0, n = check.patterns.length; i < n; i++) {
+            if (code.indexOf(check.patterns[i]) !== -1) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
+const uid = (prefix) => {
+    return (prefix ? prefix + '_' : '_') + uuid().replace(UUID_DASH_REGEX, '_');
+};
+const updateImports = (code, modification) => {
+    let { module, specifiers } = modification;
+    if (specifiers.size === 0) {
+        return code;
+    }
+    let escapedModule = module.replace(REGEX_ESCAPE_PATTERN, '\\$&'), importRegex = buildImportRegex(escapedModule);
+    return updateImportsWithRegex(code, specifiers, importRegex);
+};
+const visitAst = (sourceFile, callback, state, predicate) => {
+    function visit(node) {
+        if (!predicate || predicate(node)) {
+            callback(node, state);
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return state;
+};
+const visitAstWithDepth = (sourceFile, callback, state, depthTrigger) => {
+    let depthStack = [0];
+    function visit(node) {
+        let depth = depthStack[depthStack.length - 1], nextDepth = depthTrigger(node) ? depth + 1 : depth;
+        callback(node, depth, state);
+        depthStack.push(nextDepth);
+        ts.forEachChild(node, visit);
+        depthStack.pop();
+    }
+    visit(sourceFile);
+    return state;
+};
+export { addImport, applyReplacements, applyReplacementsReverse, collectNodes, mightNeedTransform, program, uid, updateImports, visitAst, visitAstWithDepth };

package/build/transformer/program.d.ts

@@ -0,0 +1,6 @@
+import ts from 'typescript';
+declare const _default: {
+    get: (root: string) => ts.Program;
+    delete: (root: string) => void;
+};
+export default _default;

package/build/transformer/program.js

@@ -0,0 +1,33 @@
+import path from 'path';
+import ts from 'typescript';
+let cache = new Map();
+function create(root) {
+    let tsconfig = ts.findConfigFile(root, ts.sys.fileExists, 'tsconfig.json');
+    if (!tsconfig) {
+        throw new Error('tsconfig.json not found');
+    }
+    let file = ts.readConfigFile(tsconfig, ts.sys.readFile);
+    if (file.error) {
+        throw new Error(`Error reading tsconfig.json: ${file.error.messageText}`);
+    }
+    let parsed = ts.parseJsonConfigFileContent(file.config, ts.sys, path.dirname(tsconfig));
+    if (parsed.errors.length > 0) {
+        throw new Error(`Error parsing tsconfig.json: ${parsed.errors[0].messageText}`);
+    }
+    return ts.createProgram({
+        options: parsed.options,
+        rootNames: parsed.fileNames
+    });
+}
+const get = (root) => {
+    let program = cache.get(root);
+    if (!program) {
+        program = create(root);
+        cache.set(root, program);
+    }
+    return program;
+};
+const del = (root) => {
+    cache.delete(root);
+};
+export default { get, delete: del };

package/build/transformer/types.d.ts

@@ -0,0 +1,23 @@
+import ts from 'typescript';
+type ImportModification = {
+    module: string;
+    specifiers: Set<string>;
+};
+type NodeMatch<T> = {
+    data: T;
+    end: number;
+    node: ts.Node;
+    start: number;
+};
+type QuickCheckPattern = {
+    patterns?: string[];
+    regex?: RegExp;
+};
+type Replacement = {
+    end: number;
+    newText: string;
+    start: number;
+};
+type VisitorCallback<T> = (node: ts.Node, state: T) => void;
+type VisitorPredicate = (node: ts.Node) => boolean;
+export type { ImportModification, NodeMatch, QuickCheckPattern, Replacement, VisitorCallback, VisitorPredicate };

package/build/transformer/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -6,6 +6,8 @@
   },
   "dependencies": {
     "@esportsplus/cli-passthrough": "^0.0.12",
+    "@esportsplus/utilities": "^0.27.2",
+    "@types/node": "^25.0.3",
     "tsc-alias": "^1.8.16",
     "typescript": "^5.9.3"
   },
@@ -14,6 +16,10 @@
     "./tsconfig.browser.json": "./tsconfig.browser.json",
     "./tsconfig.node.json": "./tsconfig.node.json",
     "./tsconfig.package.json": "./tsconfig.package.json",
+    "./transformer": {
+      "types": "./build/transformer/index.d.ts",
+      "default": "./build/transformer/index.js"
+    },
     ".": {
       "types": "./build/index.d.ts",
       "default": "./build/index.js"
@@ -28,7 +34,7 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.10.2",
+  "version": "0.12.0",
   "scripts": {
     "build": "tsc && tsc-alias",
     "-": "-"

package/src/transformer/constants.ts

@@ -0,0 +1,8 @@
+const BRACES_CONTENT_REGEX = /\{([^}]*)\}/;
+
+const REGEX_ESCAPE_PATTERN = /[.*+?^${}()|[\]\\]/g;
+
+const UUID_DASH_REGEX = /-/g;
+
+
+export {  BRACES_CONTENT_REGEX, REGEX_ESCAPE_PATTERN, UUID_DASH_REGEX };

package/src/transformer/index.ts

@@ -0,0 +1,258 @@
+import { uuid } from '@esportsplus/utilities';
+import ts from 'typescript';
+import { BRACES_CONTENT_REGEX, REGEX_ESCAPE_PATTERN, UUID_DASH_REGEX } from './constants.js';
+import type { ImportModification, NodeMatch, QuickCheckPattern, Replacement, VisitorCallback, VisitorPredicate } from './types.js';
+import program from './program';
+
+
+function buildImportRegex(escapedModule: string): RegExp {
+    return new RegExp(`(import\\s*\\{[^}]*\\}\\s*from\\s*['"]${escapedModule}['"])`);
+}
+
+function mergeAndSort(a: string[], b: Set<string>): string {
+    let combined = new Array<string>(a.length + b.size),
+        idx = 0,
+        n = a.length;
+
+    for (let i = 0; i < n; i++) {
+        if (a[i]) {
+            combined[idx++] = a[i];
+        }
+    }
+
+    for (let item of b) {
+        if (item) {
+            combined[idx++] = item;
+        }
+    }
+
+    combined.length = idx;
+    combined.sort();
+
+    return combined.join(', ');
+}
+
+function parseSpecifiers(str: string): Set<string> {
+    let parts = str.split(','),
+        result = new Set<string>();
+
+    for (let i = 0, n = parts.length; i < n; i++) {
+        let trimmed = parts[i].trim();
+
+        if (trimmed) {
+            result.add(trimmed);
+        }
+    }
+
+    return result;
+}
+
+function updateImportsWithRegex(code: string, specifiers: Set<string>, importRegex: RegExp): string {
+    let match = code.match(importRegex);
+
+    if (!match) {
+        return code;
+    }
+
+    let bracesMatch = match[1].match(BRACES_CONTENT_REGEX),
+        existing = bracesMatch?.[1] ? parseSpecifiers(bracesMatch[1]) : new Set<string>(),
+        toAdd: string[] = [];
+
+    for (let spec of specifiers) {
+        if (!existing.has(spec)) {
+            toAdd.push(spec);
+        }
+    }
+
+    if (toAdd.length === 0) {
+        return code;
+    }
+
+    return code.replace(
+        match[1],
+        match[1].replace(BRACES_CONTENT_REGEX, `{ ${mergeAndSort(toAdd, existing)} }`)
+    );
+}
+
+
+const addImport = (code: string, module: string, specifiers: string[]): string => {
+    if (specifiers.length === 0) {
+        return code;
+    }
+
+    let regex = buildImportRegex( module.replace(REGEX_ESCAPE_PATTERN, '\\$&') );
+
+    if (regex.test(code)) {
+        return updateImportsWithRegex(code, new Set(specifiers), regex);
+    }
+
+    let adding = `import { ${specifiers.sort().join(', ')} } from '${module}';\n`,
+        first = code.indexOf('import ');
+
+    if (first === -1) {
+        return adding + code;
+    }
+
+    return code.substring(0, first) + adding + code.substring(first);
+};
+
+const applyReplacements = (code: string, replacements: Replacement[]): string => {
+    if (replacements.length === 0) {
+        return code;
+    }
+
+    replacements.sort((a, b) => a.start - b.start);
+
+    let parts: string[] = [],
+        pos = 0;
+
+    for (let i = 0, n = replacements.length; i < n; i++) {
+        let r = replacements[i];
+
+        if (r.start > pos) {
+            parts.push(code.substring(pos, r.start));
+        }
+
+        parts.push(r.newText);
+        pos = r.end;
+    }
+
+    if (pos < code.length) {
+        parts.push(code.substring(pos));
+    }
+
+    return parts.join('');
+};
+
+const applyReplacementsReverse = (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;
+};
+
+const collectNodes = <T>(sourceFile: ts.SourceFile, predicate: (node: ts.Node) => T | null): NodeMatch<T>[] => {
+    let matches: NodeMatch<T>[] = [];
+
+    function visit(node: ts.Node): void {
+        let data = predicate(node);
+
+        if (data !== null) {
+            matches.push({
+                data,
+                end: node.end,
+                node,
+                start: node.getStart(sourceFile)
+            });
+        }
+
+        ts.forEachChild(node, visit);
+    }
+
+    visit(sourceFile);
+
+    return matches;
+};
+
+const mightNeedTransform = (code: string, check: QuickCheckPattern): boolean => {
+    if (check.regex) {
+        return check.regex.test(code);
+    }
+
+    if (check.patterns) {
+        for (let i = 0, n = check.patterns.length; i < n; i++) {
+            if (code.indexOf(check.patterns[i]) !== -1) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+};
+
+const uid = (prefix?: string): string => {
+    return (prefix ? prefix + '_' : '_') + uuid().replace(UUID_DASH_REGEX, '_');
+};
+
+const updateImports = (code: string, modification: ImportModification): string => {
+    let { module, specifiers } = modification;
+
+    if (specifiers.size === 0) {
+        return code;
+    }
+
+    let escapedModule = module.replace(REGEX_ESCAPE_PATTERN, '\\$&'),
+        importRegex = buildImportRegex(escapedModule);
+
+    return updateImportsWithRegex(code, specifiers, importRegex);
+};
+
+const visitAst = <T>(
+    sourceFile: ts.SourceFile,
+    callback: VisitorCallback<T>,
+    state: T,
+    predicate?: VisitorPredicate
+): T => {
+    function visit(node: ts.Node): void {
+        if (!predicate || predicate(node)) {
+            callback(node, state);
+        }
+
+        ts.forEachChild(node, visit);
+    }
+
+    visit(sourceFile);
+
+    return state;
+};
+
+const visitAstWithDepth = <T>(
+    sourceFile: ts.SourceFile,
+    callback: (node: ts.Node, depth: number, state: T) => void,
+    state: T,
+    depthTrigger: (node: ts.Node) => boolean
+): T => {
+    let depthStack: number[] = [0];
+
+    function visit(node: ts.Node): void {
+        let depth = depthStack[depthStack.length - 1],
+            nextDepth = depthTrigger(node) ? depth + 1 : depth;
+
+        callback(node, depth, state);
+        depthStack.push(nextDepth);
+        ts.forEachChild(node, visit);
+        depthStack.pop();
+    }
+
+    visit(sourceFile);
+
+    return state;
+};
+
+
+export {
+    addImport, applyReplacements, applyReplacementsReverse,
+    collectNodes,
+    mightNeedTransform,
+    program,
+    uid, updateImports,
+    visitAst, visitAstWithDepth
+};
+export type {
+    ImportModification,
+    NodeMatch,
+    QuickCheckPattern,
+    Replacement,
+    VisitorCallback, VisitorPredicate
+};

package/src/transformer/program.ts

@@ -0,0 +1,54 @@
+import path from 'path';
+import ts from 'typescript';
+
+
+let cache = new Map<string, ts.Program>();
+
+
+function create(root: string): ts.Program {
+    let tsconfig = ts.findConfigFile(root, ts.sys.fileExists, 'tsconfig.json');
+
+    if (!tsconfig) {
+        throw new Error('tsconfig.json not found');
+    }
+
+    let file = ts.readConfigFile(tsconfig, ts.sys.readFile);
+
+    if (file.error) {
+        throw new Error(`Error reading tsconfig.json: ${file.error.messageText}`);
+    }
+
+    let parsed = ts.parseJsonConfigFileContent(
+            file.config,
+            ts.sys,
+            path.dirname(tsconfig)
+        );
+
+    if (parsed.errors.length > 0) {
+        throw new Error(`Error parsing tsconfig.json: ${parsed.errors[0].messageText}`);
+    }
+
+    return ts.createProgram({
+        options: parsed.options,
+        rootNames: parsed.fileNames
+    });
+}
+
+
+const get = (root: string): ts.Program => {
+    let program = cache.get(root);
+
+    if (!program) {
+        program = create(root);
+        cache.set(root, program);
+    }
+
+    return program;
+}
+
+const del = (root: string): void => {
+    cache.delete(root);
+}
+
+
+export default { get, delete: del };

package/src/transformer/types.ts

@@ -0,0 +1,38 @@
+import ts from 'typescript';
+
+
+type ImportModification = {
+    module: string;
+    specifiers: Set<string>;
+};
+
+type NodeMatch<T> = {
+    data: T;
+    end: number;
+    node: ts.Node;
+    start: number;
+};
+
+type QuickCheckPattern = {
+    patterns?: string[];
+    regex?: RegExp;
+};
+
+type Replacement = {
+    end: number;
+    newText: string;
+    start: number;
+};
+
+type VisitorCallback<T> = (node: ts.Node, state: T) => void;
+
+type VisitorPredicate = (node: ts.Node) => boolean;
+
+
+export type {
+    ImportModification,
+    NodeMatch,
+    QuickCheckPattern,
+    Replacement,
+    VisitorCallback, VisitorPredicate
+};