@wyw-in-js/transform 2.0.0-alpha.0 → 2.0.0

package/types/utils/nativeResolver.d.ts

@@ -0,0 +1,13 @@
+import type { EvalResolverKind, OxcOptions, StrictOptions } from '@wyw-in-js/shared';
+export type NativeResolverParams = {
+    conditionNames?: string[];
+    extensions: StrictOptions['extensions'];
+    importer: string;
+    kind: EvalResolverKind;
+    oxcOptions?: OxcOptions;
+    specifier: string;
+};
+export declare const expandNativeResolverConditions: (kind: EvalResolverKind, conditionNames?: readonly string[]) => string[];
+export declare const clearNativeResolverCacheForTest: () => void;
+export declare const getNativeResolverCacheSizeForTest: () => number;
+export declare const resolveWithNativeResolver: ({ conditionNames, extensions, importer, kind, oxcOptions, specifier, }: NativeResolverParams) => string;

package/types/utils/nativeResolver.js

@@ -0,0 +1,91 @@
+import fs from 'fs';
+import path from 'path';
+import { ResolverFactory } from 'oxc-resolver';
+import { parseRequest } from './parseRequest';
+const CJS_DEFAULT_CONDITIONS = ['require', 'node', 'default'];
+const ESM_DEFAULT_CONDITIONS = ['node', 'import', 'default'];
+const FALLBACK_EXTENSIONS = ['.json', '.node'];
+const MAX_RESOLVER_CACHE_SIZE = 64;
+const resolverCache = new Map();
+const unique = (items) => Array.from(new Set(items));
+export const expandNativeResolverConditions = (kind, conditionNames) => {
+    const defaults = kind === 'require' ? CJS_DEFAULT_CONDITIONS : ESM_DEFAULT_CONDITIONS;
+    const names = conditionNames?.length ? conditionNames : ['...'];
+    const result = [];
+    names.forEach((name) => {
+        if (name === '...') {
+            defaults.forEach((condition) => result.push(condition));
+            return;
+        }
+        result.push(name);
+    });
+    return unique(result);
+};
+const createResolverOptions = ({ conditionNames, extensions, kind, oxcOptions, }) => {
+    const configuredResolver = (oxcOptions?.resolver ?? {});
+    const hasConfiguredTsconfig = Object.prototype.hasOwnProperty.call(configuredResolver, 'tsconfig');
+    const configuredConditionNames = Array.isArray(configuredResolver.conditionNames)
+        ? configuredResolver.conditionNames
+        : undefined;
+    const configuredExtensions = Array.isArray(configuredResolver.extensions)
+        ? configuredResolver.extensions
+        : [];
+    return {
+        ...configuredResolver,
+        ...(hasConfiguredTsconfig ? {} : { tsconfig: 'auto' }),
+        conditionNames: expandNativeResolverConditions(kind, conditionNames ?? configuredConditionNames),
+        extensions: unique([
+            ...configuredExtensions,
+            ...extensions,
+            ...FALLBACK_EXTENSIONS,
+        ]),
+    };
+};
+const getResolver = (options) => {
+    const key = JSON.stringify(options);
+    const cached = resolverCache.get(key);
+    if (cached) {
+        resolverCache.delete(key);
+        resolverCache.set(key, cached);
+        return cached;
+    }
+    const resolver = new ResolverFactory(options);
+    if (resolverCache.size >= MAX_RESOLVER_CACHE_SIZE) {
+        const oldestKey = resolverCache.keys().next().value;
+        if (oldestKey !== undefined) {
+            resolverCache.delete(oldestKey);
+        }
+    }
+    resolverCache.set(key, resolver);
+    return resolver;
+};
+export const clearNativeResolverCacheForTest = () => {
+    resolverCache.clear();
+};
+export const getNativeResolverCacheSizeForTest = () => resolverCache.size;
+const preferJsOverCjsForExtensionlessFileSpecifier = (specifier, resolved) => {
+    if ((specifier.startsWith('.') || path.isAbsolute(specifier)) &&
+        path.extname(specifier) === '' &&
+        resolved.endsWith('.cjs') &&
+        fs.existsSync(`${resolved.slice(0, -4)}.js`)) {
+        return `${resolved.slice(0, -4)}.js`;
+    }
+    return resolved;
+};
+export const resolveWithNativeResolver = ({ conditionNames, extensions, importer, kind, oxcOptions, specifier, }) => {
+    const { filename, query, hash } = parseRequest(specifier);
+    const options = createResolverOptions({
+        conditionNames,
+        extensions,
+        kind,
+        oxcOptions,
+    });
+    const resolver = getResolver(options);
+    const result = resolver.resolveFileSync(importer, filename);
+    if (!result.path) {
+        throw new Error(result.error ?? `Cannot resolve module ${specifier}`);
+    }
+    const resolved = preferJsOverCjsForExtensionlessFileSpecifier(filename, result.path);
+    const suffix = `${query ? `?${query}` : ''}${hash ? `#${hash}` : ''}`;
+    return `${resolved}${suffix}`;
+};

