@esportsplus/typescript 0.28.5 → 0.29.1

package/tests/compiler/imports.test.ts

@@ -0,0 +1,167 @@
+import { describe, expect, it } from 'vitest';
+import ts from 'typescript';
+
+import imports from '~/compiler/imports';
+
+
+function parse(code: string, fileName = 'test.ts'): ts.SourceFile {
+    return ts.createSourceFile(fileName, code, ts.ScriptTarget.Latest, true);
+}
+
+
+describe('imports.all', () => {
+    it('finds named imports from a package', () => {
+        let file = parse("import { foo, bar } from 'my-pkg';"),
+            result = imports.all(file, 'my-pkg');
+
+        expect(result).toHaveLength(1);
+        expect(result[0].specifiers.get('foo')).toBe('foo');
+        expect(result[0].specifiers.get('bar')).toBe('bar');
+    });
+
+    it('handles aliased imports', () => {
+        let file = parse("import { foo as f } from 'my-pkg';"),
+            result = imports.all(file, 'my-pkg');
+
+        expect(result).toHaveLength(1);
+        expect(result[0].specifiers.get('foo')).toBe('f');
+    });
+
+    it('returns empty for non-matching package', () => {
+        let file = parse("import { foo } from 'other-pkg';"),
+            result = imports.all(file, 'my-pkg');
+
+        expect(result).toHaveLength(0);
+    });
+
+    it('returns empty when no imports', () => {
+        let file = parse('let x = 1;'),
+            result = imports.all(file, 'my-pkg');
+
+        expect(result).toHaveLength(0);
+    });
+
+    it('finds multiple import statements for same package', () => {
+        let file = parse("import { a } from 'pkg';\nimport { b } from 'pkg';"),
+            result = imports.all(file, 'pkg');
+
+        expect(result).toHaveLength(2);
+    });
+
+    it('tracks start and end positions', () => {
+        let file = parse("import { foo } from 'my-pkg';"),
+            result = imports.all(file, 'my-pkg');
+
+        expect(result[0].start).toBe(0);
+        expect(result[0].end).toBeGreaterThan(0);
+    });
+
+    it('handles default import (no named bindings)', () => {
+        let file = parse("import pkg from 'my-pkg';"),
+            result = imports.all(file, 'my-pkg');
+
+        expect(result).toHaveLength(1);
+        expect(result[0].specifiers.size).toBe(0);
+    });
+
+    it('handles namespace import', () => {
+        let file = parse("import * as pkg from 'my-pkg';"),
+            result = imports.all(file, 'my-pkg');
+
+        expect(result).toHaveLength(1);
+        expect(result[0].specifiers.size).toBe(0);
+    });
+});
+
+
+describe('imports.includes', () => {
+    let mockChecker = { getSymbolAtLocation: () => null } as unknown as ts.TypeChecker;
+
+    function findIdentifier(file: ts.SourceFile, name: string): ts.Identifier | undefined {
+        let found: ts.Identifier | undefined;
+
+        ts.forEachChild(file, function visit(n) {
+            if (ts.isIdentifier(n) && n.text === name && !found) {
+                let parent = n.parent;
+
+                if (!ts.isImportSpecifier(parent) && !ts.isImportClause(parent) && !ts.isNamespaceImport(parent)) {
+                    found = n;
+                }
+            }
+
+            ts.forEachChild(n, visit);
+        });
+
+        return found;
+    }
+
+    it('direct named import matches', () => {
+        let file = parse("import { reactive } from 'my-pkg';\nreactive(x);"),
+            node = findIdentifier(file, 'reactive');
+
+        expect(node).toBeDefined();
+        expect(imports.includes(mockChecker, node!, 'my-pkg', 'reactive')).toBe(true);
+    });
+
+    it('aliased import matches', () => {
+        let file = parse("import { foo as f } from 'my-pkg';\nf();"),
+            node = findIdentifier(file, 'f');
+
+        expect(node).toBeDefined();
+        expect(imports.includes(mockChecker, node!, 'my-pkg')).toBe(true);
+    });
+
+    it('non-matching package returns false', () => {
+        let file = parse("import { foo } from 'other-pkg';\nfoo();"),
+            node = findIdentifier(file, 'foo');
+
+        expect(node).toBeDefined();
+        expect(imports.includes(mockChecker, node!, 'my-pkg')).toBe(false);
+    });
+
+    it('non-matching symbol name returns false', () => {
+        let file = parse("import { foo } from 'my-pkg';\nfoo();"),
+            node = findIdentifier(file, 'foo');
+
+        expect(node).toBeDefined();
+        expect(imports.includes(mockChecker, node!, 'my-pkg', 'bar')).toBe(false);
+    });
+
+    it('cache returns consistent results', () => {
+        let file = parse("import { reactive } from 'my-pkg';\nreactive(1);"),
+            node = findIdentifier(file, 'reactive');
+
+        expect(node).toBeDefined();
+
+        let first = imports.includes(mockChecker, node!, 'my-pkg', 'reactive'),
+            second = imports.includes(mockChecker, node!, 'my-pkg', 'reactive');
+
+        expect(first).toBe(true);
+        expect(second).toBe(true);
+        expect(first).toBe(second);
+    });
+
+    it('no imports at all returns false', () => {
+        let file = parse('let x = 1;\nx;'),
+            node = findIdentifier(file, 'x');
+
+        expect(node).toBeDefined();
+        expect(imports.includes(mockChecker, node!, 'my-pkg')).toBe(false);
+    });
+
+    it('returns false when getAliasedSymbol throws', () => {
+        let file = parse("import { foo } from 'my-pkg';\nbar();"),
+            node = findIdentifier(file, 'bar');
+
+        expect(node).toBeDefined();
+
+        let checker = {
+            getSymbolAtLocation: () => ({
+                getDeclarations: () => []
+            }),
+            getAliasedSymbol: () => { throw new Error('not an alias'); }
+        } as unknown as ts.TypeChecker;
+
+        expect(imports.includes(checker, node!, 'my-pkg')).toBe(false);
+    });
+});

