@esportsplus/typescript 0.29.0 → 0.29.5

package/tests/compiler/ast.test.ts

@@ -0,0 +1,131 @@
+import { describe, expect, it } from 'vitest';
+import ts from 'typescript';
+
+import ast from '~/compiler/ast';
+
+
+function parse(code: string): ts.SourceFile {
+    return ts.createSourceFile('test.ts', code, ts.ScriptTarget.Latest, true);
+}
+
+function findFirst(file: ts.SourceFile, predicate: (n: ts.Node) => boolean): ts.Node | undefined {
+    let result: ts.Node | undefined;
+
+    function visit(node: ts.Node) {
+        if (result) {
+            return;
+        }
+
+        if (predicate(node)) {
+            result = node;
+            return;
+        }
+
+        ts.forEachChild(node, visit);
+    }
+
+    ts.forEachChild(file, visit);
+
+    return result;
+}
+
+
+describe('ast.expression.name', () => {
+    it('returns text for identifiers', () => {
+        let file = parse('let x = foo;'),
+            node = findFirst(file, ts.isIdentifier);
+
+        expect(node).toBeDefined();
+        expect(ast.expression.name(node as ts.Expression)).toBe('x');
+    });
+
+    it('returns dotted path for property access', () => {
+        let file = parse('a.b.c;'),
+            node = findFirst(file, ts.isPropertyAccessExpression);
+
+        expect(node).toBeDefined();
+        expect(ast.expression.name(node as ts.Expression)).toBe('a.b.c');
+    });
+
+    it('returns null for unsupported expressions', () => {
+        let file = parse('foo();'),
+            node = findFirst(file, ts.isCallExpression);
+
+        expect(node).toBeDefined();
+        expect(ast.expression.name(node as ts.Expression)).toBeNull();
+    });
+});
+
+
+describe('ast.inRange', () => {
+    it('returns true when node is within range', () => {
+        expect(ast.inRange([{ start: 0, end: 100 }], 10, 50)).toBe(true);
+    });
+
+    it('returns true at exact boundaries', () => {
+        expect(ast.inRange([{ start: 10, end: 50 }], 10, 50)).toBe(true);
+    });
+
+    it('returns false when node is outside range', () => {
+        expect(ast.inRange([{ start: 10, end: 50 }], 0, 9)).toBe(false);
+    });
+
+    it('returns false when node partially overlaps', () => {
+        expect(ast.inRange([{ start: 10, end: 50 }], 5, 30)).toBe(false);
+    });
+
+    it('returns false for empty ranges', () => {
+        expect(ast.inRange([], 0, 10)).toBe(false);
+    });
+
+    it('checks multiple ranges', () => {
+        let ranges = [{ start: 0, end: 10 }, { start: 20, end: 30 }];
+
+        expect(ast.inRange(ranges, 0, 10)).toBe(true);
+        expect(ast.inRange(ranges, 25, 28)).toBe(true);
+        expect(ast.inRange(ranges, 11, 19)).toBe(false);
+    });
+});
+
+
+describe('ast.property.path', () => {
+    it('returns dotted path for nested access', () => {
+        let file = parse('a.b.c.d;'),
+            node = findFirst(file, (n) => ts.isPropertyAccessExpression(n) && !ts.isPropertyAccessExpression(n.parent));
+
+        expect(node).toBeDefined();
+        expect(ast.property.path(node as ts.Expression)).toBe('a.b.c.d');
+    });
+
+    it('returns null for non-identifier base', () => {
+        let file = parse('foo().bar;'),
+            node = findFirst(file, ts.isPropertyAccessExpression);
+
+        expect(node).toBeDefined();
+        expect(ast.property.path(node as ts.Expression)).toBeNull();
+    });
+});
+
+
+describe('ast.test', () => {
+    it('returns true when predicate matches root', () => {
+        let file = parse('let x = 1;'),
+            found = ast.test(file, (n) => ts.isVariableStatement(n));
+
+        expect(found).toBe(true);
+    });
+
+    it('returns true when predicate matches deep child', () => {
+        let file = parse('function f() { return { a: 1 }; }'),
+            found = ast.test(file, (n) => ts.isObjectLiteralExpression(n));
+
+        expect(found).toBe(true);
+    });
+
+    it('returns false when predicate never matches', () => {
+        let file = parse('let x = 1;'),
+            found = ast.test(file, (n) => ts.isClassDeclaration(n));
+
+        expect(found).toBe(false);
+    });
+});

