@esportsplus/typescript 0.29.6 → 0.31.0

package/.github/workflows/publish.yml

@@ -1,42 +0,0 @@
-name: publish to npm
-
-on:
-  release:
-    types: [published]
-  workflow_call:
-    secrets:
-      NPM_TOKEN:
-        required: true
-  workflow_dispatch:
-  workflow_run:
-    workflows: [bump version]
-    types:
-      - completed
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      id-token: write
-    steps:
-      - uses: actions/checkout@v7
-      - uses: pnpm/action-setup@v6
-        name: Install pnpm
-        with:
-          run_install: false
-          version: latest
-      - uses: actions/setup-node@v6
-        with:
-          cache: 'pnpm'
-          node-version: 'latest'
-          registry-url: 'https://registry.npmjs.org'
-      - run: pnpm i
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-      - run: pnpm build
-      - run: pnpm publish --no-git-checks

package/.github/workflows/templates/bump.yml

@@ -1,9 +0,0 @@
-name: bump version
-
-on:
-  push:
-    branches: '**' # only trigger on branches, not on tags
-
-jobs:
-  bump:
-    uses: esportsplus/typescript/.github/workflows/bump.yml@main

package/.github/workflows/templates/dependabot.yml

@@ -1,12 +0,0 @@
-name: dependabot automerge
-
-on:
-  pull_request:
-    types: [opened, synchronize, labeled]
-  workflow_dispatch:
-
-jobs:
-  automerge:
-    secrets:
-      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-    uses: esportsplus/typescript/.github/workflows/dependabot.yml@main

package/.github/workflows/templates/publish.yml

@@ -1,16 +0,0 @@
-name: publish to npm
-
-on:
-  release:
-    types: [published]
-  workflow_dispatch:
-  workflow_run:
-    workflows: [bump version]
-    types:
-      - completed
-
-jobs:
-  publish:
-    secrets:
-        NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-    uses: esportsplus/typescript/.github/workflows/publish.yml@main

package/pnpm-workspace.yaml

@@ -1,6 +0,0 @@
-# Approve dependency build scripts (pnpm errors on unapproved ones during install/publish) and trust
-# our own scope so freshly published first-party deps bypass the minimumReleaseAge gate.
-allowBuilds:
-  esbuild: true
-minimumReleaseAgeExclude:
-  - '@esportsplus/*'

package/src/cli/tsc.ts

