@esportsplus/typescript 0.24.2 → 0.25.1

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/ast/expression.d.ts

@@ -1,6 +1,4 @@
-import { ts } from '../../index.js';
+import ts from 'typescript';
 declare const getExpressionName: (node: ts.Expression) => string | null;
-declare const getPropertyPath: (node: ts.Expression) => string[] | null;
-declare const getPropertyPathString: (node: ts.Expression) => string | null;
-declare const unwrapParentheses: (expr: ts.Expression) => ts.Expression;
-export { getExpressionName, getPropertyPath, getPropertyPathString, unwrapParentheses };
+declare const getPropertyPath: (node: ts.Expression) => string | null;
+export { getExpressionName, getPropertyPath };

package/build/compiler/ast/expression.js

@@ -1,10 +1,10 @@
-import { ts } from '../../index.js';
+import ts from 'typescript';
 const getExpressionName = (node) => {
     if (ts.isIdentifier(node)) {
         return node.text;
     }
     if (ts.isPropertyAccessExpression(node)) {
-        return getPropertyPathString(node);
+        return getPropertyPath(node);
     }
     return null;
 };
@@ -16,18 +16,8 @@ const getPropertyPath = (node) => {
     }
     if (ts.isIdentifier(current)) {
         parts.push(current.text);
-        return parts.reverse();
+        return parts.reverse().join('.');
     }
     return null;
 };
-const getPropertyPathString = (node) => {
-    let parts = getPropertyPath(node);
-    return parts ? parts.join('.') : null;
-};
-const unwrapParentheses = (expr) => {
-    while (ts.isParenthesizedExpression(expr)) {
-        expr = expr.expression;
-    }
-    return expr;
-};
-export { getExpressionName, getPropertyPath, getPropertyPathString, unwrapParentheses };
+export { getExpressionName, getPropertyPath };

package/build/compiler/ast/range.d.ts

@@ -2,7 +2,6 @@ type Range = {
     end: number;
     start: number;
 };
-declare const containsPosition: (range: Range, pos: number) => boolean;
 declare const inRange: (ranges: Range[], start: number, end: number) => boolean;
-export { containsPosition, inRange };
+export { inRange };
 export type { Range };

package/build/compiler/ast/range.js

@@ -1,6 +1,3 @@
-const containsPosition = (range, pos) => {
-    return pos >= range.start && pos <= range.end;
-};
 const inRange = (ranges, start, end) => {
     for (let i = 0, n = ranges.length; i < n; i++) {
         let r = ranges[i];
@@ -10,4 +7,4 @@ const inRange = (ranges, start, end) => {
     }
     return false;
 };
-export { containsPosition, inRange };
+export { inRange };

package/build/compiler/code.d.ts

@@ -1,7 +1,5 @@
-import type { QuickCheckPattern, Replacement } from './types.js';
+import type { Replacement } from './types.js';
 declare const _default: {
-    contains: (code: string, { regex, patterns }: QuickCheckPattern) => boolean;
-    replace: (code: string, replacements: Replacement[]) => string;
     replaceReverse: (code: string, replacements: Replacement[]) => string;
 };
 export default _default;

package/build/compiler/code.js

@@ -1,35 +1,3 @@
-const contains = (code, { regex, patterns }) => {
-    if (regex) {
-        return regex.test(code);
-    }
-    if (patterns) {
-        for (let i = 0, n = patterns.length; i < n; i++) {
-            if (code.indexOf(patterns[i]) !== -1) {
-                return true;
-            }
-        }
-    }
-    return false;
-};
-const replace = (code, replacements) => {
-    if (replacements.length === 0) {
-        return code;
-    }
-    replacements.sort((a, b) => a.start - b.start);
-    let parts = [], pos = 0;
-    for (let i = 0, n = replacements.length; i < n; i++) {
-        let r = replacements[i];
-        if (r.start > pos) {
-            parts.push(code.substring(pos, r.start));
-        }
-        parts.push(r.newText);
-        pos = r.end;
-    }
-    if (pos < code.length) {
-        parts.push(code.substring(pos));
-    }
-    return parts.join('');
-};
 const replaceReverse = (code, replacements) => {
     if (replacements.length === 0) {
         return code;
@@ -42,4 +10,4 @@ const replaceReverse = (code, replacements) => {
     }
     return result;
 };
-export default { contains, replace, replaceReverse };
+export default { replaceReverse };

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/imports.d.ts

@@ -12,6 +12,7 @@ type ModifyOptions = {
 declare const _default: {
     find: (sourceFile: ts.SourceFile, packageName: string) => ImportInfo[];
     isFromPackage: (node: ts.Identifier, packageName: string, checker?: ts.TypeChecker) => boolean;
+    isSymbolFromPackage: (checker: ts.TypeChecker, node: ts.Node, packageName: string, symbolName?: string) => boolean;
     modify: (sourceCode: string, sourceFile: ts.SourceFile, packageName: string, options: ModifyOptions) => string;
     trace: (node: ts.Identifier, checker: ts.TypeChecker) => string | null;
 };

package/build/compiler/imports.js

@@ -29,6 +29,28 @@ const isFromPackage = (node, packageName, checker) => {
     let origin = trace(node, checker);
     return origin === null || origin.includes(packageName);
 };
+const isSymbolFromPackage = (checker, node, packageName, symbolName) => {
+    let symbol = checker.getSymbolAtLocation(node);
+    if (!symbol) {
+        return false;
+    }
+    if (symbol.flags & ts.SymbolFlags.Alias) {
+        symbol = checker.getAliasedSymbol(symbol);
+    }
+    if (symbolName && symbol.name !== symbolName) {
+        return false;
+    }
+    let declarations = symbol.getDeclarations();
+    if (!declarations || declarations.length === 0) {
+        return false;
+    }
+    for (let i = 0, n = declarations.length; i < n; i++) {
+        if (declarations[i].getSourceFile().fileName.includes(packageName)) {
+            return true;
+        }
+    }
+    return false;
+};
 const modify = (sourceCode, sourceFile, packageName, options) => {
     let { namespace } = options;
     if (!options.add && !options.namespace && !options.remove) {
@@ -92,4 +114,4 @@ const trace = (node, checker) => {
     }
     return declarations[0].getSourceFile().fileName;
 };
-export default { find, isFromPackage, modify, trace };
+export default { find, isFromPackage, isSymbolFromPackage, modify, trace };

package/build/compiler/index.d.ts

@@ -1,7 +1,7 @@
 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/build/compiler/index.js

@@ -1,6 +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';
 export { default as uid } from './uid.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("../index.js").Plugin[]) => (program: import("typescript").Program, shared: import("../index.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("../index.js").Plugin[];
     }) => ({ root }?: {
         root?: string;
     }) => {

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

@@ -1,7 +1,6 @@
-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';
+declare const _default: (plugins: Plugin[]) => (program: ts.Program, shared: SharedContext) => {
     transform: ts.TransformerFactory<ts.SourceFile>;
 };
 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,14 +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 QuickCheckPattern = {
+type Plugin = {
     patterns?: string[];
-    regex?: RegExp;
+    transform: (ctx: TransformContext) => TransformResult;
 };
+type PluginFactory = (options?: Record<string, unknown>) => Plugin;
 type Range = {
     end: number;
     start: number;
@@ -16,10 +17,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, 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.1",
   "scripts": {
     "build": "tsc && tsc-alias",
     "-": "-"