@esportsplus/typescript 0.29.0 → 0.29.5

package/build/compiler/imports.js

@@ -1,5 +1,9 @@
 import { ts } from '../index.js';
 let cache = new WeakMap();
+function fileNameMatchesPackage(fileName, pkg) {
+    let normalized = fileName.replace(/\\/g, '/'), marker = `/node_modules/${pkg}/`;
+    return normalized.includes(marker);
+}
 const all = (file, pkg) => {
     let imports = [];
     for (let i = 0, n = file.statements.length; i < n; i++) {
@@ -60,7 +64,7 @@ const includes = (checker, node, pkg, symbolName) => {
                             }
                         }
                     }
-                    if (decl.getSourceFile().fileName.includes(pkg)) {
+                    if (fileNameMatchesPackage(decl.getSourceFile().fileName, pkg)) {
                         return true;
                     }
                 }
@@ -76,7 +80,7 @@ const includes = (checker, node, pkg, symbolName) => {
     if (declarations && declarations.length > 0) {
         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;
             }
         }
@@ -87,7 +91,7 @@ const includes = (checker, node, pkg, symbolName) => {
             let aliasedDecls = aliased.getDeclarations();
             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/build/compiler/language-service.d.ts

@@ -1,12 +1,9 @@
-import ts from 'typescript';
-declare const get: (root: string) => ts.Program;
+import { ts } from '../index.js';
 declare const invalidate: (root: string, fileName: string) => void;
 declare const update: (root: string, fileName: string, content: string) => ts.Program;
 declare const _default: {
-    delete: (root: string) => void;
-    get: (root: string) => ts.Program;
     invalidate: (root: string, fileName: string) => void;
     update: (root: string, fileName: string, content: string) => ts.Program;
 };
 export default _default;
-export { get, invalidate, update };
+export { invalidate, update };

package/build/compiler/language-service.js

@@ -1,6 +1,6 @@
-import path from 'path';
-import ts from 'typescript';
 import { PACKAGE_NAME } from '../constants.js';
+import { ts } from '../index.js';
+import path from 'path';
 let cache = new Map();
 function create(root) {
     let tsconfig = ts.findConfigFile(root, ts.sys.fileExists, 'tsconfig.json');
@@ -48,16 +48,6 @@ function getEntry(root) {
     }
     return entry;
 }
-const del = (root) => {
-    cache.delete(root);
-};
-const get = (root) => {
-    let entry = getEntry(root), program = entry.service.getProgram();
-    if (!program) {
-        throw new Error(`${PACKAGE_NAME}: failed to get program from language service`);
-    }
-    return program;
-};
 const invalidate = (root, fileName) => {
     let entry = cache.get(root);
     if (entry) {
@@ -79,5 +69,5 @@ const update = (root, fileName, content) => {
     }
     return program;
 };
-export default { delete: del, get, invalidate, update };
-export { get, invalidate, update };
+export default { invalidate, update };
+export { invalidate, update };

package/build/compiler/plugins/vite.js

@@ -19,9 +19,14 @@ export default ({ name, onWatchChange, plugins }) => {
                 try {
                     let normalizedId = id.replace(DIRECTORY_SEPARATOR_REGEX, '/'), prog = languageService.update(root || '', normalizedId, code), sourceFile = prog.getSourceFile(normalizedId);
                     if (!sourceFile) {
-                        sourceFile = ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true);
+                        sourceFile = ts.createSourceFile(normalizedId, code, ts.ScriptTarget.Latest, true);
                     }
-                    let result = coordinator.transform(plugins, code, sourceFile, prog, root || '', contexts.get(root || '') ?? contexts.set(root || '', new Map()).get(root || ''));
+                    let key = root || '', ctx = contexts.get(key);
+                    if (!ctx) {
+                        ctx = new Map();
+                        contexts.set(key, ctx);
+                    }
+                    let result = coordinator.transform(plugins, code, sourceFile, prog, key, ctx);
                     if (!result.changed) {
                         return null;
                     }

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",
-    "tsc-alias": "^1.8.16",
-    "typescript": "^5.9.3"
+    "@esportsplus/cli-passthrough": "^0.0.15",
+    "@esportsplus/utilities": "^0.28.0",
+    "@types/node": "^26.0.1",
+    "tsc-alias": "^1.8.17",
+    "typescript": "^6.0.3"
   },
   "devDependencies": {
-    "vite": "^6.0.7"
+    "vite": "^8.1.0",
+    "vitest": "^4.1.9"
   },
   "exports": {
     "./package.json": "./package.json",
@@ -32,6 +33,9 @@
   },
   "main": "build/index.js",
   "name": "@esportsplus/typescript",
+  "overrides": {
+    "postcss": "8.5.15"
+  },
   "private": false,
   "repository": {
     "type": "git",
@@ -39,9 +43,11 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.29.0",
+  "version": "0.29.5",
   "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;
 };
 
@@ -227,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,8 @@
 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';
 
 
@@ -12,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);
         }
     }
 
