@esportsplus/typescript 0.29.6 → 0.31.0

package/src/compiler/imports.ts

@@ -1,185 +0,0 @@
-import { ts } from '~/index';
-
-
-type ImportInfo = {
-    end: number;
-    specifiers: Map<string, string>;
-    // propertyName keys that were imported type-only, whether via a type-only clause
-    // (`import type { A }`) or an inline specifier (`import { type A }`). Preserved so a rewrite
-    // re-emits them as type imports instead of runtime imports.
-    typeOnly: Set<string>;
-    start: number;
-};
-
-type ModifyOptions = {
-    add?: Iterable<string>;
-    namespace?: string;
-    remove?: Iterable<string>;
-};
-
-
-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[] = [];
-
-    for (let i = 0, n = file.statements.length; i < n; i++) {
-        let stmt = file.statements[i];
-
-        if (!ts.isImportDeclaration(stmt)) {
-            continue;
-        }
-
-        let moduleSpecifier = stmt.moduleSpecifier;
-
-        if (!ts.isStringLiteral(moduleSpecifier) || moduleSpecifier.text !== pkg) {
-            continue;
-        }
-
-        let bindings = stmt.importClause?.namedBindings,
-            declTypeOnly = stmt.importClause?.isTypeOnly ?? false,
-            specifiers = new Map<string, string>(),
-            typeOnly = new Set<string>();
-
-        if (bindings && ts.isNamedImports(bindings)) {
-            for (let j = 0, m = bindings.elements.length; j < m; j++) {
-                let element = bindings.elements[j],
-                    name = element.name.text,
-                    propertyName = element.propertyName?.text || name;
-
-                specifiers.set(propertyName, name);
-
-                if (declTypeOnly || element.isTypeOnly) {
-                    typeOnly.add(propertyName);
-                }
-            }
-        }
-
-        imports.push({ end: stmt.end, specifiers, start: stmt.getStart(file), typeOnly });
-    }
-
-    return imports;
-};
-
-// Check if node's symbol originates from a specific package (with optional symbol name validation)
-const includes = (checker: ts.TypeChecker, node: ts.Node, pkg: string, symbolName?: string): boolean => {
-    if (!ts.isIdentifier(node)) {
-        return false;
-    }
-
-    if (symbolName && node.text !== symbolName) {
-        return false;
-    }
-
-    let file = node.getSourceFile(),
-        imports = cache.get(file);
-
-    if (!imports) {
-        imports = new Map();
-        cache.set(file, imports);
-    }
-
-    let names = imports.get(pkg);
-
-    if (!names) {
-        names = new Set();
-
-        let packages = all(file, pkg);
-
-        for (let i = 0, n = packages.length; i < n; i++) {
-            for (let [, localName] of packages[i].specifiers) {
-                names.add(localName);
-            }
-        }
-
-        imports.set(pkg, names);
-    }
-
-    // Fast path: direct import from package
-    if (names.has(node.text)) {
-        let symbol = checker.getSymbolAtLocation(node);
-
-        if (symbol) {
-            let declarations = symbol.getDeclarations();
-
-            if (declarations && declarations.length > 0) {
-                for (let i = 0, n = declarations.length; i < n; i++) {
-                    let decl = declarations[i];
-
-                    if (ts.isImportSpecifier(decl)) {
-                        let importDecl = decl.parent?.parent?.parent;
-
-                        if (importDecl && ts.isImportDeclaration(importDecl) && ts.isStringLiteral(importDecl.moduleSpecifier)) {
-                            if (importDecl.moduleSpecifier.text === pkg) {
-                                return true;
-                            }
-                        }
-                    }
-
-                    if (fileNameMatchesPackage(decl.getSourceFile().fileName, pkg)) {
-                        return true;
-                    }
-                }
-            }
-        }
-
-        // If checker failed but name matches direct import, trust it
-        return true;
-    }
-
-    // Slow path: check for re-exports via aliased symbol
-    let symbol = checker.getSymbolAtLocation(node);
-
-    if (!symbol) {
-        return false;
-    }
-
-    // Check declarations
-    let declarations = symbol.getDeclarations();
-
-    if (declarations && declarations.length > 0) {
-        for (let i = 0, n = declarations.length; i < n; i++) {
-            let decl = declarations[i];
-
-            if (fileNameMatchesPackage(decl.getSourceFile().fileName, pkg)) {
-                return true;
-            }
-        }
-    }
-
-    // Check aliased symbol for re-exports
-    try {
-        let aliased = checker.getAliasedSymbol(symbol);
-
-        if (aliased && aliased !== symbol) {
-            let aliasedDecls = aliased.getDeclarations();
-
-            if (aliasedDecls) {
-                for (let i = 0, n = aliasedDecls.length; i < n; i++) {
-                    if (fileNameMatchesPackage(aliasedDecls[i].getSourceFile().fileName, pkg)) {
-                        return true;
-                    }
-                }
-            }
-        }
-    }
-    catch {
-        // getAliasedSymbol can throw for non-alias symbols
-    }
-
-    return false;
-};
-
-
-export default { all, includes };
-export type { ImportInfo, ModifyOptions };

package/src/compiler/index.ts

@@ -1,7 +0,0 @@
-export { default as ast } from './ast';
-export { default as code } from './code';
-export { default as coordinator } from './coordinator';
-export { default as imports } from './imports';
-export { default as plugin } from './plugins';
-export { default as uid } from './uid';
-export type * from './types';