package/tests/compiler/language-service.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, it } from 'vitest';
+
+import languageService from '~/compiler/language-service';
+
+
+describe('language-service', () => {
+    describe('update', () => {
+        it('returns a Program when given valid root + fileName + content', () => {
+            let root = process.cwd().replace(/\\/g, '/'),
+                fileName = root + '/test-virtual-update.ts',
+                content = 'let x: number = 42;',
+                program = languageService.update(root, fileName, content);
+
+            expect(program).toBeDefined();
+            expect(program.getTypeChecker).toBeDefined();
+        });
+
+        it('updated content is reflected in the program SourceFile', () => {
+            let root = process.cwd().replace(/\\/g, '/'),
+                fileName = root + '/test-virtual-reflect.ts',
+                content = 'let hello = "world";',
+                program = languageService.update(root, fileName, content),
+                sourceFile = program.getSourceFile(fileName);
+
+            expect(sourceFile).toBeDefined();
+            expect(sourceFile!.text).toBe(content);
+        });
+
+        it('increments version for updated files', () => {
+            let root = process.cwd().replace(/\\/g, '/'),
+                fileName = root + '/test-virtual-version.ts';
+
+            languageService.update(root, fileName, 'let a = 1;');
+
+            let program = languageService.update(root, fileName, 'let a = 2;'),
+                sourceFile = program.getSourceFile(fileName);
+
+            expect(sourceFile).toBeDefined();
+            expect(sourceFile!.text).toBe('let a = 2;');
+        });
+
+        it('adds new files to rootFiles', () => {
+            let root = process.cwd().replace(/\\/g, '/'),
+                fileName = root + '/test-virtual-new-root.ts',
+                content = 'export const value = 1;',
+                program = languageService.update(root, fileName, content),
+                sourceFile = program.getSourceFile(fileName);
+
+            expect(sourceFile).toBeDefined();
+            expect(sourceFile!.text).toBe(content);
+        });
+    });
+
+    describe('invalidate', () => {
+        it('removes content so next getProgram reads from disk', () => {
+            let root = process.cwd().replace(/\\/g, '/'),
+                fileName = root + '/test-virtual-invalidate.ts',
+                content = 'let val = 99;';
+
+            languageService.update(root, fileName, content);
+            languageService.invalidate(root, fileName);
+
+            let program = languageService.update(root, fileName, 'let val = 100;'),
+                sourceFile = program.getSourceFile(fileName);
+
+            expect(sourceFile).toBeDefined();
+            expect(sourceFile!.text).toBe('let val = 100;');
+        });
+
+        it('increments version for invalidated files', () => {
+            let root = process.cwd().replace(/\\/g, '/'),
+                fileName = root + '/test-virtual-inv-version.ts';
+
+            languageService.update(root, fileName, 'let a = 1;');
+            languageService.invalidate(root, fileName);
+
+            let program = languageService.update(root, fileName, 'let a = 3;'),
+                sourceFile = program.getSourceFile(fileName);
+
+            expect(sourceFile).toBeDefined();
+            expect(sourceFile!.text).toBe('let a = 3;');
+        });
+
+        it('no-op when root does not exist in cache', () => {
+            expect(() => {
+                languageService.invalidate('/nonexistent/root', 'file.ts');
+            }).not.toThrow();
+        });
+    });
+});