@@ -1,235 +0,0 @@
-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';
-
-
-type PluginConfig = {
-    transform: string;
-};
-
-
-const BACKSLASH_REGEX = /\\/g;
-
-
-let require = createRequire(import.meta.url),
-    skipFlags = new Set(['--help', '--init', '--noEmit', '--showConfig', '--version', '-h', '-noEmit', '-v']);
-
-
-async function build(config: object, tsconfig: string, pluginConfigs: PluginConfig[]): Promise<void> {
-    let root = path.dirname(path.resolve(tsconfig)),
-        parsed = ts.parseJsonConfigFileContent(config, ts.sys, root);
-
-    if (parsed.errors.length > 0) {
-        for (let i = 0, n = parsed.errors.length; i < n; i++) {
-            console.error(
-                ts.flattenDiagnosticMessageText(parsed.errors[i].messageText, '\n')
-            );
-        }
-
-        process.exit(1);
-    }
-
-    let plugins = await loadPlugins(pluginConfigs, root);
-
-    let program = ts.createProgram(parsed.fileNames, parsed.options),
-        shared: SharedContext = new Map(),
-        transformedFiles = new Map<string, string>();
-
-    for (let i = 0, n = parsed.fileNames.length; i < n; i++) {
-        let fileName = parsed.fileNames[i],
-            sourceFile = program.getSourceFile(fileName);
-
-        if (!sourceFile) {
-            continue;
-        }
-
-        let result = coordinator.transform(
-            plugins,
-            sourceFile.getFullText(),
-            sourceFile,
-            program,
-            root,
-            shared
-        );
-
-        if (result.changed) {
-            transformedFiles.set(normalizePath(fileName), result.code);
-        }
-    }
-
-    if (transformedFiles.size > 0) {
-        let customHost = ts.createCompilerHost(parsed.options),
-            originalGetSourceFile = customHost.getSourceFile.bind(customHost),
-            originalReadFile = customHost.readFile.bind(customHost);
-
-        customHost.getSourceFile = (
-            fileName: string,
-            languageVersion: ts.ScriptTarget,
-            onError?: (message: string) => void,
-            shouldCreateNewSourceFile?: boolean
-        ): ts.SourceFile | undefined => {
-            let transformed = transformedFiles.get(normalizePath(fileName));
-
-            if (transformed) {
-                return ts.createSourceFile(fileName, transformed, languageVersion, true);
-            }
-
-            return originalGetSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
-        };
-
-        customHost.readFile = (fileName: string): string | undefined => {
-            return transformedFiles.get(normalizePath(fileName)) ?? originalReadFile(fileName);
-        };
-
-        program = ts.createProgram(parsed.fileNames, parsed.options, customHost);
-    }
-
-    let { diagnostics, emitSkipped } = program.emit();
-
-    diagnostics = ts.getPreEmitDiagnostics(program).concat(diagnostics);
-
-    if (diagnostics.length > 0) {
-        console.error(
-            ts.formatDiagnosticsWithColorAndContext(diagnostics, {
-                getCanonicalFileName: (fileName) => fileName,
-                getCurrentDirectory: () => root,
-                getNewLine: () => '\n'
-            })
-        );
-    }
-
-    if (emitSkipped) {
-        process.exit(1);
-    }
-
-    return runTscAlias(process.argv.slice(2)).then((code) => process.exit(code));
-}
-
-function isPlugin(value: unknown): value is Plugin {
-    return typeof value === 'object' && value !== null && 'transform' in value && typeof (value as Plugin).transform === 'function';
-}
-
-async function loadPlugins(configs: PluginConfig[], root: string): Promise<Plugin[]> {
-    let plugins: Plugin[] = [],
-        promises: Promise<void>[] = [];
-
-    for (let i = 0, n = configs.length; i < n; i++) {
-        let config = configs[i],
-            pluginPath = config.transform;
-
-        if (pluginPath.startsWith('.')) {
-            pluginPath = pathToFileURL(path.resolve(root, pluginPath)).href;
-        }
-        else {
-            pluginPath = pathToFileURL(require.resolve(pluginPath, { paths: [root] })).href;
-        }
-
-        promises.push(
-            import(pluginPath).then((module) => {
-                let plugin = module.default ?? module;
-
-                if (typeof plugin === 'function') {
-                    plugin = plugin();
-                }
-
-                if (Array.isArray(plugin)) {
-                    for (let j = 0, m = plugin.length; j < m; j++) {
-                        if (isPlugin(plugin[j])) {
-                            plugins.push(plugin[j]);
-                        }
-                        else {
-                            console.error(`${PACKAGE_NAME}: plugin ${config.transform}[${j}] uses an invalid plugin format`);
-                        }
-                    }
-
-                    return;
-                }
-
-                if (!isPlugin(plugin)) {
-                    console.error(`${PACKAGE_NAME}: plugin ${config.transform} uses an invalid plugin format, expected { transform: Function } or Plugin[]`);
-                    return;
-                }
-
-                plugins.push(plugin);
-            })
-        );
-    }
-
-    await Promise.all(promises);
-
-    return plugins;
-}
-
-function main(): void {
-    let tsconfig = ts.findConfigFile(process.cwd(), ts.sys.fileExists, 'tsconfig.json');
-
-    if (!tsconfig) {
-        return passthrough();
-    }
-
-    let { config, error } = ts.readConfigFile(tsconfig, ts.sys.readFile);
-
-    if (error) {
-        return passthrough();
-    }
-
-    let pluginConfigs = config?.compilerOptions?.plugins?.filter(
-            (p: unknown) => typeof p === 'object' && p !== null && 'transform' in p
-        ) ?? [];
-
-    if (pluginConfigs.length === 0) {
-        return passthrough();
-    }
-
-    console.log(`${PACKAGE_NAME}: found ${pluginConfigs.length} transformer plugin(s), using coordinated build...`);
-
-    build(config, tsconfig, pluginConfigs).catch((err) => {
-        console.error(`${PACKAGE_NAME}: ${err}`);
-        process.exit(1);
-    });
-}
-
-function normalizePath(fileName: string): string {
-    return path.resolve(fileName).replace(BACKSLASH_REGEX, '/');
-}
-
-function passthrough(): void {
-    let args = process.argv.slice(2);
-
-    spawn(process.execPath, [require.resolve('typescript/lib/tsc.js'), ...args], { stdio: 'inherit' })
-        .on('exit', async (code) => {
-            if (code === 0) {
-                code = await runTscAlias(args);
-            }
-
-            process.exit(code ?? 0);
-        });
-}
-
-function runTscAlias(args: string[]): Promise<number> {
-    for (let i = 0, n = args.length; i < n; i++) {
-        if (skipFlags.has(args[i])) {
-            return Promise.resolve(0);
-        }
-    }
-
-    return new Promise((resolve) => {
-        let child = spawn(process.execPath, [require.resolve('tsc-alias/dist/bin/index.js'), ...args], { stdio: 'inherit' });
-
-        child.on('exit', (code) => resolve(code ?? 0));
-    });
-}
-
-
-if (process.env.VITEST === undefined) {
-    main();
-}
-
-
-export { build, isPlugin, loadPlugins, normalizePath, runTscAlias };

