@esportsplus/typescript 0.29.6 → 0.31.1

package/src/compiler/coordinator.ts

@@ -1,284 +0,0 @@
-import type { ImportIntent, Plugin, Replacement, ReplacementIntent, SharedContext } from './types';
-import type { ModifyOptions } from './imports';
-import { ts } from '~/index';
-
-import imports from './imports';
-import languageService from './language-service';
-
-
-type CoordinatorResult = {
-    changed: boolean;
-    code: string;
-    sourceFile: ts.SourceFile;
-};
-
-
-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],
-            existing = merged.get(intent.package);
-
-        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);
-        }
-    }
-
-    return code;
-}
-
-function applyIntents(code: string, file: ts.SourceFile, intents: ReplacementIntent[]): string {
-    if (intents.length === 0) {
-        return code;
-    }
-
-    return replaceReverse(
-        code,
-        intents.map(intent => ({
-            end: intent.node.end,
-            newText: intent.generate(file),
-            start: intent.node.getStart(file)
-        }))
-    );
-}
-
-function applyPrepend(code: string, file: ts.SourceFile, prepend: string[]): string {
-    if (prepend.length === 0) {
-        return code;
-    }
-
-    let position = 0;
-
-    for (let i = 0, n = file.statements.length; i < n; i++) {
-        let stmt = file.statements[i];
-
-        if (ts.isImportDeclaration(stmt)) {
-            position = stmt.end;
-        }
-        else {
-            break;
-        }
-    }
-
-    if (position === 0) {
-        return prepend.join('\n') + '\n' + code;
-    }
-
-    return code.slice(0, position) + '\n' + prepend.join('\n') + '\n' + code.slice(position);
-}
-
-function hasPattern(code: string, patterns: string[]): boolean {
-    for (let i = 0, n = patterns.length; i < n; i++) {
-        if (code.indexOf(patterns[i]) !== -1) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-function modify(code: string, file: ts.SourceFile, pkg: string, options: ModifyOptions): string {
-    if (!options.add && !options.namespace && !options.remove) {
-        return code;
-    }
-
-    let { namespace } = options,
-        add = options.add ? new Set(options.add) : null,
-        found = imports.all(file, pkg);
-
-    if (found.length === 0) {
-        let statements: string[] = [];
-
-        if (namespace) {
-            statements.push(`import * as ${namespace} from '${pkg}';`);
-        }
-
-        if (add && add.size > 0) {
-            statements.push(`import { ${[...add].sort().join(', ')} } from '${pkg}';`);
-        }
-
-        if (statements.length === 0) {
-            return code;
-        }
-
-        return statements.join('\n') + '\n' + code;
-    }
-
-    let remove = options.remove ? new Set(options.remove) : null,
-        specifiers = new Set<string>();
-
-    for (let i = 0, n = found.length; i < n; i++) {
-        for (let [name, alias] of found[i].specifiers) {
-            if (!remove || (!remove.has(name) && !remove.has(alias))) {
-                let base = name === alias ? name : `${name} as ${alias}`;
-
-                // Preserve type-only specifiers with an inline `type` modifier so the merged import
-                // stays erasable — otherwise `import type { X }` re-emits as a runtime `import { X }`
-                // and fails at load time when X has no runtime export.
-                specifiers.add(found[i].typeOnly.has(name) ? `type ${base}` : base);
-            }
-        }
-    }
-
-    if (add) {
-        for (let name of add) {
-            specifiers.add(name);
-        }
-    }
-
-    let statements: string[] = [];
-
-    if (namespace) {
-        statements.push(`import * as ${namespace} from '${pkg}';`);
-    }
-
-    if (specifiers.size > 0) {
-        statements.push(`import { ${[...specifiers].sort().join(', ')} } from '${pkg}';`);
-    }
-
-    let replacements: Replacement[] = [];
-
-    for (let i = 0, n = found.length; i < n; i++) {
-        replacements.push({
-            end: found[i].end,
-            newText: i === 0 ? statements.join('\n') : '',
-            start: found[i].start
-        });
-    }
-
-    return replaceReverse(code, replacements);
-}
-
-function replaceReverse(code: string, replacements: Replacement[]): string {
-    if (replacements.length === 0) {
-        return code;
-    }
-
-    replacements.sort((a, b) => b.start - a.start);
-
-    let parts: string[] = [],
-        pos = code.length;
-
-    for (let i = 0, n = replacements.length; i < n; i++) {
-        let r = replacements[i];
-
-        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 parts.reverse().join('');
-}
-
-
-const transform = (
-    plugins: Plugin[],
-    code: string,
-    file: ts.SourceFile,
-    program: ts.Program,
-    root: string,
-    shared: SharedContext
-) => {
-    if (plugins.length === 0) {
-        return { changed: false, code, sourceFile: file };
-    }
-
-    let changed = false,
-        currentCode = code,
-        currentFile = file,
-        currentProgram = program,
-        fileName = file.fileName,
-        last = plugins.length - 1;
-
-    for (let i = 0, n = plugins.length; i < n; i++) {
-        let plugin = plugins[i];
-
-        if (plugin.patterns && !hasPattern(currentCode, plugin.patterns)) {
-            continue;
-        }
-
-        let { imports, prepend, replacements } = plugin.transform({
-                checker: currentProgram.getTypeChecker(),
-                code: currentCode,
-                program: currentProgram,
-                shared,
-                sourceFile: currentFile
-            }),
-            pluginChanged = false;
-
-        if (replacements?.length) {
-            currentCode = applyIntents(currentCode, currentFile, replacements);
-            pluginChanged = true;
-        }
-
-        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;
-
-            if (i < last) {
-                currentProgram = languageService.update(root, fileName, currentCode);
-                currentFile = currentProgram.getSourceFile(fileName) ||
-                    ts.createSourceFile(fileName, currentCode, file.languageVersion, true);
-            }
-            else {
-                currentFile = ts.createSourceFile(fileName, currentCode, file.languageVersion, true);
-            }
-        }
-    }
-
-    return { changed, code: currentCode, sourceFile: currentFile };
-};
-
-
-export default { transform };
-export type { CoordinatorResult };

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);
-                }
-            }
-        };
-    };
-};