package/tests/compiler/plugins.test.ts

@@ -0,0 +1,172 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import ts from 'typescript';
+
+import type { Plugin } from '~/compiler/types';
+
+import tsc from '~/compiler/plugins/tsc';
+import vite from '~/compiler/plugins/vite';
+
+vi.mock('~/compiler/language-service', () => ({
+    default: {
+        invalidate: vi.fn(),
+        update: vi.fn((_root: string, fileName: string, content: string) => {
+            let file = ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, true);
+
+            return {
+                getSourceFile: () => file,
+                getTypeChecker: () => ({} as ts.TypeChecker)
+            } as unknown as ts.Program;
+        })
+    }
+}));
+
+vi.mock('~/compiler/coordinator', () => ({
+    default: {
+        transform: vi.fn((_plugins: Plugin[], code: string, _file: ts.SourceFile, _prog: ts.Program, _root: string, _ctx: Map<string, unknown>) => ({
+            changed: false,
+            code,
+            sourceFile: {} as ts.SourceFile
+        }))
+    }
+}));
+
+import coordinator from '~/compiler/coordinator';
+import languageService from '~/compiler/language-service';
+
+
+describe('plugin.tsc', () => {
+    it('returns a function that returns the plugins array', () => {
+        let p1: Plugin = { transform: () => ({}) },
+            p2: Plugin = { transform: () => ({}) },
+            factory = tsc([p1, p2]),
+            result = factory();
+
+        expect(result).toEqual([p1, p2]);
+    });
+
+    it('returns empty array for empty input', () => {
+        let result = tsc([])();
+
+        expect(result).toEqual([]);
+    });
+});
+
+
+describe('plugin.vite', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    it('creates VitePlugin with correct shape', () => {
+        let factory = vite({ name: 'test-pkg', plugins: [] }),
+            plugin = factory();
+
+        expect(plugin).toHaveProperty('configResolved');
+        expect(plugin).toHaveProperty('enforce');
+        expect(plugin).toHaveProperty('name');
+        expect(plugin).toHaveProperty('transform');
+        expect(plugin).toHaveProperty('watchChange');
+    });
+
+    it('name includes package name', () => {
+        let plugin = vite({ name: 'test-pkg', plugins: [] })();
+
+        expect(plugin.name).toBe('test-pkg/compiler/vite');
+    });
+
+    it('filters non-ts files', () => {
+        let plugin = vite({ name: 'test-pkg', plugins: [] })();
+
+        expect(plugin.transform('code', 'file.css')).toBeNull();
+    });
+
+    it('filters node_modules', () => {
+        let plugin = vite({ name: 'test-pkg', plugins: [] })();
+
+        expect(plugin.transform('code', 'node_modules/pkg/index.ts')).toBeNull();
+    });
+
+    it('processes .ts files — returns null when unchanged', () => {
+        let plugin = vite({ name: 'test-pkg', plugins: [] })();
+
+        let result = plugin.transform('let x = 1;', 'src/app.ts');
+
+        expect(result).toBeNull();
+        expect(coordinator.transform).toHaveBeenCalled();
+    });
+
+    it('returns transformed code when changed', () => {
+        vi.mocked(coordinator.transform).mockReturnValueOnce({
+            changed: true,
+            code: 'TRANSFORMED',
+            sourceFile: {} as ts.SourceFile
+        });
+
+        let plugin = vite({ name: 'test-pkg', plugins: [] })();
+
+        let result = plugin.transform('let x = 1;', 'src/app.ts');
+
+        expect(result).toEqual({ code: 'TRANSFORMED', map: null });
+    });
+
+    it('watchChange calls onWatchChange and invalidate', () => {
+        let onWatchChange = vi.fn(),
+            plugin = vite({ name: 'test-pkg', onWatchChange, plugins: [] })();
+
+        plugin.watchChange('src/app.ts');
+
+        expect(onWatchChange).toHaveBeenCalled();
+        expect(languageService.invalidate).toHaveBeenCalledWith('', 'src/app.ts');
+    });
+
+    it('watchChange ignores non-ts files', () => {
+        let onWatchChange = vi.fn(),
+            plugin = vite({ name: 'test-pkg', onWatchChange, plugins: [] })();
+
+        plugin.watchChange('style.css');
+
+        expect(onWatchChange).not.toHaveBeenCalled();
+    });
+
+    it('configResolved sets root', () => {
+        let plugin = vite({ name: 'test-pkg', plugins: [] })();
+
+        plugin.configResolved({ root: '/my/root' });
+        plugin.transform('let x = 1;', 'src/app.ts');
+
+        expect(languageService.update).toHaveBeenCalledWith('/my/root', expect.any(String), expect.any(String));
+    });
+
+    it('catches coordinator.transform() error and returns null', () => {
+        vi.mocked(coordinator.transform).mockImplementationOnce(() => {
+            throw new Error('transform failed');
+        });
+
+        let consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}),
+            plugin = vite({ name: 'test-pkg', plugins: [] })();
+
+        let result = plugin.transform('let x = 1;', 'src/app.ts');
+
+        expect(result).toBeNull();
+        expect(consoleSpy).toHaveBeenCalledWith(
+            expect.stringContaining('test-pkg'),
+            expect.any(Error)
+        );
+
+        consoleSpy.mockRestore();
+    });
+
+    it('falls back to createSourceFile when getSourceFile returns undefined', () => {
+        vi.mocked(languageService.update).mockReturnValueOnce({
+            getSourceFile: () => undefined,
+            getTypeChecker: () => ({} as ts.TypeChecker)
+        } as unknown as ts.Program);
+
+        let plugin = vite({ name: 'test-pkg', plugins: [] })();
+
+        let result = plugin.transform('let x = 1;', 'src/app.ts');
+
+        expect(result).toBeNull();
+        expect(coordinator.transform).toHaveBeenCalled();
+    });
+});