package/src/compiler/language-service.ts

@@ -1,121 +0,0 @@
-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/index.ts

@@ -1,5 +0,0 @@
-import tsc from './tsc';
-import vite from './vite';
-
-
-export default { tsc, vite };

package/src/compiler/plugins/tsc.ts

@@ -1,6 +0,0 @@
-import type { Plugin } from '../types';
-
-
-export default (plugins: Plugin[]) => {
-    return () => plugins;
-};

package/src/compiler/plugins/vite.ts

@@ -1,91 +0,0 @@
-import type { Plugin, SharedContext } from '../types';
-import type { ResolvedConfig } from 'vite';
-import { ts } from '~/index';
-
-import coordinator from '../coordinator';
-import languageService from '../language-service';
-
-
-type VitePlugin = {
-    configResolved: (config: unknown) => void;
-    enforce: 'pre';
-    name: string;
-    transform: (code: string, id: string) => { code: string; map: null } | null;
-    watchChange: (id: string) => void;
-};
-
-type VitePluginOptions = {
-    name: string;
-    onWatchChange?: () => void;
-    plugins: Plugin[];
-};
-
-
-const DIRECTORY_SEPARATOR_REGEX = /\\/g;
-
-const FILE_REGEX = /\.[tj]sx?$/;
-
-
-let contexts = new Map<string, SharedContext>();
-
-
-export default ({ name, onWatchChange, plugins }: VitePluginOptions) => {
-    return ({ root }: { root?: string } = {}): VitePlugin => {
-        return {
-            configResolved(config: unknown) {
-                root ??= (config as ResolvedConfig).root;
-            },
-            enforce: 'pre',
-            name: `${name}/compiler/vite`,
-            transform(code: string, id: string) {
-                if (!FILE_REGEX.test(id) || id.includes('node_modules')) {
-                    return null;
-                }
-
-                try {
-                    let normalizedId = id.replace(DIRECTORY_SEPARATOR_REGEX, '/'),
-                        prog = languageService.update(root || '', normalizedId, code),
-                        sourceFile = prog.getSourceFile(normalizedId);
-
-                    if (!sourceFile) {
-                        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,
-                            key,
-                            ctx
-                        );
-
-                    if (!result.changed) {
-                        return null;
-                    }
-
-                    return { code: result.code, map: null };
-                }
-                catch (error) {
-                    console.error(`${name}: error transforming ${id}:`, error);
-                    return null;
-                }
-            },
-            watchChange(id: string) {
-                if (FILE_REGEX.test(id)) {
-                    onWatchChange?.();
-                    contexts.delete(root || '');
-                    languageService.invalidate(root || '', id);
-                }
-            }
-        };
-    };
-};

package/src/compiler/types.ts

@@ -1,83 +0,0 @@
-import type ts from 'typescript';
-
-
-type ImportIntent = {
-    add?: string[];
-    namespace?: string;
-    package: string;
-    remove?: string[];
-};
-
-type Plugin = {
-    /**
-     * Optional patterns for quick-check optimization.
-     * If provided, transform() is only called when source contains at least one pattern.
-     */
-    patterns?: string[];
-
-    /**
-     * Transform a source file, returning replacement intents.
-     * Called with fresh AST - positions are always accurate.
-     */
-    transform: (ctx: TransformContext) => TransformResult;
-};
-
-type PluginFactory = (options?: Record<string, unknown>) => Plugin;
-
-type Range = {
-    end: number;
-    start: number;
-};
-
-type Replacement = Range & {
-    newText: string;
-};
-
-type ReplacementIntent = {
-    /**
-     * Generator function that produces the replacement text.
-     * Called at apply-time with current sourceFile for accurate positions.
-     */
-    generate: (sourceFile: ts.SourceFile) => string;
-
-    /**
-     * AST node to replace. Position resolved at apply-time.
-     */
-    node: ts.Node;
-};
-
-type SharedContext = Map<string, unknown>;
-
-type TransformContext = {
-    checker: ts.TypeChecker;
-    code: string;
-    program: ts.Program;
-    shared: SharedContext;
-    sourceFile: ts.SourceFile;
-};
-
-type TransformResult = {
-    /**
-     * Import modifications to apply after replacements.
-     */
-    imports?: ImportIntent[];
-
-    /**
-     * Code to prepend after imports (e.g., generated classes, template factories).
-     */
-    prepend?: string[];
-
-    /**
-     * Replacement intents - node references with generator functions.
-     */
-    replacements?: ReplacementIntent[];
-};
-
-
-export type {
-    ImportIntent,
-    Plugin, PluginFactory,
-    Range, Replacement, ReplacementIntent,
-    SharedContext,
-    TransformContext, TransformResult
-};

package/src/compiler/uid.ts

@@ -1,10 +0,0 @@
-import { uuid } from '@esportsplus/utilities';
-
-
-let i = 0,
-    namespace = uuid().replace(/[^A-Za-z0-9]/g, '');
-
-
-export default (name: string): string => {
-    return name + '_' + namespace + (i++).toString(36);
-};

package/src/constants.ts

@@ -1,4 +0,0 @@
-const PACKAGE_NAME = '@esportsplus/typescript';
-
-
-export { PACKAGE_NAME };

package/src/index.ts

@@ -1 +0,0 @@
-export { default as ts } from 'typescript';

package/tests/cli/tsc.test.ts

@@ -1,155 +0,0 @@
-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);
-    });
-});