@esportsplus/typescript 0.28.5 → 0.29.1

package/build/compiler/plugins/vite.js

@@ -1,9 +1,8 @@
 import { ts } from '../../index.js';
 import coordinator from '../coordinator.js';
-import program from '../program.js';
-const FILE_REGEX = /\.[tj]sx?$/;
+import languageService from '../language-service.js';
 const DIRECTORY_SEPARATOR_REGEX = /\\/g;
-const LINE_ENDINGS_REGEX = /\r\n/g;
+const FILE_REGEX = /\.[tj]sx?$/;
 let contexts = new Map();
 export default ({ name, onWatchChange, plugins }) => {
     return ({ root } = {}) => {
@@ -18,15 +17,16 @@ export default ({ name, onWatchChange, plugins }) => {
                     return null;
                 }
                 try {
-                    let normalizedId = id.replace(DIRECTORY_SEPARATOR_REGEX, '/'), prog = program.get(root || ''), sourceFile = prog.getSourceFile(normalizedId) || prog.getSourceFile(id);
-                    if (sourceFile && sourceFile.getText().replace(LINE_ENDINGS_REGEX, '\n') !== code.replace(LINE_ENDINGS_REGEX, '\n')) {
-                        sourceFile = undefined;
-                    }
+                    let normalizedId = id.replace(DIRECTORY_SEPARATOR_REGEX, '/'), prog = languageService.update(root || '', normalizedId, code), sourceFile = prog.getSourceFile(normalizedId);
                     if (!sourceFile) {
-                        prog = coordinator.createPatchedProgram(prog, normalizedId, code);
-                        sourceFile = prog.getSourceFile(normalizedId) || ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true);
+                        sourceFile = ts.createSourceFile(normalizedId, code, ts.ScriptTarget.Latest, true);
+                    }
+                    let key = root || '', ctx = contexts.get(key);
+                    if (!ctx) {
+                        ctx = new Map();
+                        contexts.set(key, ctx);
                     }
-                    let result = coordinator.transform(plugins, code, sourceFile, prog, contexts.get(root || '') ?? contexts.set(root || '', new Map()).get(root || ''));
+                    let result = coordinator.transform(plugins, code, sourceFile, prog, key, ctx);
                     if (!result.changed) {
                         return null;
                     }
@@ -41,7 +41,7 @@ export default ({ name, onWatchChange, plugins }) => {
                 if (FILE_REGEX.test(id)) {
                     onWatchChange?.();
                     contexts.delete(root || '');
-                    program.delete(root || '');
+                    languageService.invalidate(root || '', id);
                 }
             }
         };

package/package.json

@@ -7,14 +7,15 @@
     "tsc-alias": "./bin/tsc-alias"
   },
   "dependencies": {
-    "@esportsplus/cli-passthrough": "^0.0.12",
-    "@esportsplus/utilities": "^0.27.2",
-    "@types/node": "^25.0.3",
+    "@esportsplus/cli-passthrough": "^0.0.15",
+    "@esportsplus/utilities": "^0.27.3",
+    "@types/node": "^25.6.0",
     "tsc-alias": "^1.8.16",
-    "typescript": "^5.9.3"
+    "typescript": "^6.0.2"
   },
   "devDependencies": {
-    "vite": "^6.0.7"
+    "vite": "^8.0.8",
+    "vitest": "^4.1.4"
   },
   "exports": {
     "./package.json": "./package.json",
@@ -39,9 +40,11 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.28.5",
+  "version": "0.29.1",
   "scripts": {
+    "bench:run": "vitest bench --run",
     "build": "tsc && tsc-alias",
-    "-": "-"
+    "-": "-",
+    "test": "vitest run"
   }
 }

package/src/cli/tsc.ts

@@ -1,15 +1,15 @@
-import { spawn } from 'child_process';
+import type { Plugin, SharedContext } from '~/compiler/types';
 import { createRequire } from 'module';