package/types/utils/oxc/ast.d.ts

@@ -0,0 +1,4 @@
+import type { Node } from 'oxc-parser';
+export declare const isOxcNode: (value: unknown) => value is Node;
+export declare const getOxcNodeChildren: (node: Node) => Node[];
+export declare const walkOxc: (node: Node, enter: (node: Node, parent: Node | null) => void, parent?: Node | null) => void;

package/types/utils/oxc/ast.js

@@ -0,0 +1,61 @@
+export const isOxcNode = (value) => !!value &&
+    typeof value === 'object' &&
+    'type' in value &&
+    typeof value.type === 'string';
+// Cache visitor-key lists per node.type. oxc-parser AST nodes have a stable
+// shape per `type` — optional children are present as null/undefined, not
+// omitted — so Object.keys() returns the same key set for every instance of
+// the same kind. First instance pays the discovery cost; the rest do an
+// indexed lookup. getOxcNodeChildren is invoked tens of millions of times
+// on a cold build of a large monorepo, so this matters a lot.
+//
+// An instance-level WeakMap cache of the resulting Node[] was tried and
+// regressed wall time ~20% (WeakMap.get/set per call beat the recompute
+// savings for small children arrays + pinned arrays into older generations
+// and increased GC pressure). Per-type key cache only.
+const META_KEYS = new Set([
+    'comments',
+    'end',
+    'errors',
+    'parent',
+    'range',
+    'span',
+    'start',
+    'type',
+]);
+const VISITOR_KEYS_BY_TYPE = new Map();
+const visitorKeysFor = (node) => {
+    let keys = VISITOR_KEYS_BY_TYPE.get(node.type);
+    if (keys === undefined) {
+        keys = Object.keys(node).filter((key) => !META_KEYS.has(key));
+        VISITOR_KEYS_BY_TYPE.set(node.type, keys);
+    }
+    return keys;
+};
+export const getOxcNodeChildren = (node) => {
+    const result = [];
+    const record = node;
+    const keys = visitorKeysFor(record);
+    for (let i = 0; i < keys.length; i += 1) {
+        const value = record[keys[i]];
+        if (isOxcNode(value)) {
+            result.push(value);
+        }
+        else if (Array.isArray(value)) {
+            for (let j = 0; j < value.length; j += 1) {
+                const item = value[j];
+                if (isOxcNode(item)) {
+                    result.push(item);
+                }
+            }
+        }
+    }
+    return result;
+};
+export const walkOxc = (node, enter, parent = null) => {
+    enter(node, parent);
+    const children = getOxcNodeChildren(node);
+    for (let i = 0; i < children.length; i += 1) {
+        walkOxc(children[i], enter, node);
+    }
+};

package/types/utils/oxc/parse.d.ts

@@ -0,0 +1,3 @@
+import type { Program } from 'oxc-parser';
+export type OxcSourceType = 'module' | 'unambiguous';
+export declare const parseOxcProgram: (code: string, filename: string, sourceType?: OxcSourceType) => Program;

package/types/utils/oxc/parse.js

@@ -0,0 +1,2 @@
+import { parseOxcProgramCached } from '../parseOxc';
+export const parseOxcProgram = (code, filename, sourceType = 'unambiguous') => parseOxcProgramCached(filename, code, sourceType);

