@esportsplus/typescript 0.24.2 → 0.25.0

package/build/cli/tsc.js

@@ -3,9 +3,10 @@ import { createRequire } from 'module';
 import { pathToFileURL } from 'url';
 import path from 'path';
 import ts from 'typescript';
+import coordinator from '../compiler/coordinator.js';
 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, tsconfig, plugins) {
+async function build(config, tsconfig, pluginConfigs) {
     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++) {
@@ -13,63 +14,50 @@ async function build(config, tsconfig, plugins) {
         }
         process.exit(1);
     }
-    await loadPlugins(plugins, root).then((factories) => {
-        let context = new Map(), printer = ts.createPrinter(), program = ts.createProgram(parsed.fileNames, parsed.options), transformedFiles = new Map();
-        let instances = factories.before.map(f => f(program, context));
-        for (let i = 0, n = parsed.fileNames.length; i < n; i++) {
-            let fileName = parsed.fileNames[i], sourceFile = program.getSourceFile(fileName);
-            if (!sourceFile) {
-                continue;
-            }
-            for (let j = 0, m = instances.length; j < m; j++) {
-                instances[j].analyze?.(sourceFile);
-            }
-        }
-        let transformers = instances.map(i => i.transform);
-        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 = ts.transform(sourceFile, transformers), transformed = result.transformed[0];
-            if (transformed !== sourceFile) {
-                transformedFiles.set(normalizePath(fileName), printer.printFile(transformed));
-            }
-            result.dispose();
+    let plugins = await loadPlugins(pluginConfigs, root);
+    let program = ts.createProgram(parsed.fileNames, parsed.options), shared = new Map(), transformedFiles = new Map();
+    for (let i = 0, n = parsed.fileNames.length; i < n; i++) {
+        let fileName = parsed.fileNames[i], sourceFile = program.getSourceFile(fileName);
+        if (!sourceFile) {
+            continue;
         }
-        if (transformedFiles.size > 0) {
-            let customHost = ts.createCompilerHost(parsed.options), originalGetSourceFile = customHost.getSourceFile.bind(customHost), originalReadFile = customHost.readFile.bind(customHost);
-            customHost.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
-                let transformed = transformedFiles.get(normalizePath(fileName));
-                if (transformed) {
-                    return ts.createSourceFile(fileName, transformed, languageVersion, true);
-                }
-                return originalGetSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
-            };
-            customHost.readFile = (fileName) => {
-                return transformedFiles.get(normalizePath(fileName)) ?? originalReadFile(fileName);
-            };
-            program = ts.createProgram(parsed.fileNames, parsed.options, customHost);
+        let result = coordinator.transform(plugins, sourceFile.getFullText(), sourceFile, program, shared);
+        if (result.changed) {
+            transformedFiles.set(normalizePath(fileName), result.code);
         }
-        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));
-    });
+    }
+    if (transformedFiles.size > 0) {
+        let customHost = ts.createCompilerHost(parsed.options), originalGetSourceFile = customHost.getSourceFile.bind(customHost), originalReadFile = customHost.readFile.bind(customHost);
+        customHost.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
+            let transformed = transformedFiles.get(normalizePath(fileName));
+            if (transformed) {
+                return ts.createSourceFile(fileName, transformed, languageVersion, true);
+            }
+            return originalGetSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
+        };
+        customHost.readFile = (fileName) => {
+            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));
 }