+import { PACKAGE_NAME } from '~/constants';
 import { pathToFileURL } from 'url';
+import { spawn } from 'child_process';
+
+import coordinator from '~/compiler/coordinator';
 import path from 'path';
 import ts from 'typescript';
-import coordinator from '~/compiler/coordinator';
-import type { Plugin, SharedContext } from '~/compiler/types';
-import { PACKAGE_NAME } from '~/constants';
 
 
 type PluginConfig = {
-    after?: boolean;
     transform: string;
 };
 
@@ -54,6 +54,7 @@ async function build(config: object, tsconfig: string, pluginConfigs: PluginConf
             sourceFile.getFullText(),
             sourceFile,
             program,
+            root,
             shared
         );
 
@@ -226,4 +227,9 @@ function runTscAlias(args: string[]): Promise<number> {
 }
 
 
-main();
+if (process.env.VITEST === undefined) {
+    main();
+}
+
+
+export { build, isPlugin, loadPlugins, normalizePath, runTscAlias };

package/src/compiler/ast.ts

@@ -1,10 +1,5 @@
-import ts from 'typescript';
-
-
-type Range = {
-    end: number;
-    start: number;
-};
+import type { Range } from './types';
+import { ts } from '~/index';
 
 
 const expression = {

package/src/compiler/coordinator.ts

@@ -1,6 +1,9 @@
 import type { ImportIntent, Plugin, Replacement, ReplacementIntent, SharedContext } from './types';
+import type { ModifyOptions } from './imports';
 import { ts } from '~/index';
-import imports, { ModifyOptions } from './imports';
+
+import imports from './imports';
+import languageService from './language-service';
 
 
 type CoordinatorResult = {
@@ -11,22 +14,39 @@ type CoordinatorResult = {
 
 
 function applyImports(code: string, file: ts.SourceFile, intents: ImportIntent[]): string {
+    let merged = new Map<string, { add?: string[]; namespace?: string; remove?: string[] }>();
+
     for (let i = 0, n = intents.length; i < n; i++) {
-        let intent = intents[i];
+        let intent = intents[i],
+            existing = merged.get(intent.package);
 
-        code = modify(code, file, intent.package, {
-            add: intent.add,
-            namespace: intent.namespace,
-            remove: intent.remove
-        });
+        if (existing) {
+            if (intent.add) {
+                (existing.add ??= []).push(...intent.add);
+            }
+            if (intent.namespace) {
+                existing.namespace = intent.namespace;
+            }
+            if (intent.remove) {
+                (existing.remove ??= []).push(...intent.remove);
+            }
+        }
+        else {
+            merged.set(intent.package, {
+                add: intent.add ? [...intent.add] : undefined,
+                namespace: intent.namespace,
+                remove: intent.remove ? [...intent.remove] : undefined
+            });
+        }
+    }
+
+    let keys = [...merged.keys()];
+
+    for (let i = 0, n = keys.length; i < n; i++) {
+        code = modify(code, file, keys[i], merged.get(keys[i])!);
 
         if (i < n - 1) {
-            file = ts.createSourceFile(
-                file.fileName,
-                code,
-                file.languageVersion,
-                true
-            );
+            file = ts.createSourceFile(file.fileName, code, file.languageVersion, true);
         }
     }
 
@@ -67,10 +87,10 @@ function applyPrepend(code: string, file: ts.SourceFile, prepend: string[]): str
     }
 
     if (position === 0) {
-        return prepend.join('\n') + code;
+        return prepend.join('\n') + '\n' + code;
     }
 
-    return code.slice(0, position) + prepend.join('\n') + code.slice(position);
+    return code.slice(0, position) + '\n' + prepend.join('\n') + '\n' + code.slice(position);
 }
 
 function hasPattern(code: string, patterns: string[]): boolean {
@@ -157,45 +177,34 @@ function replaceReverse(code: string, replacements: Replacement[]): string {
 
     replacements.sort((a, b) => b.start - a.start);
 
-    let result = code;
+    let parts: string[] = [],
+        pos = code.length;
 
     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);
+        if (r.end < pos) {
+            parts.push(code.substring(r.end, pos));
+        }
+
+        parts.push(r.newText);
+        pos = r.start;
+    }
+
+    if (pos > 0) {
+        parts.push(code.substring(0, pos));
     }
 
-    return result;
+    return parts.reverse().join('');
 }
 
 
-const createPatchedProgram = (baseProgram: ts.Program, fileName: string, newContent: string) => {
-    let baseHost = ts.createCompilerHost(baseProgram.getCompilerOptions()),
-        options = baseProgram.getCompilerOptions();
-
-    return ts.createProgram(
-        baseProgram.getRootFileNames(),
-        options,
-        {
-            ...baseHost,
-            getSourceFile: (name, languageVersion) => {
-                if (name === fileName || name === fileName.replace(/\\/g, '/')) {
-                    return ts.createSourceFile(name, newContent, languageVersion, true);
-                }
-                return baseProgram.getSourceFile(name) ?? baseHost.getSourceFile(name, languageVersion);
-            },
-            fileExists: (name) => baseHost.fileExists(name),
-            readFile: (name) => name === fileName ? newContent : baseHost.readFile(name)
-        },
-        baseProgram
-    );
-};
-
 const transform = (
     plugins: Plugin[],
     code: string,
     file: ts.SourceFile,
     program: ts.Program,
+    root: string,
     shared: SharedContext
 ) => {
     if (plugins.length === 0) {
@@ -206,7 +215,8 @@ const transform = (
         currentCode = code,
         currentFile = file,
         currentProgram = program,
-        fileName = file.fileName;
+        fileName = file.fileName,
+        last = plugins.length - 1;
 
     for (let i = 0, n = plugins.length; i < n; i++) {
         let plugin = plugins[i];
@@ -230,20 +240,28 @@ const transform = (
         }
 
         if (prepend?.length) {
+            if (pluginChanged) {
+                currentFile = ts.createSourceFile(fileName, currentCode, file.languageVersion, true);
+            }
+
             currentCode = applyPrepend(currentCode, currentFile, prepend);
             pluginChanged = true;
         }
 
         if (imports?.length) {
+            if (pluginChanged) {
+                currentFile = ts.createSourceFile(fileName, currentCode, file.languageVersion, true);
+            }
+
             currentCode = applyImports(currentCode, currentFile, imports);
             pluginChanged = true;
         }
 
         if (pluginChanged) {
             changed = true;
-            // Create patched program for next plugin
-            if (i < n - 1) {
-                currentProgram = createPatchedProgram(program, fileName, currentCode);
+
+            if (i < last) {
+                currentProgram = languageService.update(root, fileName, currentCode);
                 currentFile = currentProgram.getSourceFile(fileName) ||
                     ts.createSourceFile(fileName, currentCode, file.languageVersion, true);
             }
@@ -257,5 +275,5 @@ const transform = (
 };
 
 
-export default { createPatchedProgram, transform };
+export default { transform };
 export type { CoordinatorResult };

package/src/compiler/imports.ts

@@ -17,6 +17,14 @@ type ModifyOptions = {
 let cache = new WeakMap<ts.SourceFile, Map<string, Set<string>>>();
 
 
+function fileNameMatchesPackage(fileName: string, pkg: string): boolean {
+    let normalized = fileName.replace(/\\/g, '/'),
+        marker = `/node_modules/${pkg}/`;
+
+    return normalized.includes(marker);
+}
+
+
 // Find all named imports from a specific package
 const all = (file: ts.SourceFile, pkg: string): ImportInfo[] => {
     let imports: ImportInfo[] = [];
@@ -108,7 +116,7 @@ const includes = (checker: ts.TypeChecker, node: ts.Node, pkg: string, symbolNam
                         }
                     }
 
-                    if (decl.getSourceFile().fileName.includes(pkg)) {
+                    if (fileNameMatchesPackage(decl.getSourceFile().fileName, pkg)) {
                         return true;
                     }
                 }
@@ -133,7 +141,7 @@ const includes = (checker: ts.TypeChecker, node: ts.Node, pkg: string, symbolNam
         for (let i = 0, n = declarations.length; i < n; i++) {
             let decl = declarations[i];
 
-            if (decl.getSourceFile().fileName.includes(pkg)) {
+            if (fileNameMatchesPackage(decl.getSourceFile().fileName, pkg)) {
                 return true;
             }
         }
@@ -148,7 +156,7 @@ const includes = (checker: ts.TypeChecker, node: ts.Node, pkg: string, symbolNam
 
             if (aliasedDecls) {
                 for (let i = 0, n = aliasedDecls.length; i < n; i++) {
-                    if (aliasedDecls[i].getSourceFile().fileName.includes(pkg)) {
+                    if (fileNameMatchesPackage(aliasedDecls[i].getSourceFile().fileName, pkg)) {
                         return true;
                     }
                 }

package/src/compiler/language-service.ts

@@ -0,0 +1,121 @@
+import { PACKAGE_NAME } from '~/constants';
+import { ts } from '~/index';
+
+import path from 'path';
+
+
+type LanguageServiceEntry = {
+    contents: Map<string, string>;
+    host: ts.LanguageServiceHost;
+    rootFiles: Set<string>;
+    service: ts.LanguageService;
+    versions: Map<string, number>;
+};
+
+
+let cache = new Map<string, LanguageServiceEntry>();
+
+
+function create(root: string): LanguageServiceEntry {
+    let tsconfig = ts.findConfigFile(root, ts.sys.fileExists, 'tsconfig.json');
+
+    if (!tsconfig) {
+        throw new Error(`${PACKAGE_NAME}: tsconfig.json not found`);
+    }
+
+    let file = ts.readConfigFile(tsconfig, ts.sys.readFile);
+
+    if (file.error) {
+        throw new Error(`${PACKAGE_NAME}: 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(`${PACKAGE_NAME}: error parsing tsconfig.json ${parsed.errors[0].messageText}`);
+    }
+
+    let contents = new Map<string, string>(),
+        rootFiles = new Set(parsed.fileNames.map(f => f.replace(/\\/g, '/'))),
+        versions = new Map<string, number>();
+
+    for (let fileName of rootFiles) {
+        versions.set(fileName, 0);
+    }
+
+    let host: ts.LanguageServiceHost = {
+        fileExists: ts.sys.fileExists,
+        getCompilationSettings: () => parsed.options,
+        getCurrentDirectory: () => root,
+        getDefaultLibFileName: ts.getDefaultLibFilePath,
+        getScriptFileNames: () => [...rootFiles],
+        getScriptSnapshot: (fileName: string) => {
+            let content = contents.get(fileName);
+
+            if (content !== undefined) {
+                return ts.ScriptSnapshot.fromString(content);
+            }
+
+            if (!ts.sys.fileExists(fileName)) {
+                return undefined;
+            }
+
+            return ts.ScriptSnapshot.fromString(ts.sys.readFile(fileName) || '');
+        },
+        getScriptVersion: (fileName: string) => String(versions.get(fileName) || 0),
+        readFile: ts.sys.readFile
+    };
+
+    return { contents, host, rootFiles, service: ts.createLanguageService(host), versions };
+}
+
+function getEntry(root: string): LanguageServiceEntry {
+    let entry = cache.get(root);
+
+    if (!entry) {
+        entry = create(root);
+        cache.set(root, entry);
+    }
+
+    return entry;
+}
+
+
+const invalidate = (root: string, fileName: string): void => {
+    let entry = cache.get(root);
+
+    if (entry) {
+        let normalized = fileName.replace(/\\/g, '/');
+
+        entry.contents.delete(normalized);
+        entry.versions.set(normalized, (entry.versions.get(normalized) || 0) + 1);
+    }
+};
+
+const update = (root: string, fileName: string, content: string): ts.Program => {
+    let entry = getEntry(root),
+        normalized = fileName.replace(/\\/g, '/');
+
+    if (!entry.rootFiles.has(normalized)) {
+        entry.rootFiles.add(normalized);
+    }
+
+    entry.contents.set(normalized, content);
+    entry.versions.set(normalized, (entry.versions.get(normalized) || 0) + 1);
+
+    let program = entry.service.getProgram();
+
+    if (!program) {
+        throw new Error(`${PACKAGE_NAME}: failed to get program from language service`);
+    }
+
+    return program;
+};
+
+
+export default { invalidate, update };
+export { invalidate, update };

package/src/compiler/plugins/vite.ts

@@ -1,8 +1,9 @@
-import type { ResolvedConfig } from 'vite';
 import type { Plugin, SharedContext } from '../types';
+import type { ResolvedConfig } from 'vite';
 import { ts } from '~/index';
+
 import coordinator from '../coordinator';
-import program from '../program';
+import languageService from '../language-service';
 
 
 type VitePlugin = {
@@ -20,11 +21,9 @@ type VitePluginOptions = {
 };
 
 
-const FILE_REGEX = /\.[tj]sx?$/;
-
 const DIRECTORY_SEPARATOR_REGEX = /\\/g;
 
-const LINE_ENDINGS_REGEX = /\r\n/g;
+const FILE_REGEX = /\.[tj]sx?$/;
 
 
 let contexts = new Map<string, SharedContext>();
@@ -45,17 +44,19 @@ export default ({ name, onWatchChange, plugins }: VitePluginOptions) => {
 
                 try {
                     let normalizedId = id.replace(DIRECTORY_SEPARATOR_REGEX, '/'),
-                        prog = program.get(root || ''),
-                        sourceFile = prog.getSourceFile(normalizedId) || prog.getSourceFile(id);
+                        prog = languageService.update(root || '', normalizedId, code),
+                        sourceFile = prog.getSourceFile(normalizedId);
 
-                    // Check if file content matches (existing file may have changed)
-                    if (sourceFile && sourceFile.getText().replace(LINE_ENDINGS_REGEX, '\n') !== code.replace(LINE_ENDINGS_REGEX, '\n')) {
-                        sourceFile = undefined;
+                    if (!sourceFile) {
+                        sourceFile = ts.createSourceFile(normalizedId, code, ts.ScriptTarget.Latest, true);
                     }
 
-                    if (!sourceFile) {
-                        prog = coordinator.createPatchedProgram(prog, normalizedId, code);
-                        sourceFile = prog.getSourceFile(normalizedId) || ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true);
+                    let key = root || '',
+                        ctx = contexts.get(key);
+
+                    if (!ctx) {
+                        ctx = new Map();
+                        contexts.set(key, ctx);
                     }
 
                     let result = coordinator.transform(
@@ -63,7 +64,8 @@ export default ({ name, onWatchChange, plugins }: VitePluginOptions) => {
                             code,
                             sourceFile,
                             prog,
-                            contexts.get(root || '') ?? contexts.set(root || '', new Map()).get(root || '')!
+                            key,
+                            ctx
                         );
 
                     if (!result.changed) {
@@ -81,7 +83,7 @@ export default ({ name, onWatchChange, plugins }: VitePluginOptions) => {
                 if (FILE_REGEX.test(id)) {
                     onWatchChange?.();
                     contexts.delete(root || '');
-                    program.delete(root || '');
+                    languageService.invalidate(root || '', id);
                 }
             }
         };