package/tests/compiler/code.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, it } from 'vitest';
+
+import code from '~/compiler/code';
+
+
+describe('code', () => {
+    it('interpolates values into template', () => {
+        let result = code`let x = ${'hello'};`;
+
+        expect(result).toBe("let x = hello;");
+    });
+
+    it('handles multiple interpolations', () => {
+        let result = code`${'a'} + ${'b'} = ${'c'}`;
+
+        expect(result).toBe('a + b = c');
+    });
+
+    it('collapses null to empty string', () => {
+        let result = code`x${null}y`;
+
+        expect(result).toBe('xy');
+    });
+
+    it('collapses undefined to empty string', () => {
+        let result = code`x${undefined}y`;
+
+        expect(result).toBe('xy');
+    });
+
+    it('collapses false to empty string', () => {
+        let result = code`x${false}y`;
+
+        expect(result).toBe('xy');
+    });
+
+    it('preserves zero', () => {
+        let result = code`x${0}y`;
+
+        expect(result).toBe('x0y');
+    });
+
+    it('preserves empty string', () => {
+        let result = code`x${''}y`;
+
+        expect(result).toBe('xy');
+    });
+
+    it('handles no interpolations', () => {
+        let result = code`just plain text`;
+
+        expect(result).toBe('just plain text');
+    });
+});
+
+
+describe('code.escape', () => {
+    it('escapes single quotes', () => {
+        expect(code.escape("it's")).toBe("it\\'s");
+    });
+
+    it('escapes multiple quotes', () => {
+        expect(code.escape("a'b'c")).toBe("a\\'b\\'c");
+    });
+
+    it('returns unchanged string without quotes', () => {
+        expect(code.escape('hello')).toBe('hello');
+    });
+
+    it('handles empty string', () => {
+        expect(code.escape('')).toBe('');
+    });
+});

package/tests/compiler/coordinator.bench.ts

@@ -0,0 +1,101 @@
+import { bench, describe, vi } from 'vitest';
+import ts from 'typescript';
+
+import type { Plugin, TransformContext } from '~/compiler/types';
+
+import coordinator from '~/compiler/coordinator';
+
+
+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;
+        })
+    }
+}));
+
+
+function parse(code: string, fileName = 'bench.ts'): ts.SourceFile {
+    return ts.createSourceFile(fileName, code, ts.ScriptTarget.Latest, true);
+}
+
+function makeProgram(file: ts.SourceFile): ts.Program {
+    return {
+        getSourceFile: () => file,
+        getTypeChecker: () => ({} as ts.TypeChecker)
+    } as unknown as ts.Program;
+}
+
+function makePlugin(transformFn: (ctx: TransformContext) => ReturnType<Plugin['transform']>): Plugin {
+    return { transform: transformFn };
+}
+
+
+let code = 'let x = 1;',
+    file = parse(code),
+    program = makeProgram(file);
+
+describe('applyImports batching', () => {
+    bench('10 intents, 1 package', () => {
+        let plugin = makePlugin(() => ({
+            imports: [
+                { add: ['a'], package: '@pkg/a' },
+                { add: ['b'], package: '@pkg/a' },
+                { add: ['c'], package: '@pkg/a' },
+                { add: ['d'], package: '@pkg/a' },
+                { add: ['e'], package: '@pkg/a' },
+                { add: ['f'], package: '@pkg/a' },
+                { add: ['g'], package: '@pkg/a' },
+                { add: ['h'], package: '@pkg/a' },
+                { add: ['i'], package: '@pkg/a' },
+                { add: ['j'], package: '@pkg/a' }
+            ]
+        }));
+
+        coordinator.transform([plugin], code, file, program, '/root', new Map());
+    });
+
+    bench('10 intents, 3 packages', () => {
+        let plugin = makePlugin(() => ({
+            imports: [
+                { add: ['a'], package: '@pkg/a' },
+                { add: ['b'], package: '@pkg/a' },
+                { add: ['c'], package: '@pkg/a' },
+                { add: ['d'], package: '@pkg/b' },
+                { add: ['e'], package: '@pkg/b' },
+                { add: ['f'], package: '@pkg/b' },
+                { add: ['g'], package: '@pkg/b' },
+                { add: ['h'], package: '@pkg/c' },
+                { add: ['i'], package: '@pkg/c' },
+                { add: ['j'], package: '@pkg/c' }
+            ]
+        }));
+
+        coordinator.transform([plugin], code, file, program, '/root', new Map());
+    });
+
+    bench('10 intents, 10 packages', () => {
+        let plugin = makePlugin(() => ({
+            imports: [
+                { add: ['a'], package: '@pkg/a' },
+                { add: ['b'], package: '@pkg/b' },
+                { add: ['c'], package: '@pkg/c' },
+                { add: ['d'], package: '@pkg/d' },
+                { add: ['e'], package: '@pkg/e' },
+                { add: ['f'], package: '@pkg/f' },
+                { add: ['g'], package: '@pkg/g' },
+                { add: ['h'], package: '@pkg/h' },
+                { add: ['i'], package: '@pkg/i' },
+                { add: ['j'], package: '@pkg/j' }
+            ]
+        }));
+
+        coordinator.transform([plugin], code, file, program, '/root', new Map());
+    });
+});