-async function loadPlugins(plugins, root) {
-    let after = [], before = [], promises = [];
-    for (let i = 0, n = plugins.length; i < n; i++) {
-        let plugin = plugins[i], pluginPath = plugin.transform;
+async function loadPlugins(configs, root) {
+    let plugins = [], promises = [];
+    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;
         }
@@ -77,20 +65,19 @@ async function loadPlugins(plugins, root) {
             pluginPath = pathToFileURL(require.resolve(pluginPath, { paths: [root] })).href;
         }
         promises.push(import(pluginPath).then((module) => {
-            let factory = module.default ?? module.createTransformer ?? module;
-            if (typeof factory !== 'function') {
-                console.error(`Plugin ${plugin.transform}: no transformer factory found`);
-                return;
-            }
-            if (plugin.after) {
-                after.push(factory);
+            let plugin = module.default ?? module;
+            if (typeof plugin === 'function') {
+                plugin = plugin();
             }
-            else {
-                before.push(factory);
+            if (!plugin || typeof plugin.transform !== 'function') {
+                console.error(`Plugin ${config.transform}: invalid plugin format, expected { transform: Function }`);
+                return;
             }
+            plugins.push(plugin);
         }));
     }
-    return Promise.all(promises).then(() => ({ after, before }));
+    await Promise.all(promises);
+    return plugins;
 }
 function main() {
     let tsconfig = ts.findConfigFile(process.cwd(), ts.sys.fileExists, 'tsconfig.json');
@@ -101,9 +88,12 @@ function main() {
     if (error) {
         return passthrough();
     }
-    let plugins = config?.compilerOptions?.plugins?.filter((p) => typeof p === 'object' && p !== null && 'transform' in p) ?? [];
-    console.log(`Found ${plugins.length} transformer plugin(s), using programmatic build...`);
-    build(config, tsconfig, plugins).catch((err) => {
+    let pluginConfigs = config?.compilerOptions?.plugins?.filter((p) => typeof p === 'object' && p !== null && 'transform' in p) ?? [];
+    if (pluginConfigs.length === 0) {
+        return passthrough();
+    }
+    console.log(`Found ${pluginConfigs.length} transformer plugin(s), using coordinated build...`);
+    build(config, tsconfig, pluginConfigs).catch((err) => {
         console.error(err);
         process.exit(1);
     });

package/build/compiler/coordinator.d.ts

@@ -0,0 +1,12 @@
+import type { Plugin, SharedContext } from './types.js';
+import { ts } from '../index.js';
+type CoordinatorResult = {
+    changed: boolean;
+    code: string;
+    sourceFile: ts.SourceFile;
+};
+declare const _default: {
+    transform: (plugins: Plugin[], sourceCode: string, sourceFile: ts.SourceFile, program: ts.Program, shared: SharedContext) => CoordinatorResult;
+};
+export default _default;
+export type { CoordinatorResult };

package/build/compiler/coordinator.js

@@ -0,0 +1,100 @@
+import { ts } from '../index.js';
+import code from './code.js';
+import imports from './imports.js';
+function applyImports(sourceCode, sourceFile, intents) {
+    let result = sourceCode;
+    for (let i = 0, n = intents.length; i < n; i++) {
+        let intent = intents[i];
+        result = imports.modify(result, sourceFile, intent.package, {
+            add: intent.add,
+            namespace: intent.namespace,
+            remove: intent.remove
+        });
+        if (i < n - 1) {
+            sourceFile = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
+        }
+    }
+    return result;
+}
+function applyIntents(sourceCode, sourceFile, intents) {
+    if (intents.length === 0) {
+        return sourceCode;
+    }
+    let replacements = intents.map(intent => ({
+        end: intent.node.end,
+        newText: intent.generate(sourceFile),
+        start: intent.node.getStart(sourceFile)
+    }));
+    return code.replaceReverse(sourceCode, replacements);
+}
+function applyPrepend(sourceCode, sourceFile, prepend) {
+    if (prepend.length === 0) {
+        return sourceCode;
+    }
+    let insertPos = findLastImportEnd(sourceFile), prependText = prepend.join('\n') + '\n';
+    if (insertPos === 0) {
+        return prependText + sourceCode;
+    }
+    return sourceCode.slice(0, insertPos) + '\n' + prependText + sourceCode.slice(insertPos);
+}
+function findLastImportEnd(sourceFile) {
+    let lastEnd = 0;
+    for (let i = 0, n = sourceFile.statements.length; i < n; i++) {
+        let stmt = sourceFile.statements[i];
+        if (ts.isImportDeclaration(stmt)) {
+            lastEnd = stmt.end;
+        }
+        else {
+            break;
+        }
+    }
+    return lastEnd;
+}
+function hasPattern(sourceCode, patterns) {
+    for (let i = 0, n = patterns.length; i < n; i++) {
+        if (sourceCode.indexOf(patterns[i]) !== -1) {
+            return true;
+        }
+    }
+    return false;
+}
+const transform = (plugins, sourceCode, sourceFile, program, shared) => {
+    if (plugins.length === 0) {
+        return { changed: false, code: sourceCode, sourceFile };
+    }
+    let changed = false, currentCode = sourceCode, currentSourceFile = sourceFile;
+    for (let i = 0, n = plugins.length; i < n; i++) {
+        let plugin = plugins[i];
+        if (plugin.patterns && !hasPattern(currentCode, plugin.patterns)) {
+            continue;
+        }
+        let result = plugin.transform({
+            checker: program.getTypeChecker(),
+            code: currentCode,
+            program,
+            shared,
+            sourceFile: currentSourceFile
+        });
+        let hasChanges = (result.imports && result.imports.length > 0) ||
+            (result.prepend && result.prepend.length > 0) ||
+            (result.replacements && result.replacements.length > 0);
+        if (!hasChanges) {
+            continue;
+        }
+        changed = true;
+        if (result.replacements && result.replacements.length > 0) {
+            currentCode = applyIntents(currentCode, currentSourceFile, result.replacements);
+            currentSourceFile = ts.createSourceFile(currentSourceFile.fileName, currentCode, currentSourceFile.languageVersion, true);
+        }
+        if (result.prepend && result.prepend.length > 0) {
+            currentCode = applyPrepend(currentCode, currentSourceFile, result.prepend);
+            currentSourceFile = ts.createSourceFile(currentSourceFile.fileName, currentCode, currentSourceFile.languageVersion, true);
+        }
+        if (result.imports && result.imports.length > 0) {
+            currentCode = applyImports(currentCode, currentSourceFile, result.imports);
+            currentSourceFile = ts.createSourceFile(currentSourceFile.fileName, currentCode, currentSourceFile.languageVersion, true);
+        }
+    }
+    return { changed, code: currentCode, sourceFile: currentSourceFile };
+};
+export default { transform };

package/build/compiler/index.d.ts

@@ -1,5 +1,6 @@
 export * as ast from './ast/index.js';
 export { default as code } from './code.js';
+export { default as coordinator } from './coordinator.js';
 export { default as imports } from './imports.js';
 export { default as plugin } from './plugins/index.js';
 export { default as program } from './program.js';

package/build/compiler/index.js

@@ -1,5 +1,6 @@
 export * as ast from './ast/index.js';
 export { default as code } from './code.js';
+export { default as coordinator } from './coordinator.js';
 export { default as imports } from './imports.js';
 export { default as plugin } from './plugins/index.js';
 export { default as program } from './program.js';

package/build/compiler/plugins/index.d.ts

@@ -1,13 +1,11 @@
 declare const _default: {
-    tsc: ({ analyze, transform }: import("../index.js").PluginDefinition) => (program: import("typescript").Program, context: import("../index.js").PluginContext) => {
-        analyze: ((sourceFile: import("typescript").SourceFile) => void) | undefined;
+    tsc: (plugins: import("../types.js").Plugin[]) => (program: import("typescript").Program, shared: import("../types.js").SharedContext) => {
         transform: import("typescript").TransformerFactory<import("typescript").SourceFile>;
     };
-    vite: ({ analyze, name, onWatchChange, transform }: {
-        analyze?: import("../index.js").AnalyzeFn;
+    vite: ({ name, onWatchChange, plugins }: {
         name: string;
         onWatchChange?: () => void;
-        transform: import("../index.js").TransformFn;
+        plugins: import("../types.js").Plugin[];
     }) => ({ root }?: {
         root?: string;
     }) => {

package/build/compiler/plugins/tsc.d.ts

@@ -1,7 +1,7 @@
-import type { PluginContext, PluginDefinition } from '../types.js';
-import { ts } from '../../index.js';
-declare const _default: ({ analyze, transform }: PluginDefinition) => (program: ts.Program, context: PluginContext) => {
-    analyze: ((sourceFile: ts.SourceFile) => void) | undefined;
+import type { Plugin, SharedContext } from '../types.js';
+import type ts from 'typescript';
+type PluginInstance = {
     transform: ts.TransformerFactory<ts.SourceFile>;
 };
+declare const _default: (plugins: Plugin[]) => (program: ts.Program, shared: SharedContext) => PluginInstance;
 export default _default;

package/build/compiler/plugins/tsc.js

@@ -1,12 +1,10 @@
-export default ({ analyze, transform }) => {
-    return (program, context) => {
+import coordinator from '../coordinator.js';
+export default (plugins) => {
+    return (program, shared) => {
         return {
-            analyze: analyze
-                ? (sourceFile) => analyze(sourceFile, program, context)
-                : undefined,
             transform: (() => {
                 return (sourceFile) => {
-                    let result = transform(sourceFile, program, context);
+                    let result = coordinator.transform(plugins, sourceFile.getFullText(), sourceFile, program, shared);
                     return result.changed ? result.sourceFile : sourceFile;
                 };
             })

package/build/compiler/plugins/vite.d.ts

@@ -1,4 +1,4 @@
-import type { AnalyzeFn, TransformFn } from '../types.js';
+import type { Plugin } from '../types.js';
 type VitePlugin = {
     configResolved: (config: unknown) => void;
     enforce: 'pre';
@@ -10,12 +10,11 @@ type VitePlugin = {
     watchChange: (id: string) => void;
 };
 type VitePluginOptions = {
-    analyze?: AnalyzeFn;
     name: string;
     onWatchChange?: () => void;
-    transform: TransformFn;
+    plugins: Plugin[];
 };
-declare const _default: ({ analyze, name, onWatchChange, transform }: VitePluginOptions) => ({ root }?: {
+declare const _default: ({ name, onWatchChange, plugins }: VitePluginOptions) => ({ root }?: {
     root?: string;
 }) => VitePlugin;
 export default _default;

package/build/compiler/plugins/vite.js

@@ -1,8 +1,9 @@
 import { ts } from '../../index.js';
+import coordinator from '../coordinator.js';
 import program from '../program.js';
 const FILE_REGEX = /\.[tj]sx?$/;
 let contexts = new Map();
-export default ({ analyze, name, onWatchChange, transform }) => {
+export default ({ name, onWatchChange, plugins }) => {
     return ({ root } = {}) => {
         return {
             configResolved(config) {
@@ -15,9 +16,8 @@ export default ({ analyze, name, onWatchChange, transform }) => {
                     return null;
                 }
                 try {
-                    let context = contexts.get(root || '') ?? contexts.set(root || '', new Map()).get(root || ''), prog = program.get(root || ''), sourceFile = ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true);
-                    analyze?.(sourceFile, prog, context);
-                    let result = transform(sourceFile, prog, context);
+                    let prog = program.get(root || ''), shared = contexts.get(root || '') ?? contexts.set(root || '', new Map()).get(root || ''), sourceFile = ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true);
+                    let result = coordinator.transform(plugins, code, sourceFile, prog, shared);
                     if (!result.changed) {
                         return null;
                     }

package/build/compiler/types.d.ts

@@ -1,10 +1,15 @@
 import type ts from 'typescript';
-type AnalyzeFn = (sourceFile: ts.SourceFile, program: ts.Program, context: PluginContext) => void;
-type PluginContext = Map<string, unknown>;
-type PluginDefinition = {
-    analyze?: AnalyzeFn;
-    transform: TransformFn;
+type ImportIntent = {
+    add?: string[];
+    namespace?: string;
+    package: string;
+    remove?: string[];
 };
+type Plugin = {
+    patterns?: string[];
+    transform: (ctx: TransformContext) => TransformResult;
+};
+type PluginFactory = (options?: Record<string, unknown>) => Plugin;
 type QuickCheckPattern = {
     patterns?: string[];
     regex?: RegExp;
@@ -16,10 +21,21 @@ type Range = {
 type Replacement = Range & {
     newText: string;
 };
-type TransformFn = (sourceFile: ts.SourceFile, program: ts.Program, context?: PluginContext) => TransformResult;
-type TransformResult = {
-    changed: boolean;
+type ReplacementIntent = {
+    generate: (sourceFile: ts.SourceFile) => string;
+    node: ts.Node;
+};
+type SharedContext = Map<string, unknown>;
+type TransformContext = {
+    checker: ts.TypeChecker;
     code: string;
+    program: ts.Program;
+    shared: SharedContext;
     sourceFile: ts.SourceFile;
 };
-export type { AnalyzeFn, PluginContext, PluginDefinition, QuickCheckPattern, Range, Replacement, TransformFn, TransformResult };
+type TransformResult = {
+    imports?: ImportIntent[];
+    prepend?: string[];
+    replacements?: ReplacementIntent[];
+};
+export type { ImportIntent, Plugin, PluginFactory, QuickCheckPattern, Range, Replacement, ReplacementIntent, SharedContext, TransformContext, TransformResult };

package/package.json

@@ -37,7 +37,7 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.24.2",
+  "version": "0.25.0",
   "scripts": {
     "build": "tsc && tsc-alias",
     "-": "-"

package/src/cli/tsc.ts

@@ -1,9 +1,10 @@
 import { spawn } from 'child_process';
 import { createRequire } from 'module';
 import { pathToFileURL } from 'url';
-
 import path from 'path';
 import ts from 'typescript';
+import coordinator from '~/compiler/coordinator';
+import type { Plugin, SharedContext } from '~/compiler/types';
 
 
 type PluginConfig = {
@@ -11,15 +12,6 @@ type PluginConfig = {
     transform: string;
 };
 
-type PluginContext = Map<string, unknown>;
-
-type PluginInstance = {
-    analyze?: (sourceFile: ts.SourceFile) => void;
-    transform: ts.TransformerFactory<ts.SourceFile>;
-};
-
-type PluginFactory = (program: ts.Program, context: PluginContext) => PluginInstance;
-
 
 const BACKSLASH_REGEX = /\\/g;
 
@@ -28,7 +20,7 @@ let require = createRequire(import.meta.url),
     skipFlags = new Set(['--help', '--init', '--noEmit', '--showConfig', '--version', '-h', '-noEmit', '-v']);
 
 
-async function build(config: object, tsconfig: string, plugins: PluginConfig[]): Promise<void> {
+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);
 
@@ -42,110 +34,88 @@ async function build(config: object, tsconfig: string, plugins: PluginConfig[]):
         process.exit(1);
     }
 
-    await loadPlugins(plugins, root).then((factories) => {
-        let context: PluginContext = new Map(),
-            printer = ts.createPrinter(),
-            program = ts.createProgram(parsed.fileNames, parsed.options),
-            transformedFiles = new Map<string, string>();
+    let plugins = await loadPlugins(pluginConfigs, root);
 
-        // Create plugin instances with shared context
-        let instances = factories.before.map(f => f(program, context));
+    let program = ts.createProgram(parsed.fileNames, parsed.options),
+        shared: SharedContext = new Map(),
+        transformedFiles = new Map<string, string>();
 
-        // Phase 1: Analyze - all plugins analyze all files first
-        for (let i = 0, n = parsed.fileNames.length; i < n; i++) {
-            let fileName = parsed.fileNames[i],
-                sourceFile = program.getSourceFile(fileName);
+    for (let i = 0, n = parsed.fileNames.length; i < n; i++) {
+        let fileName = parsed.fileNames[i],
+            sourceFile = program.getSourceFile(fileName);
 
-            if (!sourceFile) {
-                continue;
-            }
-
-            for (let j = 0, m = instances.length; j < m; j++) {
-                instances[j].analyze?.(sourceFile);
-            }
+        if (!sourceFile) {
+            continue;
         }
 
-        // Phase 2: Transform - all plugins transform all files
-        let transformers = instances.map(i => i.transform);
-
-        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 = ts.transform(sourceFile, transformers),
-                transformed = result.transformed[0];
-
-            if (transformed !== sourceFile) {
-                transformedFiles.set(normalizePath(fileName), printer.printFile(transformed));
-            }
+        let result = coordinator.transform(
+            plugins,
+            sourceFile.getFullText(),
+            sourceFile,
+            program,
+            shared
+        );
 
-            result.dispose();
+        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);
-                }
+    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);
-            };
+            return originalGetSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
+        };
 
-            customHost.readFile = (fileName: string): string | undefined => {
-                return transformedFiles.get(normalizePath(fileName)) ?? originalReadFile(fileName);
-            };
+        customHost.readFile = (fileName: string): string | undefined => {
+            return transformedFiles.get(normalizePath(fileName)) ?? originalReadFile(fileName);
+        };
 
-            program = ts.createProgram(parsed.fileNames, parsed.options, customHost);
-        }
+        program = ts.createProgram(parsed.fileNames, parsed.options, customHost);
+    }
 
-        let { diagnostics, emitSkipped } = program.emit();
+    let { diagnostics, emitSkipped } = program.emit();
 
-        diagnostics = ts.getPreEmitDiagnostics(program).concat(diagnostics);
+    diagnostics = ts.getPreEmitDiagnostics(program).concat(diagnostics);
 
-        if (diagnostics.length > 0) {
-            console.error(
-                ts.formatDiagnosticsWithColorAndContext(diagnostics, {
-                    getCanonicalFileName: (fileName) => fileName,
-                    getCurrentDirectory: () => root,
-                    getNewLine: () => '\n'
-                })
-            );
-        }
+    if (diagnostics.length > 0) {
+        console.error(
+            ts.formatDiagnosticsWithColorAndContext(diagnostics, {
+                getCanonicalFileName: (fileName) => fileName,
+                getCurrentDirectory: () => root,
+                getNewLine: () => '\n'
+            })
+        );
+    }
 
-        if (emitSkipped) {
-            process.exit(1);
-        }
+    if (emitSkipped) {
+        process.exit(1);
+    }
 
-        return runTscAlias(process.argv.slice(2)).then((code) => process.exit(code));
-    });
+    return runTscAlias(process.argv.slice(2)).then((code) => process.exit(code));
 }
 
-async function loadPlugins(plugins: PluginConfig[], root: string): Promise<{
-    after: PluginFactory[];
-    before: PluginFactory[];
-}> {
-    let after: PluginFactory[] = [],
-        before: PluginFactory[] = [],
+async function loadPlugins(configs: PluginConfig[], root: string): Promise<Plugin[]> {
+    let plugins: Plugin[] = [],
         promises: Promise<void>[] = [];
 
-    for (let i = 0, n = plugins.length; i < n; i++) {
-        let plugin = plugins[i],
-            pluginPath = plugin.transform;
+    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;
@@ -156,24 +126,25 @@ async function loadPlugins(plugins: PluginConfig[], root: string): Promise<{
 
         promises.push(
             import(pluginPath).then((module) => {
-                let factory = module.default ?? module.createTransformer ?? module;
+                let plugin = module.default ?? module;
 
-                if (typeof factory !== 'function') {
-                    console.error(`Plugin ${plugin.transform}: no transformer factory found`);
-                    return;
+                if (typeof plugin === 'function') {
+                    plugin = plugin();
                 }
 
-                if (plugin.after) {
-                    after.push(factory);
-                }
-                else {
-                    before.push(factory);
+                if (!plugin || typeof plugin.transform !== 'function') {
+                    console.error(`Plugin ${config.transform}: invalid plugin format, expected { transform: Function }`);
+                    return;
                 }
+
+                plugins.push(plugin);
             })
         );
     }
 
-    return Promise.all(promises).then(() => ({ after, before }));
+    await Promise.all(promises);
+
+    return plugins;
 }
 
 function main(): void {
@@ -189,13 +160,17 @@ function main(): void {
         return passthrough();
     }
 
-    let plugins = config?.compilerOptions?.plugins?.filter(
+    let pluginConfigs = config?.compilerOptions?.plugins?.filter(
             (p: unknown) => typeof p === 'object' && p !== null && 'transform' in p
         ) ?? [];
 
-    console.log(`Found ${plugins.length} transformer plugin(s), using programmatic build...`);
+    if (pluginConfigs.length === 0) {
+        return passthrough();
+    }
+
+    console.log(`Found ${pluginConfigs.length} transformer plugin(s), using coordinated build...`);
 
-    build(config, tsconfig, plugins).catch((err) => {
+    build(config, tsconfig, pluginConfigs).catch((err) => {
         console.error(err);
         process.exit(1);
     });

package/src/compiler/coordinator.ts

@@ -0,0 +1,184 @@
+import type { ImportIntent, Plugin, ReplacementIntent, SharedContext } from './types.js';
+import { ts } from '~/index.js';
+import code from './code.js';
+import imports from './imports.js';
+
+
+type CoordinatorResult = {
+    changed: boolean;
+    code: string;
+    sourceFile: ts.SourceFile;
+};
+
+
+function applyImports(
+    sourceCode: string,
+    sourceFile: ts.SourceFile,
+    intents: ImportIntent[]
+): string {
+    let result = sourceCode;
+
+    for (let i = 0, n = intents.length; i < n; i++) {
+        let intent = intents[i];
+
+        result = imports.modify(result, sourceFile, intent.package, {
+            add: intent.add,
+            namespace: intent.namespace,
+            remove: intent.remove
+        });
+
+        if (i < n - 1) {
+            sourceFile = ts.createSourceFile(
+                sourceFile.fileName,
+                result,
+                sourceFile.languageVersion,
+                true
+            );
+        }
+    }
+
+    return result;
+}
+
+function applyIntents(
+    sourceCode: string,
+    sourceFile: ts.SourceFile,
+    intents: ReplacementIntent[]
+): string {
+    if (intents.length === 0) {
+        return sourceCode;
+    }
+
+    let replacements = intents.map(intent => ({
+        end: intent.node.end,
+        newText: intent.generate(sourceFile),
+        start: intent.node.getStart(sourceFile)
+    }));
+
+    return code.replaceReverse(sourceCode, replacements);
+}
+
+function applyPrepend(sourceCode: string, sourceFile: ts.SourceFile, prepend: string[]): string {
+    if (prepend.length === 0) {
+        return sourceCode;
+    }
+
+    let insertPos = findLastImportEnd(sourceFile),
+        prependText = prepend.join('\n') + '\n';
+
+    if (insertPos === 0) {
+        return prependText + sourceCode;
+    }
+
+    return sourceCode.slice(0, insertPos) + '\n' + prependText + sourceCode.slice(insertPos);
+}
+
+function findLastImportEnd(sourceFile: ts.SourceFile): number {
+    let lastEnd = 0;
+
+    for (let i = 0, n = sourceFile.statements.length; i < n; i++) {
+        let stmt = sourceFile.statements[i];
+
+        if (ts.isImportDeclaration(stmt)) {
+            lastEnd = stmt.end;
+        }
+        else {
+            break;
+        }
+    }
+
+    return lastEnd;
+}
+
+function hasPattern(sourceCode: string, patterns: string[]): boolean {
+    for (let i = 0, n = patterns.length; i < n; i++) {
+        if (sourceCode.indexOf(patterns[i]) !== -1) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+
+/**
+ * Transform source through all plugins sequentially.
+ * Each plugin receives fresh AST with accurate positions.
+ */
+const transform = (
+    plugins: Plugin[],
+    sourceCode: string,
+    sourceFile: ts.SourceFile,
+    program: ts.Program,
+    shared: SharedContext
+): CoordinatorResult => {
+    if (plugins.length === 0) {
+        return { changed: false, code: sourceCode, sourceFile };
+    }
+
+    let changed = false,
+        currentCode = sourceCode,
+        currentSourceFile = sourceFile;
+
+    for (let i = 0, n = plugins.length; i < n; i++) {
+        let plugin = plugins[i];
+
+        if (plugin.patterns && !hasPattern(currentCode, plugin.patterns)) {
+            continue;
+        }
+
+        let result = plugin.transform({
+            checker: program.getTypeChecker(),
+            code: currentCode,
+            program,
+            shared,
+            sourceFile: currentSourceFile
+        });
+
+        let hasChanges = (result.imports && result.imports.length > 0) ||
+            (result.prepend && result.prepend.length > 0) ||
+            (result.replacements && result.replacements.length > 0);
+
+        if (!hasChanges) {
+            continue;
+        }
+
+        changed = true;
+
+        if (result.replacements && result.replacements.length > 0) {
+            currentCode = applyIntents(currentCode, currentSourceFile, result.replacements);
+            currentSourceFile = ts.createSourceFile(
+                currentSourceFile.fileName,
+                currentCode,
+                currentSourceFile.languageVersion,
+                true
+            );
+        }
+
+        if (result.prepend && result.prepend.length > 0) {
+            currentCode = applyPrepend(currentCode, currentSourceFile, result.prepend);
+            currentSourceFile = ts.createSourceFile(
+                currentSourceFile.fileName,
+                currentCode,
+                currentSourceFile.languageVersion,
+                true
+            );
+        }
+
+        if (result.imports && result.imports.length > 0) {
+            currentCode = applyImports(currentCode, currentSourceFile, result.imports);
+            currentSourceFile = ts.createSourceFile(
+                currentSourceFile.fileName,
+                currentCode,
+                currentSourceFile.languageVersion,
+                true
+            );
+        }
+    }
+
+    return { changed, code: currentCode, sourceFile: currentSourceFile };
+};
+
+
+export default { transform };
+export type { CoordinatorResult };

package/src/compiler/index.ts

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

package/src/compiler/plugins/index.ts

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

package/src/compiler/plugins/tsc.ts

@@ -1,20 +1,29 @@
-import type { PluginContext, PluginDefinition } from '../types';
-import { ts } from '../..';
+import type { Plugin, SharedContext } from '../types.js';
+import type ts from 'typescript';
+import coordinator from '../coordinator.js';
 
 
-export default ({ analyze, transform }: PluginDefinition) => {
-    return (program: ts.Program, context: PluginContext) => {
+type PluginInstance = {
+    transform: ts.TransformerFactory<ts.SourceFile>;
+};
+
+
+export default (plugins: Plugin[]) => {
+    return (program: ts.Program, shared: SharedContext): PluginInstance => {
         return {
-            analyze: analyze
-                ? (sourceFile: ts.SourceFile) => analyze(sourceFile, program, context)
-                : undefined,
             transform: (() => {
-                return (sourceFile) => {
-                    let result = transform(sourceFile, program, context);
+                return (sourceFile: ts.SourceFile) => {
+                    let result = coordinator.transform(
+                            plugins,
+                            sourceFile.getFullText(),
+                            sourceFile,
+                            program,
+                            shared
+                        );
 
                     return result.changed ? result.sourceFile : sourceFile;
                 };
             }) as ts.TransformerFactory<ts.SourceFile>
         };
     };
-}
+};

package/src/compiler/plugins/vite.ts

@@ -1,7 +1,8 @@
 import type { ResolvedConfig } from 'vite';
-import type { AnalyzeFn, PluginContext, TransformFn } from '../types';
-import { ts } from '../..';
-import program from '../program';
+import type { Plugin, SharedContext } from '../types.js';
+import { ts } from '~/index.js';
+import coordinator from '../coordinator.js';
+import program from '../program.js';
 
 
 type VitePlugin = {
@@ -13,20 +14,19 @@ type VitePlugin = {
 };
 
 type VitePluginOptions = {
-    analyze?: AnalyzeFn;
     name: string;
     onWatchChange?: () => void;
-    transform: TransformFn;
+    plugins: Plugin[];
 };
 
 
 const FILE_REGEX = /\.[tj]sx?$/;
 
 
-let contexts = new Map<string, PluginContext>();
+let contexts = new Map<string, SharedContext>();
 
 
-export default ({ analyze, name, onWatchChange, transform }: VitePluginOptions) => {
+export default ({ name, onWatchChange, plugins }: VitePluginOptions) => {
     return ({ root }: { root?: string } = {}): VitePlugin => {
         return {
             configResolved(config: unknown) {
@@ -40,13 +40,11 @@ export default ({ analyze, name, onWatchChange, transform }: VitePluginOptions)
                 }
 
                 try {
-                    let context = contexts.get(root || '') ?? contexts.set(root || '', new Map()).get(root || '')!,
-                        prog = program.get(root || ''),
+                    let prog = program.get(root || ''),
+                        shared = contexts.get(root || '') ?? contexts.set(root || '', new Map()).get(root || '')!,
                         sourceFile = ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true);
 
-                    analyze?.(sourceFile, prog, context);
-
-                    let result = transform(sourceFile, prog, context);
+                    let result = coordinator.transform(plugins, code, sourceFile, prog, shared);
 
                     if (!result.changed) {
                         return null;
@@ -62,7 +60,6 @@ export default ({ analyze, name, onWatchChange, transform }: VitePluginOptions)
             watchChange(id: string) {
                 if (FILE_REGEX.test(id)) {
                     onWatchChange?.();
-
                     contexts.delete(root || '');
                     program.delete(root || '');
                 }

package/src/compiler/types.ts

@@ -1,15 +1,29 @@
 import type ts from 'typescript';
 
 
-type AnalyzeFn = (sourceFile: ts.SourceFile, program: ts.Program, context: PluginContext) => void;
+type ImportIntent = {
+    add?: string[];
+    namespace?: string;
+    package: string;
+    remove?: string[];
+};
 
-type PluginContext = Map<string, unknown>;
+type Plugin = {
+    /**
+     * Optional patterns for quick-check optimization.
+     * If provided, transform() is only called when source contains at least one pattern.
+     */
+    patterns?: string[];
 
-type PluginDefinition = {
-    analyze?: AnalyzeFn;
-    transform: TransformFn;
+    /**
+     * 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 QuickCheckPattern = {
     patterns?: string[];
     regex?: RegExp;
@@ -24,19 +38,52 @@ type Replacement = Range & {
     newText: string;
 };
 
-type TransformFn = (sourceFile: ts.SourceFile, program: ts.Program, context?: PluginContext) => TransformResult;
+type ReplacementIntent = {
+    /**
+     * Generator function that produces the replacement text.
+     * Called at apply-time with current sourceFile for accurate positions.
+     */
+    generate: (sourceFile: ts.SourceFile) => string;
 
-type TransformResult = {
-    changed: boolean;
+    /**
+     * 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 {
-    AnalyzeFn,
-    PluginContext, PluginDefinition,
+    ImportIntent,
+    Plugin, PluginFactory,
     QuickCheckPattern,
-    Range, Replacement,
-    TransformFn, TransformResult
+    Range, Replacement, ReplacementIntent,
+    SharedContext,
+    TransformContext, TransformResult
 };