@@ -68,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 {
@@ -158,15 +177,25 @@ 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;
     }
 
-    return result;
+    if (pos > 0) {
+        parts.push(code.substring(0, pos));
+    }
+
+    return parts.reverse().join('');
 }
 
 
@@ -211,11 +240,19 @@ 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;
         }

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

@@ -1,6 +1,7 @@
-import path from 'path';
-import ts from 'typescript';
 import { PACKAGE_NAME } from '~/constants';
+import { ts } from '~/index';
+
+import path from 'path';
 
 
 type LanguageServiceEntry = {
@@ -84,21 +85,6 @@ function getEntry(root: string): LanguageServiceEntry {
 }
 
 
-const del = (root: string): void => {
-    cache.delete(root);
-};
-
-const get = (root: string): ts.Program => {
-    let entry = getEntry(root),
-        program = entry.service.getProgram();
-
-    if (!program) {
-        throw new Error(`${PACKAGE_NAME}: failed to get program from language service`);
-    }
-
-    return program;
-};
-
 const invalidate = (root: string, fileName: string): void => {
     let entry = cache.get(root);
 
@@ -131,5 +117,5 @@ const update = (root: string, fileName: string, content: string): ts.Program =>
 };
 
 
-export default { delete: del, get, invalidate, update };
-export { get, invalidate, update };
+export default { invalidate, update };
+export { invalidate, update };

package/src/compiler/plugins/vite.ts

@@ -1,6 +1,7 @@
-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 languageService from '../language-service';
 
@@ -47,7 +48,15 @@ export default ({ name, onWatchChange, plugins }: VitePluginOptions) => {
                         sourceFile = prog.getSourceFile(normalizedId);
 
                     if (!sourceFile) {
-                        sourceFile = 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(
@@ -55,8 +64,8 @@ export default ({ name, onWatchChange, plugins }: VitePluginOptions) => {
                             code,
                             sourceFile,
                             prog,
-                            root || '',
-                            contexts.get(root || '') ?? contexts.set(root || '', new Map()).get(root || '')!
+                            key,
+                            ctx
                         );
 
                     if (!result.changed) {

package/tests/cli/tsc.test.ts

@@ -0,0 +1,155 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+import { isPlugin, loadPlugins, normalizePath, runTscAlias } from '~/cli/tsc';
+
+
+describe('isPlugin', () => {
+    it('returns true for valid plugin', () => {
+        expect(isPlugin({ transform: () => {} })).toBe(true);
+    });
+
+    it('returns false for null', () => {
+        expect(isPlugin(null)).toBe(false);
+    });
+
+    it('returns false for empty object', () => {
+        expect(isPlugin({})).toBe(false);
+    });
+
+    it('returns false when transform is not a function', () => {
+        expect(isPlugin({ transform: 'not-fn' })).toBe(false);
+    });
+
+    it('returns false for primitives', () => {
+        expect(isPlugin(42)).toBe(false);
+        expect(isPlugin('str')).toBe(false);
+        expect(isPlugin(undefined)).toBe(false);
+    });
+});
+
+
+describe('normalizePath', () => {
+    it('converts backslashes to forward slashes', () => {
+        let result = normalizePath('C:\\foo\\bar.ts');
+
+        expect(result).not.toContain('\\');
+        expect(result).toContain('/foo/bar');
+    });
+
+    it('resolves to absolute path', () => {
+        let result = normalizePath('relative/file.ts');
+
+        expect(path.isAbsolute(result)).toBe(true);
+    });
+});
+
+
+describe('loadPlugins', () => {
+    let tmpDir: string;
+
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tsc-test-'));
+    });
+
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    it('loads a valid plugin with transform export', async () => {
+        let pluginFile = 'plugin.mjs';
+
+        fs.writeFileSync(path.join(tmpDir, pluginFile), 'export default { transform: () => ({}) };');
+
+        let plugins = await loadPlugins([{ transform: './' + pluginFile }], tmpDir);
+
+        expect(plugins).toHaveLength(1);
+        expect(typeof plugins[0].transform).toBe('function');
+    });
+
+    it('loads a factory function that returns a plugin', async () => {
+        let pluginFile = 'factory.mjs';
+
+        fs.writeFileSync(path.join(tmpDir, pluginFile), 'export default function() { return { transform: () => ({}) }; };');
+
+        let plugins = await loadPlugins([{ transform: './' + pluginFile }], tmpDir);
+
+        expect(plugins).toHaveLength(1);
+        expect(typeof plugins[0].transform).toBe('function');
+    });
+
+    it('loads array of plugins', async () => {
+        let pluginFile = 'array.mjs';
+
+        fs.writeFileSync(path.join(tmpDir, pluginFile), 'export default [{ transform: () => ({}) }, { transform: () => ({}) }];');
+
+        let plugins = await loadPlugins([{ transform: './' + pluginFile }], tmpDir);
+
+        expect(plugins).toHaveLength(2);
+    });
+
+    it('skips invalid plugin format with error', async () => {
+        let pluginFile = 'invalid.mjs';
+
+        fs.writeFileSync(path.join(tmpDir, pluginFile), 'export default { notTransform: true };');
+
+        let spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+        let plugins = await loadPlugins([{ transform: './' + pluginFile }], tmpDir);
+
+        expect(plugins).toHaveLength(0);
+        expect(spy).toHaveBeenCalled();
+        spy.mockRestore();
+    });
+
+    it('skips invalid array element with error', async () => {
+        let pluginFile = 'mixed.mjs';
+
+        fs.writeFileSync(path.join(tmpDir, pluginFile), 'export default [{ transform: () => ({}) }, { bad: true }];');
+
+        let spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+        let plugins = await loadPlugins([{ transform: './' + pluginFile }], tmpDir);
+
+        expect(plugins).toHaveLength(1);
+        expect(spy).toHaveBeenCalled();
+        spy.mockRestore();
+    });
+
+    it('resolves relative paths from root', async () => {
+        let pluginFile = 'relative.mjs';
+
+        fs.writeFileSync(path.join(tmpDir, pluginFile), 'export default { transform: () => ({}) };');
+
+        let plugins = await loadPlugins([{ transform: './' + pluginFile }], tmpDir);
+
+        expect(plugins).toHaveLength(1);
+    });
+});
+
+
+describe('runTscAlias', () => {
+    it('returns 0 for --noEmit flag', async () => {
+        let code = await runTscAlias(['--noEmit']);
+
+        expect(code).toBe(0);
+    });
+
+    it('returns 0 for --help flag', async () => {
+        let code = await runTscAlias(['--help']);
+
+        expect(code).toBe(0);
+    });
+
+    it('returns 0 for --version flag', async () => {
+        let code = await runTscAlias(['--version']);
+
+        expect(code).toBe(0);
+    });
+
+    it('returns 0 for -v flag', async () => {
+        let code = await runTscAlias(['-v']);
+
+        expect(code).toBe(0);
+    });
+});