package/types/utils/oxc/replacements.d.ts

@@ -0,0 +1,12 @@
+export type OxcValueReplacement = {
+    end: number;
+    start: number;
+    value: string;
+};
+export type OxcTextReplacement = {
+    end: number;
+    start: number;
+    text: string;
+};
+export type OxcReplacement = OxcTextReplacement | OxcValueReplacement;
+export declare const applyOxcReplacements: (code: string, replacements: OxcReplacement[]) => string;

package/types/utils/oxc/replacements.js

@@ -0,0 +1,18 @@
+const getReplacementValue = (replacement) => {
+    if ('value' in replacement) {
+        return replacement.value;
+    }
+    return replacement.text;
+};
+export const applyOxcReplacements = (code, replacements) => {
+    let result = code;
+    [...replacements]
+        .sort((a, b) => b.start - a.start)
+        .forEach((replacement) => {
+        result =
+            result.slice(0, replacement.start) +
+                getReplacementValue(replacement) +
+                result.slice(replacement.end);
+    });
+    return result;
+};

package/types/utils/oxc/sourceLocations.d.ts

@@ -0,0 +1,5 @@
+import type { SourceLocation } from '@wyw-in-js/shared';
+export type OxcLocationLookup = (offset: number) => SourceLocation['start'];
+export declare const createOxcLocationLookup: (code: string) => OxcLocationLookup;
+export declare const createOxcSourceLocation: (start: number, end: number, loc: OxcLocationLookup, filename?: string | null, identifierName?: string | null) => SourceLocation;
+export declare const buildOxcCodeFrameError: (code: string, location: SourceLocation, message: string) => Error;

package/types/utils/oxc/sourceLocations.js

@@ -0,0 +1,63 @@
+export const createOxcLocationLookup = (code) => {
+    const lineStarts = [0];
+    for (let idx = 0; idx < code.length; idx += 1) {
+        if (code[idx] === '\n') {
+            lineStarts.push(idx + 1);
+        }
+    }
+    return (offset) => {
+        let low = 0;
+        let high = lineStarts.length - 1;
+        while (low <= high) {
+            const mid = Math.floor((low + high) / 2);
+            const next = lineStarts[mid + 1] ?? Infinity;
+            if (lineStarts[mid] <= offset && offset < next) {
+                return {
+                    column: offset - lineStarts[mid],
+                    line: mid + 1,
+                };
+            }
+            if (offset < lineStarts[mid]) {
+                high = mid - 1;
+            }
+            else {
+                low = mid + 1;
+            }
+        }
+        const lastLine = lineStarts.length - 1;
+        return {
+            column: Math.max(0, offset - lineStarts[lastLine]),
+            line: lastLine + 1,
+        };
+    };
+};
+export const createOxcSourceLocation = (start, end, loc, filename, identifierName) => ({
+    end: loc(end),
+    filename: filename ?? undefined,
+    identifierName,
+    start: loc(start),
+});
+export const buildOxcCodeFrameError = (code, location, message) => {
+    const lines = code.split('\n');
+    const startLine = location.start.line;
+    const endLine = location.end.line;
+    const frameStart = Math.max(1, startLine - 2);
+    const frameEnd = Math.min(lines.length, endLine + 2);
+    const lineNoWidth = String(frameEnd).length;
+    const frame = [];
+    for (let lineNo = frameStart; lineNo <= frameEnd; lineNo += 1) {
+        const marker = lineNo === startLine ? '>' : ' ';
+        const line = lines[lineNo - 1] ?? '';
+        frame.push(line.length > 0
+            ? `${marker} ${String(lineNo).padStart(lineNoWidth)} | ${line}`
+            : `${marker} ${String(lineNo).padStart(lineNoWidth)} |`);
+        if (lineNo === startLine) {
+            const pointerLength = startLine === endLine
+                ? Math.max(1, location.end.column - location.start.column)
+                : 1;
+            frame.push(`  ${' '.repeat(lineNoWidth)} | ${' '.repeat(location.start.column)}${'^'.repeat(pointerLength)}`);
+        }
+    }
+    const prefix = location.filename ? `${location.filename}: ` : '';
+    return new Error(`${prefix}${message}\n${frame.join('\n')}`);
+};