package/src/compiler/ast.ts

@@ -1,60 +0,0 @@
-import type { Range } from './types';
-import { ts } from '~/index';
-
-
-const expression = {
-    name: (node: ts.Expression): string | null => {
-        if (ts.isIdentifier(node)) {
-            return node.text;
-        }
-
-        if (ts.isPropertyAccessExpression(node)) {
-            return property.path(node);
-        }
-
-        return null;
-    }
-};
-
-const inRange = (ranges: Range[], start: number, end: number): boolean => {
-    for (let i = 0, n = ranges.length; i < n; i++) {
-        let r = ranges[i];
-
-        if (start >= r.start && end <= r.end) {
-            return true;
-        }
-    }
-
-    return false;
-};
-
-const property = {
-    path: (node: ts.Expression): string | null => {
-        let current: ts.Node = node,
-            parts: string[] = [];
-
-        while (ts.isPropertyAccessExpression(current)) {
-            parts.push(current.name.text);
-            current = current.expression;
-        }
-
-        if (ts.isIdentifier(current)) {
-            parts.push(current.text);
-            return parts.reverse().join('.');
-        }
-
-        return null;
-    }
-};
-
-const test = (node: ts.Node, fn: (n: ts.Node) => boolean): boolean => {
-    if (fn(node)) {
-        return true;
-    }
-
-    return !!ts.forEachChild(node, child => test(child, fn) || undefined);
-};
-
-
-export default { expression, inRange, property, test };
-export type { Range };

package/src/compiler/code.ts

@@ -1,27 +0,0 @@
-const SINGLE_QUOTE_REGEX = /'/g;
-
-
-const code = (literals: TemplateStringsArray, ...values: unknown[]): string => {
-    let buffer = '';
-
-    for (let i = 0, n = literals.length; i < n; i++) {
-        buffer += literals[i];
-
-        let value = values[i];
-
-        if (value == null || value === false) {
-            value = '';
-        }
-
-        buffer += value;
-    }
-
-    return buffer;
-};
-
-code.escape = (str: string): string => {
-    return str.replace(SINGLE_QUOTE_REGEX, "\\'");
-};
-
-
-export default code;

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