package/tests/compiler/uid.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from 'vitest';
+
+import uid from '~/compiler/uid';
+
+
+describe('uid', () => {
+    it('generates unique ids', () => {
+        let a = uid('test'),
+            b = uid('test');
+
+        expect(a).not.toBe(b);
+    });
+
+    it('prefixes with given name', () => {
+        let result = uid('myPrefix');
+
+        expect(result.startsWith('myPrefix_')).toBe(true);
+    });
+
+    it('contains only alphanumeric characters after prefix', () => {
+        let result = uid('x'),
+            suffix = result.slice(2); // after 'x_'
+
+        expect(suffix).toMatch(/^[A-Za-z0-9]+$/);
+    });
+
+    // F-TEST-008: uid sequential guarantees
+
+    it('sequential calls produce different suffixes (5 calls)', () => {
+        let results = new Set<string>();
+
+        for (let i = 0; i < 5; i++) {
+            results.add(uid('x'));
+        }
+
+        expect(results.size).toBe(5);
+    });
+
+    it('different prefixes share same namespace', () => {
+        let a1 = uid('a'),
+            a2 = uid('a'),
+            b1 = uid('b'),
+            suffixA1 = a1.slice(2), // after 'a_'
+            suffixA2 = a2.slice(2),
+            suffixB1 = b1.slice(2); // after 'b_'
+
+        // Find common prefix between two 'a' calls — that's the namespace
+        let common = '';
+
+        for (let i = 0, n = Math.min(suffixA1.length, suffixA2.length); i < n; i++) {
+            if (suffixA1[i] !== suffixA2[i]) {
+                break;
+            }
+
+            common += suffixA1[i];
+        }
+
+        expect(common.length).toBeGreaterThan(0);
+        expect(suffixB1.startsWith(common)).toBe(true);
+    });
+
+    it('suffix contains valid base-36 characters', () => {
+        let result = uid('z'),
+            parts = result.slice(2), // after 'z_'
+            base36Suffix = parts.match(/[0-9a-z]+$/);
+
+        expect(base36Suffix).not.toBeNull();
+        expect(base36Suffix![0]).toMatch(/^[0-9a-z]+$/);
+    });
+});

package/tsconfig.base.json

@@ -3,7 +3,6 @@
     "compilerOptions": {
         "allowJs": true,
         "allowSyntheticDefaultImports": true,
-        "baseUrl": "${configDir}",
         "declaration": false,
         "esModuleInterop": true,
         "isolatedModules": true,

package/vitest.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from 'vitest/config';
+import path from 'path';
+
+
+export default defineConfig({
+    resolve: {
+        alias: {
+            '~': path.resolve(__dirname, 'src')
+        }
+    },
+    test: {
+        include: ['tests/**/*.test.ts']
+    }
+});

package/build/compiler/program.d.ts

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

package/build/compiler/program.js

@@ -1,34 +0,0 @@
-import path from 'path';
-import ts from 'typescript';
-import { PACKAGE_NAME } from '../constants.js';
-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(`${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}`);
-    }
-    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/src/compiler/program.ts

@@ -1,55 +0,0 @@
-import path from 'path';
-import ts from 'typescript';
-import { PACKAGE_NAME } from '~/constants';
-
-
-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(`${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}`);
-    }
-
-    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 };