package/types/utils/oxcPreevalStage/evalStrategy.d.ts

@@ -0,0 +1,3 @@
+import type { OxcPreevalOptions } from './types';
+export declare const getEvalStrategy: (options: OxcPreevalOptions) => import("@wyw-in-js/shared").EvalStrategy;
+export declare const usesStaticEvaluation: (options: OxcPreevalOptions) => boolean;

package/types/utils/oxcPreevalStage/evalStrategy.js

@@ -0,0 +1,2 @@
+export const getEvalStrategy = (options) => options.eval?.strategy ?? 'hybrid';
+export const usesStaticEvaluation = (options) => getEvalStrategy(options) !== 'execute';

package/types/utils/oxcPreevalStage/prepareCode.d.ts

@@ -0,0 +1,3 @@
+import type { EventEmitter } from '../EventEmitter';
+import type { OxcPreevalOptions } from './types';
+export declare const prepareOxcPreevalCode: (code: string, filename: string, options: OxcPreevalOptions, eventEmitter: EventEmitter) => string;

package/types/utils/oxcPreevalStage/prepareCode.js

@@ -0,0 +1,20 @@
+import { isFeatureEnabled } from '@wyw-in-js/shared';
+import { removeDangerousCodeWithOxc, replaceImportMetaEnvWithOxc, rewriteDynamicImportsAndAddRequireFallbackWithOxc, } from '../oxcPreevalTransforms';
+const DYNAMIC_IMPORT_RE = /\bimport(?:\s|\/\*[\s\S]*?\*\/)*\(/;
+const REQUIRE_CALL_RE = /\brequire(?:\s|\/\*[\s\S]*?\*\/)*\(/;
+export const prepareOxcPreevalCode = (code, filename, options, eventEmitter) => {
+    let nextCode = eventEmitter.perf('transform:preeval:importMetaEnv', () => replaceImportMetaEnvWithOxc(code, filename));
+    if (isFeatureEnabled(options.features, 'dangerousCodeRemover', filename)) {
+        nextCode = eventEmitter.perf('transform:preeval:removeDangerousCode', () => removeDangerousCodeWithOxc(nextCode, filename, options.codeRemover));
+    }
+    const shouldRewriteDynamicImports = DYNAMIC_IMPORT_RE.test(nextCode);
+    const shouldAddRequireFallback = REQUIRE_CALL_RE.test(nextCode);
+    if (shouldRewriteDynamicImports || shouldAddRequireFallback) {
+        nextCode = rewriteDynamicImportsAndAddRequireFallbackWithOxc(nextCode, filename, {
+            addRequireFallback: shouldAddRequireFallback,
+            eventEmitter,
+            rewriteDynamicImports: shouldRewriteDynamicImports,
+        });
+    }
+    return nextCode;
+};

package/types/utils/oxcPreevalStage/prevalExport.d.ts

@@ -0,0 +1 @@
+export declare const appendOxcWywPreval: (code: string, filename: string, dependencyNames: string[]) => string;

package/types/utils/oxcPreevalStage/prevalExport.js

@@ -0,0 +1,22 @@
+import { parseSync } from 'oxc-parser';
+const parseSourceType = (code, filename) => {
+    const parsed = parseSync(filename, code, {
+        astType: filename.endsWith('.ts') || filename.endsWith('.tsx') ? 'ts' : 'js',
+        range: true,
+        sourceType: 'unambiguous',
+    });
+    const fatalError = parsed.errors.find((error) => error.severity === 'Error');
+    if (fatalError) {
+        throw new Error(fatalError.message);
+    }
+    return parsed.program.sourceType === 'script' ? 'script' : 'module';
+};
+export const appendOxcWywPreval = (code, filename, dependencyNames) => {
+    const uniqueNames = [...new Set(dependencyNames)];
+    const properties = uniqueNames.map((name) => `${name}: ${name}`).join(', ');
+    const object = uniqueNames.length > 0 ? `{ ${properties} }` : '{}';
+    if (parseSourceType(code, filename) === 'script') {
+        return `${code}\nexports.__wywPreval = ${object};`;
+    }
+    return `${code}\nexport const __wywPreval = ${object};`;
+};

package/types/utils/oxcPreevalStage/processors.d.ts

@@ -0,0 +1,10 @@
+import type { IFileContext } from '@wyw-in-js/processor-utils';
+import type { EventEmitter } from '../EventEmitter';
+import type { ApplyOxcProcessorsResult } from '../applyOxcProcessors/types';
+import type { OxcPreevalOptions } from './types';
+type PreevalProcessorCollection = {
+    dependencyNames: string[];
+    processed: ApplyOxcProcessorsResult;
+};
+export declare const collectPreevalProcessors: (code: string, fileContext: IFileContext, options: OxcPreevalOptions, eventEmitter: EventEmitter) => PreevalProcessorCollection;
+export {};

package/types/utils/oxcPreevalStage/processors.js

@@ -0,0 +1,16 @@
+import { applyOxcProcessors } from '../applyOxcProcessors';
+export const collectPreevalProcessors = (code, fileContext, options, eventEmitter) => {
+    const dependencyNames = [];
+    const processed = eventEmitter.perf('transform:preeval:processTemplate', () => applyOxcProcessors(code, fileContext, options, (processor) => {
+        processor.dependencies.forEach((dependency) => {
+            if (dependency.ex.type === 'Identifier') {
+                dependencyNames.push(dependency.ex.name);
+            }
+        });
+        processor.doEvaltimeReplacement();
+    }));
+    return {
+        dependencyNames,
+        processed,
+    };
+};

package/types/utils/oxcPreevalStage/staticOverlay.d.ts

@@ -0,0 +1,3 @@
+import type { ApplyOxcProcessorsResult } from '../applyOxcProcessors/types';
+import type { OxcPreevalOptions, StaticPreevalOverlay } from './types';
+export declare const createStaticPreevalOverlay: (processed: ApplyOxcProcessorsResult, dependencyNames: string[], options: OxcPreevalOptions) => StaticPreevalOverlay;

package/types/utils/oxcPreevalStage/staticOverlay.js

@@ -0,0 +1,23 @@
+import { usesStaticEvaluation } from './evalStrategy';
+export const createStaticPreevalOverlay = (processed, dependencyNames, options) => {
+    const staticValuesEnabled = usesStaticEvaluation(options);
+    const staticValueNames = staticValuesEnabled
+        ? new Set(processed.staticValues.map((item) => item.name))
+        : null;
+    const evalDependencyNames = staticValuesEnabled
+        ? dependencyNames.filter((name) => !staticValueNames.has(name))
+        : dependencyNames;
+    const staticValueCache = new Map();
+    if (staticValuesEnabled) {
+        processed.staticValues.forEach(({ name, value }) => {
+            staticValueCache.set(name, value);
+        });
+    }
+    return {
+        evalDependencyNames,
+        staticValueCache,
+        staticValueCandidates: staticValuesEnabled
+            ? processed.staticValueCandidates
+            : [],
+    };
+};

package/types/utils/oxcPreevalStage/types.d.ts

@@ -0,0 +1,22 @@
+import type { StrictOptions } from '@wyw-in-js/shared';
+import type { EventEmitter } from '../EventEmitter';
+import type { WYWTransformMetadata } from '../TransformMetadata';
+import type { OxcStaticValueCandidate } from '../collectOxcTemplateDependencies';
+export type OxcPreevalOptions = Pick<StrictOptions, 'classNameSlug' | 'codeRemover' | 'displayName' | 'eval' | 'extensions' | 'features' | 'staticBindings' | 'tagResolver'> & {
+    eventEmitter?: EventEmitter;
+};
+export type OxcPreevalResult = {
+    baseCode: string;
+    code: string;
+    dependencyNames: string[];
+    metadata: WYWTransformMetadata | null;
+    processorClassNames: Record<string, string>;
+    staticDependencies: string[];
+    staticValueCache: Map<string, unknown>;
+    staticValueCandidates: OxcStaticValueCandidate[];
+};
+export type StaticPreevalOverlay = {
+    evalDependencyNames: string[];
+    staticValueCache: Map<string, unknown>;
+    staticValueCandidates: OxcStaticValueCandidate[];
+};

package/types/utils/oxcPreevalStage/types.js

@@ -0,0 +1 @@
+export {};

package/types/utils/oxcPreevalStage.d.ts

@@ -1,20 +1,4 @@
 import type { IFileContext } from '@wyw-in-js/processor-utils';
-import type { StrictOptions } from '@wyw-in-js/shared';
-import { EventEmitter } from './EventEmitter';
-import type { WYWTransformMetadata } from './TransformMetadata';
-import type { OxcStaticValueCandidate } from './collectOxcTemplateDependencies';
-type OxcPreevalOptions = Pick<StrictOptions, 'classNameSlug' | 'codeRemover' | 'displayName' | 'evaluate' | 'extensions' | 'features' | 'tagResolver'> & {
-    eventEmitter?: EventEmitter;
-};
-type OxcPreevalResult = {
-    baseCode: string;
-    code: string;
-    dependencyNames: string[];
-    metadata: WYWTransformMetadata | null;
-    staticDependencies: string[];
-    staticValueCache: Map<string, unknown>;
-    staticValueCandidates: OxcStaticValueCandidate[];
-};
-export declare const appendOxcWywPreval: (code: string, filename: string, dependencyNames: string[]) => string;
+import type { OxcPreevalOptions, OxcPreevalResult } from './oxcPreevalStage/types';
+export { appendOxcWywPreval } from './oxcPreevalStage/prevalExport';
 export declare const runOxcPreevalStage: (code: string, fileContext: IFileContext, options: OxcPreevalOptions) => OxcPreevalResult;
-export {};

package/types/utils/oxcPreevalStage.js

@@ -1,102 +1,40 @@
-import { parseSync } from 'oxc-parser';
-import { isFeatureEnabled } from '@wyw-in-js/shared';
 import { EventEmitter } from './EventEmitter';
-import { applyOxcProcessors } from './applyOxcProcessors';
-import { removeDangerousCodeWithOxc, replaceImportMetaEnvWithOxc, rewriteDynamicImportsAndAddRequireFallbackWithOxc, } from './oxcPreevalTransforms';
-const DYNAMIC_IMPORT_RE = /\bimport(?:\s|\/\*[\s\S]*?\*\/)*\(/;
-const REQUIRE_CALL_RE = /\brequire(?:\s|\/\*[\s\S]*?\*\/)*\(/;
-const isEnvDisabled = (value) => value === '0' || value === 'false' || value === 'no' || value === 'off';
-const isStaticImportValuesEnabled = (features, filename) => {
-    const envValue = process.env.WYW_STATIC_IMPORT_VALUES?.trim().toLowerCase();
-    if (envValue) {
-        return !isEnvDisabled(envValue);
-    }
-    return isFeatureEnabled(features, 'staticImportValues', filename);
-};
-const parseSourceType = (code, filename) => {
-    const parsed = parseSync(filename, code, {
-        astType: filename.endsWith('.ts') || filename.endsWith('.tsx') ? 'ts' : 'js',
-        range: true,
-        sourceType: 'unambiguous',
-    });
-    const fatalError = parsed.errors.find((error) => error.severity === 'Error');
-    if (fatalError) {
-        throw new Error(fatalError.message);
-    }
-    return parsed.program.sourceType === 'script' ? 'script' : 'module';
-};
-export const appendOxcWywPreval = (code, filename, dependencyNames) => {
-    const uniqueNames = [...new Set(dependencyNames)];
-    const properties = uniqueNames.map((name) => `${name}: ${name}`).join(', ');
-    const object = uniqueNames.length > 0 ? `{ ${properties} }` : '{}';
-    if (parseSourceType(code, filename) === 'script') {
-        return `${code}\nexports.__wywPreval = ${object};`;
-    }
-    return `${code}\nexport const __wywPreval = ${object};`;
-};
+import { appendOxcWywPreval } from './oxcPreevalStage/prevalExport';
+import { prepareOxcPreevalCode } from './oxcPreevalStage/prepareCode';
+import { collectPreevalProcessors } from './oxcPreevalStage/processors';
+import { createStaticPreevalOverlay } from './oxcPreevalStage/staticOverlay';
+export { appendOxcWywPreval } from './oxcPreevalStage/prevalExport';
 export const runOxcPreevalStage = (code, fileContext, options) => {
     const filename = fileContext.filename ?? 'unknown.js';
-    const dependencyNames = [];
     const eventEmitter = options.eventEmitter ?? EventEmitter.dummy;
-    const processed = eventEmitter.perf('transform:preeval:processTemplate', () => applyOxcProcessors(code, fileContext, options, (processor) => {
-        processor.dependencies.forEach((dependency) => {
-            if (dependency.ex.type === 'Identifier') {
-                dependencyNames.push(dependency.ex.name);
-            }
-        });
-        processor.doEvaltimeReplacement();
-    }));
-    const staticValuesEnabled = isStaticImportValuesEnabled(options.features, filename);
-    const staticValueNames = staticValuesEnabled
-        ? new Set(processed.staticValues.map((item) => item.name))
-        : null;
-    const evalDependencyNames = staticValuesEnabled
-        ? dependencyNames.filter((name) => !staticValueNames.has(name))
-        : dependencyNames;
-    let nextCode = eventEmitter.perf('transform:preeval:importMetaEnv', () => replaceImportMetaEnvWithOxc(processed.code, filename));
-    if (isFeatureEnabled(options.features, 'dangerousCodeRemover', filename)) {
-        nextCode = eventEmitter.perf('transform:preeval:removeDangerousCode', () => removeDangerousCodeWithOxc(nextCode, filename, options.codeRemover));
-    }
-    const shouldRewriteDynamicImports = DYNAMIC_IMPORT_RE.test(nextCode);
-    const shouldAddRequireFallback = REQUIRE_CALL_RE.test(nextCode);
-    if (shouldRewriteDynamicImports || shouldAddRequireFallback) {
-        nextCode = rewriteDynamicImportsAndAddRequireFallbackWithOxc(nextCode, filename, {
-            addRequireFallback: shouldAddRequireFallback,
-            eventEmitter,
-            rewriteDynamicImports: shouldRewriteDynamicImports,
-        });
-    }
+    const { dependencyNames, processed } = collectPreevalProcessors(code, fileContext, options, eventEmitter);
+    const staticOverlay = createStaticPreevalOverlay(processed, dependencyNames, options);
+    const baseCode = prepareOxcPreevalCode(processed.code, filename, options, eventEmitter);
     if (processed.processors.length === 0) {
         return {
-            baseCode: nextCode,
-            code: nextCode,
+            baseCode,
+            code: baseCode,
             dependencyNames: [],
             metadata: null,
+            processorClassNames: {},
             staticDependencies: [],
             staticValueCandidates: [],
             staticValueCache: new Map(),
         };
     }
-    const staticValueCache = new Map();
-    if (staticValuesEnabled) {
-        processed.staticValues.forEach(({ name, value }) => {
-            staticValueCache.set(name, value);
-        });
-    }
     return {
-        baseCode: nextCode,
-        code: appendOxcWywPreval(nextCode, filename, evalDependencyNames),
-        dependencyNames: evalDependencyNames,
+        baseCode,
+        code: appendOxcWywPreval(baseCode, filename, staticOverlay.evalDependencyNames),
+        dependencyNames: staticOverlay.evalDependencyNames,
         metadata: {
             dependencies: [],
             processors: processed.processors,
             replacements: [],
             rules: {},
         },
+        processorClassNames: Object.fromEntries(processed.processorClassNamesByLocal),
         staticDependencies: [],
-        staticValueCandidates: staticValuesEnabled
-            ? processed.staticValueCandidates
-            : [],
-        staticValueCache,
+        staticValueCache: staticOverlay.staticValueCache,
+        staticValueCandidates: staticOverlay.staticValueCandidates,
     };
 };