@esportsplus/typescript 0.21.0 → 0.23.0

package/build/cli/tsc.js

@@ -13,15 +13,25 @@ async function build(config, tsconfig, plugins) {
         }
         process.exit(1);
     }
-    await loadTransformers(plugins, root).then((transformers) => {
-        let printer = ts.createPrinter(), program = ts.createProgram(parsed.fileNames, parsed.options);
-        let beforeTransformers = transformers.before.map(f => f(program)), transformedFiles = new Map();
+    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;
             }
-            let result = ts.transform(sourceFile, beforeTransformers), transformed = result.transformed[0];
+            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));
             }
@@ -56,7 +66,7 @@ async function build(config, tsconfig, plugins) {
         return runTscAlias(process.argv.slice(2)).then((code) => process.exit(code));
     });
 }
-async function loadTransformers(plugins, root) {
+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;

package/build/compiler/imports.d.ts

@@ -0,0 +1,19 @@
+import { ts } from '../index.js';
+type ImportInfo = {
+    end: number;
+    specifiers: Map<string, string>;
+    start: number;
+};
+type ModifyOptions = {
+    add?: Iterable<string>;
+    namespace?: string;
+    remove?: Iterable<string>;
+};
+declare const _default: {
+    find: (sourceFile: ts.SourceFile, packageName: string) => ImportInfo[];
+    isFromPackage: (node: ts.Identifier, packageName: string, checker?: ts.TypeChecker) => boolean;
+    modify: (sourceCode: string, sourceFile: ts.SourceFile, packageName: string, options: ModifyOptions) => string;
+    trace: (node: ts.Identifier, checker: ts.TypeChecker) => string | null;
+};
+export default _default;
+export type { ImportInfo, ModifyOptions };

package/build/compiler/imports.js

@@ -0,0 +1,95 @@
+import { ts } from '../index.js';
+import code from './code.js';
+const find = (sourceFile, packageName) => {
+    let imports = [];
+    for (let i = 0, n = sourceFile.statements.length; i < n; i++) {
+        let stmt = sourceFile.statements[i];
+        if (!ts.isImportDeclaration(stmt)) {
+            continue;
+        }
+        let moduleSpecifier = stmt.moduleSpecifier;
+        if (!ts.isStringLiteral(moduleSpecifier) || moduleSpecifier.text !== packageName) {
+            continue;
+        }
+        let bindings = stmt.importClause?.namedBindings, specifiers = new Map();
+        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);
+            }
+        }
+        imports.push({ end: stmt.end, specifiers, start: stmt.getStart() });
+    }
+    return imports;
+};
+const isFromPackage = (node, packageName, checker) => {
+    if (!checker) {
+        return true;
+    }
+    let origin = trace(node, checker);
+    return origin === null || origin.includes(packageName);
+};
+const modify = (sourceCode, sourceFile, packageName, options) => {
+    let { namespace } = options;
+    if (!options.add && !options.namespace && !options.remove) {
+        return sourceCode;
+    }
+    let add = options.add ? new Set(options.add) : null, imports = find(sourceFile, packageName), remove = options.remove ? new Set(options.remove) : null;
+    if (imports.length === 0) {
+        let statements = [];
+        if (namespace) {
+            statements.push(`import * as ${namespace} from '${packageName}';`);
+        }
+        if (add && add.size > 0) {
+            statements.push(`import { ${[...add].sort().join(', ')} } from '${packageName}';`);
+        }
+        if (statements.length === 0) {
+            return sourceCode;
+        }
+        return statements.join('\n') + '\n' + sourceCode;
+    }
+    let specifiers = new Set();
+    for (let i = 0, n = imports.length; i < n; i++) {
+        for (let [name, alias] of imports[i].specifiers) {
+            if (!remove || (!remove.has(name) && !remove.has(alias))) {
+                specifiers.add(name === alias ? name : `${name} as ${alias}`);
+            }
+        }
+    }
+    if (add) {
+        for (let name of add) {
+            specifiers.add(name);
+        }
+    }
+    let statements = [];
+    if (namespace) {
+        statements.push(`import * as ${namespace} from '${packageName}';`);
+    }
+    if (specifiers.size > 0) {
+        statements.push(`import { ${[...specifiers].sort().join(', ')} } from '${packageName}';`);
+    }
+    let replacements = [];
+    for (let i = 0, n = imports.length; i < n; i++) {
+        replacements.push({
+            end: imports[i].end,
+            newText: i === 0 ? statements.join('\n') : '',
+            start: imports[i].start
+        });
+    }
+    return code.replaceReverse(sourceCode, replacements);
+};
+const trace = (node, checker) => {
+    let symbol = checker.getSymbolAtLocation(node);
+    if (!symbol) {
+        return null;
+    }
+    if (symbol.flags & ts.SymbolFlags.Alias) {
+        symbol = checker.getAliasedSymbol(symbol);
+    }
+    let declarations = symbol.getDeclarations();
+    if (!declarations || declarations.length === 0) {
+        return null;
+    }
+    return declarations[0].getSourceFile().fileName;
+};
+export default { find, isFromPackage, 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 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';
-export * from './constants.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 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 * from './constants.js';

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

@@ -1,6 +1,9 @@
 declare const _default: {
-    tsc: (transform: import("../index.js").TransformFn) => (program: import("typescript").Program) => import("typescript").TransformerFactory<import("typescript").SourceFile>;
-    vite: ({ name, onWatchChange, transform }: import("../index.js").VitePluginOptions) => ({ root }?: {
+    tsc: ({ analyze, transform }: import("../index.js").PluginDefinition) => (program: import("typescript").Program, context: import("../index.js").PluginContext) => {
+        analyze?: (sourceFile: import("typescript").SourceFile) => void;
+        transform: import("typescript").TransformerFactory<import("typescript").SourceFile>;
+    };
+    vite: ({ analyze, name, onWatchChange, transform }: import("../index.js").VitePluginOptions) => ({ root }?: {
         root?: string;
     }) => {
         configResolved(config: import("vite").ResolvedConfig): void;

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

@@ -1,4 +1,8 @@
-import type { TransformFn } from '../types.js';
+import type { PluginContext, PluginDefinition } from '../types.js';
 import { ts } from '../../index.js';
-declare const _default: (transform: TransformFn) => (program: ts.Program) => ts.TransformerFactory<ts.SourceFile>;
+type TscPluginFactory = (program: ts.Program, context: PluginContext) => {
+    analyze?: (sourceFile: ts.SourceFile) => void;
+    transform: ts.TransformerFactory<ts.SourceFile>;
+};
+declare const _default: ({ analyze, transform }: PluginDefinition) => TscPluginFactory;
 export default _default;

package/build/compiler/plugins/tsc.js

@@ -1,10 +1,15 @@
-export default (transform) => {
-    return (program) => {
-        return () => {
-            return (sourceFile) => {
-                let result = transform(sourceFile, program);
-                return result.changed ? result.sourceFile : sourceFile;
-            };
+export default ({ analyze, transform }) => {
+    return (program, context) => {
+        return {
+            analyze: analyze
+                ? (sourceFile) => analyze(sourceFile, program, context)
+                : undefined,
+            transform: () => {
+                return (sourceFile) => {
+                    let result = transform(sourceFile, program, context);
+                    return result.changed ? result.sourceFile : sourceFile;
+                };
+            }
         };
     };
 };

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

@@ -1,6 +1,6 @@
 import type { ResolvedConfig } from 'vite';
 import type { VitePluginOptions } from '../types.js';
-declare const _default: ({ name, onWatchChange, transform }: VitePluginOptions) => ({ root }?: {
+declare const _default: ({ analyze, name, onWatchChange, transform }: VitePluginOptions) => ({ root }?: {
     root?: string;
 }) => {
     configResolved(config: ResolvedConfig): void;

package/build/compiler/plugins/vite.js

@@ -1,7 +1,8 @@
 import { ts } from '../../index.js';
 import program from '../program.js';
 const FILE_REGEX = /\.[tj]sx?$/;
-export default ({ name, onWatchChange, transform }) => {
+let contexts = new Map();
+export default ({ analyze, name, onWatchChange, transform }) => {
     return ({ root } = {}) => {
         return {
             configResolved(config) {
@@ -14,7 +15,9 @@ export default ({ name, onWatchChange, transform }) => {
                     return null;
                 }
                 try {
-                    let result = transform(ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true), program.get(root || ''));
+                    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);
                     if (!result.changed) {
                         return null;
                     }
@@ -28,6 +31,7 @@ export default ({ name, onWatchChange, transform }) => {
             watchChange(id) {
                 if (FILE_REGEX.test(id)) {
                     onWatchChange?.();
+                    contexts.delete(root || '');
                     program.delete(root || '');
                 }
             }

package/build/compiler/types.d.ts

@@ -1,4 +1,10 @@
 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 QuickCheckPattern = {
     patterns?: string[];
     regex?: RegExp;
@@ -10,15 +16,16 @@ type Range = {
 type Replacement = Range & {
     newText: string;
 };
-type TransformFn = (sourceFile: ts.SourceFile, program: ts.Program) => TransformResult;
+type TransformFn = (sourceFile: ts.SourceFile, program: ts.Program, context?: PluginContext) => TransformResult;
 type TransformResult = {
     changed: boolean;
     code: string;
     sourceFile: ts.SourceFile;
 };
 type VitePluginOptions = {
+    analyze?: AnalyzeFn;
     name: string;
     onWatchChange?: () => void;
     transform: TransformFn;
 };
-export type { QuickCheckPattern, Range, Replacement, TransformFn, TransformResult, VitePluginOptions };
+export type { AnalyzeFn, PluginContext, PluginDefinition, QuickCheckPattern, Range, Replacement, TransformFn, TransformResult, VitePluginOptions };

package/build/compiler/uid.d.ts

@@ -1,2 +1,2 @@
-declare const _default: (prefix: string, reset?: boolean) => string;
+declare const _default: (prefix: string) => string;
 export default _default;

package/build/compiler/uid.js

@@ -1,6 +1,13 @@
-import { uuid } from '@esportsplus/utilities';
-import { UUID_REGEX } from './constants.js';
-let cache = uuid().replace(UUID_REGEX, ''), i = 0;
-export default (prefix, reset = false) => {
-    return prefix + '_' + (reset ? uuid().replace(UUID_REGEX, '') : cache) + (i++).toString(36);
+const INVALID_CHARS = /[^A-Za-z0-9]/g;
+let counter = 0;
+function hash(str) {
+    let h = 0x811c9dc5;
+    for (let i = 0, n = str.length; i < n; i++) {
+        h ^= str.charCodeAt(i);
+        h = Math.imul(h, 0x01000193);
+    }
+    return ((h >>> 0).toString(36) + Math.abs(h).toString(36)).replace(INVALID_CHARS, '');
+}
+export default (prefix) => {
+    return prefix + '_' + hash(prefix) + (counter++).toString(36);
 };

package/package.json

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

package/src/cli/tsc.ts

@@ -11,7 +11,14 @@ type PluginConfig = {
     transform: string;
 };
 
-type TransformerCreator = (program: ts.Program) => ts.TransformerFactory<ts.SourceFile>;
+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;
@@ -35,13 +42,32 @@ async function build(config: object, tsconfig: string, plugins: PluginConfig[]):
         process.exit(1);
     }
 
-    await loadTransformers(plugins, root).then((transformers) => {
-        let printer = ts.createPrinter(),
-            program = ts.createProgram(parsed.fileNames, parsed.options);
-
-        let beforeTransformers = transformers.before.map(f => f(program)),
+    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>();
 
+        // Create plugin instances with shared context
+        let instances = factories.before.map(f => f(program, context));
+
+        // 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);
+
+            if (!sourceFile) {
+                continue;
+            }
+
+            for (let j = 0, m = instances.length; j < m; j++) {
+                instances[j].analyze?.(sourceFile);
+            }
+        }
+
+        // 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);
@@ -50,7 +76,7 @@ async function build(config: object, tsconfig: string, plugins: PluginConfig[]):
                 continue;
             }
 
-            let result = ts.transform(sourceFile, beforeTransformers),
+            let result = ts.transform(sourceFile, transformers),
                 transformed = result.transformed[0];
 
             if (transformed !== sourceFile) {
@@ -109,12 +135,12 @@ async function build(config: object, tsconfig: string, plugins: PluginConfig[]):
     });
 }
 
-async function loadTransformers(plugins: PluginConfig[], root: string): Promise<{
-    after: TransformerCreator[];
-    before: TransformerCreator[];
+async function loadPlugins(plugins: PluginConfig[], root: string): Promise<{
+    after: PluginFactory[];
+    before: PluginFactory[];
 }> {
-    let after: TransformerCreator[] = [],
-        before: TransformerCreator[] = [],
+    let after: PluginFactory[] = [],
+        before: PluginFactory[] = [],
         promises: Promise<void>[] = [];
 
     for (let i = 0, n = plugins.length; i < n; i++) {

package/src/compiler/imports.ts

@@ -0,0 +1,170 @@
+import type { Replacement } from './types.js';
+import { ts } from '~/index.js';
+import code from './code.js';
+
+
+type ImportInfo = {
+    end: number;
+    specifiers: Map<string, string>;
+    start: number;
+};
+
+type ModifyOptions = {
+    add?: Iterable<string>;
+    namespace?: string;
+    remove?: Iterable<string>;
+};
+
+
+// Find all named imports from a specific package
+const find = (sourceFile: ts.SourceFile, packageName: string): ImportInfo[] => {
+    let imports: ImportInfo[] = [];
+
+    for (let i = 0, n = sourceFile.statements.length; i < n; i++) {
+        let stmt = sourceFile.statements[i];
+
+        if (!ts.isImportDeclaration(stmt)) {
+            continue;
+        }
+
+        let moduleSpecifier = stmt.moduleSpecifier;
+
+        if (!ts.isStringLiteral(moduleSpecifier) || moduleSpecifier.text !== packageName) {
+            continue;
+        }
+
+        let bindings = stmt.importClause?.namedBindings,
+            specifiers = new Map<string, 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);
+            }
+        }
+
+        imports.push({ end: stmt.end, specifiers, start: stmt.getStart() });
+    }
+
+    return imports;
+};
+
+// Check if identifier traces back to a specific package
+const isFromPackage = (node: ts.Identifier, packageName: string, checker?: ts.TypeChecker): boolean => {
+    if (!checker) {
+        return true;
+    }
+
+    let origin = trace(node, checker);
+
+    // If can't resolve symbol (e.g., sourceFile not in program), assume valid
+    // False positives cause compile errors; false negatives silently skip transforms
+    return origin === null || origin.includes(packageName);
+};
+
+
+// Modify imports: remove specified, add needed, delete if empty
+const modify = (
+    sourceCode: string,
+    sourceFile: ts.SourceFile,
+    packageName: string,
+    options: ModifyOptions
+): string => {
+    let { namespace } = options;
+
+    // Fast path: nothing to change
+    if (!options.add && !options.namespace && !options.remove) {
+        return sourceCode;
+    }
+
+    let add = options.add ? new Set(options.add) : null,
+        imports = find(sourceFile, packageName),
+        remove = options.remove ? new Set(options.remove) : null;
+
+    if (imports.length === 0) {
+        let statements: string[] = [];
+
+        if (namespace) {
+            statements.push(`import * as ${namespace} from '${packageName}';`);
+        }
+
+        if (add && add.size > 0) {
+            statements.push(`import { ${[...add].sort().join(', ')} } from '${packageName}';`);
+        }
+
+        if (statements.length === 0) {
+            return sourceCode;
+        }
+
+        return statements.join('\n') + '\n' + sourceCode;
+    }
+
+    // Collect all non-removed specifiers from existing imports
+    let specifiers = new Set<string>();
+
+    for (let i = 0, n = imports.length; i < n; i++) {
+        for (let [name, alias] of imports[i].specifiers) {
+            if (!remove || (!remove.has(name) && !remove.has(alias))) {
+                specifiers.add(name === alias ? name : `${name} as ${alias}`);
+            }
+        }
+    }
+
+    if (add) {
+        for (let name of add) {
+            specifiers.add(name);
+        }
+    }
+
+    // Build replacement text - namespace import first, then named imports
+    let statements: string[] = [];
+
+    if (namespace) {
+        statements.push(`import * as ${namespace} from '${packageName}';`);
+    }
+
+    if (specifiers.size > 0) {
+        statements.push(`import { ${[...specifiers].sort().join(', ')} } from '${packageName}';`);
+    }
+
+    // Build replacements - replace first import, remove others
+    let replacements: Replacement[] = [];
+
+    for (let i = 0, n = imports.length; i < n; i++) {
+        replacements.push({
+            end: imports[i].end,
+            newText: i === 0 ? statements.join('\n') : '',
+            start: imports[i].start
+        });
+    }
+
+    return code.replaceReverse(sourceCode, replacements);
+};
+
+// Trace symbol through re-exports to find original declaration source file
+const trace = (node: ts.Identifier, checker: ts.TypeChecker): string | null => {
+    let symbol = checker.getSymbolAtLocation(node);
+
+    if (!symbol) {
+        return null;
+    }
+
+    if (symbol.flags & ts.SymbolFlags.Alias) {
+        symbol = checker.getAliasedSymbol(symbol);
+    }
+
+    let declarations = symbol.getDeclarations();
+
+    if (!declarations || declarations.length === 0) {
+        return null;
+    }
+
+    return declarations[0].getSourceFile().fileName;
+};
+
+
+export default { find, isFromPackage, modify, trace };
+export type { ImportInfo, ModifyOptions };

package/src/compiler/index.ts

@@ -1,7 +1,7 @@
 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 * from './constants';

package/src/compiler/plugins/tsc.ts

@@ -1,15 +1,26 @@
-import type { TransformFn } from '../types';
+import type { PluginContext, PluginDefinition } from '../types';
 import { ts } from '../..';
 
 
-export default (transform: TransformFn) => {
-    return (program: ts.Program): ts.TransformerFactory<ts.SourceFile> => {
-        return () => {
-            return (sourceFile) => {
-                let result = transform(sourceFile, program);
+type TscPluginFactory = (program: ts.Program, context: PluginContext) => {
+    analyze?: (sourceFile: ts.SourceFile) => void;
+    transform: ts.TransformerFactory<ts.SourceFile>;
+};
 
-                return result.changed ? result.sourceFile : sourceFile;
-            };
+
+export default ({ analyze, transform }: PluginDefinition): TscPluginFactory => {
+    return (program: ts.Program, context: PluginContext) => {
+        return {
+            analyze: analyze
+                ? (sourceFile: ts.SourceFile) => analyze(sourceFile, program, context)
+                : undefined,
+            transform: () => {
+                return (sourceFile) => {
+                    let result = transform(sourceFile, program, context);
+
+                    return result.changed ? result.sourceFile : sourceFile;
+                };
+            }
         };
     };
 }

package/src/compiler/plugins/vite.ts

@@ -1,5 +1,5 @@
 import type { ResolvedConfig } from 'vite';
-import type { VitePluginOptions } from '../types';
+import type { PluginContext, VitePluginOptions } from '../types';
 import { ts } from '../..';
 import program from '../program';
 
@@ -7,7 +7,10 @@ import program from '../program';
 const FILE_REGEX = /\.[tj]sx?$/;
 
 
-export default ({ name, onWatchChange, transform }: VitePluginOptions) => {
+let contexts = new Map<string, PluginContext>();
+
+
+export default ({ analyze, name, onWatchChange, transform }: VitePluginOptions) => {
     return ({ root }: { root?: string } = {}) => {
         return {
             configResolved(config: ResolvedConfig) {
@@ -21,10 +24,13 @@ export default ({ name, onWatchChange, transform }: VitePluginOptions) => {
                 }
 
                 try {
-                    let result = transform(
-                            ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true),
-                            program.get(root || '')
-                        );
+                    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);
 
                     if (!result.changed) {
                         return null;
@@ -40,6 +46,8 @@ export default ({ 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,6 +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 QuickCheckPattern = {
     patterns?: string[];
     regex?: RegExp;
@@ -15,7 +24,7 @@ type Replacement = Range & {
     newText: string;
 };
 
-type TransformFn = (sourceFile: ts.SourceFile, program: ts.Program) => TransformResult;
+type TransformFn = (sourceFile: ts.SourceFile, program: ts.Program, context?: PluginContext) => TransformResult;
 
 type TransformResult = {
     changed: boolean;
@@ -24,10 +33,11 @@ type TransformResult = {
 };
 
 type VitePluginOptions = {
+    analyze?: AnalyzeFn;
     name: string;
     onWatchChange?: () => void;
     transform: TransformFn;
 };
 
 
-export type { QuickCheckPattern, Range, Replacement, TransformFn, TransformResult, VitePluginOptions };
+export type { AnalyzeFn, PluginContext, PluginDefinition, QuickCheckPattern, Range, Replacement, TransformFn, TransformResult, VitePluginOptions };

package/src/compiler/uid.ts

@@ -1,11 +1,21 @@
-import { uuid } from '@esportsplus/utilities';
-import { UUID_REGEX } from './constants';
+const INVALID_CHARS = /[^A-Za-z0-9]/g;
 
 
-let cache = uuid().replace(UUID_REGEX, ''),
-    i = 0;
+let counter = 0;
 
 
-export default (prefix: string, reset = false): string => {
-    return prefix + '_' + (reset ? uuid().replace(UUID_REGEX, '') : cache) + (i++).toString(36);
+function hash(str: string): string {
+    let h = 0x811c9dc5;
+
+    for (let i = 0, n = str.length; i < n; i++) {
+        h ^= str.charCodeAt(i);
+        h = Math.imul(h, 0x01000193);
+    }
+
+    return ((h >>> 0).toString(36) + Math.abs(h).toString(36)).replace(INVALID_CHARS, '');
+}
+
+
+export default (prefix: string): string => {
+    return prefix + '_' + hash(prefix) + (counter++).toString(36);
 };

package/build/compiler/constants.d.ts

@@ -1,2 +0,0 @@
-declare const UUID_REGEX: RegExp;
-export { UUID_REGEX };

package/build/compiler/constants.js

@@ -1,2 +0,0 @@
-const UUID_REGEX = /[^A-Za-z0-9_$]/g;
-export { UUID_REGEX };

package/src/compiler/constants.ts

@@ -1,4 +0,0 @@
-const UUID_REGEX = /[^A-Za-z0-9_$]/g;
-
-
-export { UUID_REGEX };