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

package/types/transform/generators/resolveStaticOxcValues/candidateResolver.js

@@ -0,0 +1,149 @@
+/* eslint-disable no-restricted-syntax,no-continue,@typescript-eslint/no-use-before-define */
+import { evaluateOxcStaticExpression, isOxcStaticSerializableValue, lookupStaticBinding, } from '../../../utils/collectOxcTemplateDependencies';
+import { resolveDependency } from './dependencies';
+import { debugStaticResolve, getStaticBindings } from './environment';
+import { resolveImportValue } from './exportResolver';
+import { resolveImportAsOpaqueRuntime } from './opaqueRuntime';
+import { bindStaticResolvedValue, isRuntimeCallbackExpression, parseStaticExpressionSource, } from './staticExpression';
+export function* resolveCandidateValue(action, candidate, filename, memo) {
+    const env = new Map();
+    const dependencies = new Set();
+    const sideEffectDependencies = new Set();
+    const sideEffectImportLocals = new Set();
+    let candidateExpression;
+    if (candidate.inlineConstants) {
+        for (const [name, value] of Object.entries(candidate.inlineConstants)) {
+            env.set(name, value);
+        }
+    }
+    const staticBindingsForCandidate = getStaticBindings(action);
+    for (const item of candidate.imports) {
+        // staticBindings overrides take precedence over actual import
+        // resolution: a registered value (or function) replaces whatever
+        // the source module would otherwise provide. Useful for prototyping
+        // / SSR theming and for opaque utilities like `cx`.
+        //
+        // Match the override map first by the raw specifier as written
+        // (`@linaria/core`, `./flags`, …). If that misses, resolve to an
+        // absolute path and try again — this lets the host key by
+        // absolute file path so a single entry covers every relative
+        // variant of the same module.
+        let override = lookupStaticBinding(staticBindingsForCandidate, item.source, item.imported);
+        if (!override.found && staticBindingsForCandidate) {
+            const dep = yield* resolveDependency(action, filename, item.source, item.imported);
+            if (dep?.resolved) {
+                override = lookupStaticBinding(staticBindingsForCandidate, dep.resolved, item.imported);
+            }
+        }
+        if (override.found) {
+            env.set(item.local, override.value);
+            continue;
+        }
+        const resolved = yield* resolveImportValue(action, filename, item, new Set(), memo);
+        if (!resolved) {
+            debugStaticResolve(action, {
+                candidate: candidate.name,
+                filename,
+                imported: item.imported,
+                phase: 'candidate',
+                reason: 'candidate-import-unresolved',
+                source: item.source,
+                status: 'rejected',
+            });
+            return null;
+        }
+        if (resolved.callable === 'zero-arg' && candidateExpression === undefined) {
+            candidateExpression = parseStaticExpressionSource(candidate.source, filename);
+        }
+        const expressionForBinding = resolved.callable === 'zero-arg' ? candidateExpression : null;
+        if ((resolved.callable === 'zero-arg' && !expressionForBinding) ||
+            (expressionForBinding &&
+                !bindStaticResolvedValue(env, expressionForBinding, item.local, resolved))) {
+            debugStaticResolve(action, {
+                candidate: candidate.name,
+                filename,
+                imported: item.imported,
+                phase: 'candidate',
+                reason: 'candidate-callable-usage-unsupported',
+                source: item.source,
+                status: 'rejected',
+            });
+            return null;
+        }
+        if (!expressionForBinding) {
+            env.set(item.local, resolved.value);
+        }
+        resolved.dependencies.forEach((dependency) => dependencies.add(dependency));
+        resolved.sideEffectDependencies?.forEach((dependency) => {
+            sideEffectDependencies.add(dependency);
+            sideEffectImportLocals.add(item.importLocal ?? item.local);
+        });
+    }
+    if (candidateExpression === undefined) {
+        candidateExpression = parseStaticExpressionSource(candidate.source, filename);
+    }
+    const value = evaluateOxcStaticExpression(candidate.source, filename, env, getStaticBindings(action));
+    // Function-valued candidates are runtime callbacks (e.g. styled-
+    // component dynamic prop interpolations like `${props => ...}`). The
+    // value isn't serializable, but the candidate IS resolved — the
+    // local `_exp = () => target` arrow already lives in the bundle, so
+    // the file does not need evalFile to compute it. Mark the result as
+    // runtimeOnly so the helper declaration survives pruning.
+    if (typeof value === 'function' ||
+        (value === undefined && isRuntimeCallbackExpression(candidateExpression))) {
+        debugStaticResolve(action, {
+            candidate: candidate.name,
+            filename,
+            phase: 'candidate',
+            reason: 'runtime-callback',
+            status: 'resolved',
+        });
+        return {
+            dependencies: [...dependencies],
+            runtimeOnly: true,
+            sideEffectDependencies: [...sideEffectDependencies],
+            sideEffectImportLocals: [...sideEffectImportLocals],
+            value,
+        };
+    }
+    if (!isOxcStaticSerializableValue(value)) {
+        debugStaticResolve(action, {
+            candidate: candidate.name,
+            filename,
+            phase: 'candidate',
+            reason: 'candidate-expression-non-serializable',
+            status: 'rejected',
+        });
+        return null;
+    }
+    debugStaticResolve(action, {
+        candidate: candidate.name,
+        filename,
+        phase: 'candidate',
+        status: 'resolved',
+    });
+    return {
+        dependencies: [...dependencies],
+        sideEffectDependencies: [...sideEffectDependencies],
+        sideEffectImportLocals: [...sideEffectImportLocals],
+        value,
+    };
+}
+export function* resolveOpaqueRuntimeCandidateValue(action, candidate, filename) {
+    if (candidate.imports.length === 0) {
+        return null;
+    }
+    const dependencies = new Set();
+    const memo = new Map();
+    for (const item of candidate.imports) {
+        const proof = yield* resolveImportAsOpaqueRuntime(action, filename, item, new Set(), memo);
+        if (!proof) {
+            return null;
+        }
+        proof.dependencies.forEach((dependency) => dependencies.add(dependency));
+    }
+    return {
+        dependencies: [...dependencies],
+        value: null,
+    };
+}

package/types/transform/generators/resolveStaticOxcValues/dependencies.d.ts

@@ -0,0 +1,6 @@
+import type { IEntrypointDependency } from '../../Entrypoint.types';
+import type { ITransformAction, SyncScenarioFor } from '../../types';
+export declare const isRelativeSource: (source: string) => boolean;
+export declare const dependencyResolutionCaches: WeakMap<object, Map<string, IEntrypointDependency>>;
+export declare const dependencyResolutionCacheKey: (importer: string, source: string, imported: string) => string;
+export declare function resolveDependency(action: ITransformAction, importer: string, source: string, imported: string): SyncScenarioFor<IEntrypointDependency | null>;

package/types/transform/generators/resolveStaticOxcValues/dependencies.js

@@ -0,0 +1,37 @@
+/* eslint-disable no-restricted-syntax,no-continue,@typescript-eslint/no-use-before-define */
+import { Entrypoint } from '../../Entrypoint';
+import { getWeakCacheMap } from './cache';
+export const isRelativeSource = (source) => source.startsWith('./') ||
+    source.startsWith('../') ||
+    source === '.' ||
+    source === '..';
+export const dependencyResolutionCaches = new WeakMap();
+// Bare package and alias resolution can depend on the importer through nested
+// packages, package boundaries, tsconfig paths, or bundler aliases.
+export const dependencyResolutionCacheKey = (importer, source, imported) => `${importer}\0${source}\0${imported}`;
+export function* resolveDependency(action, importer, source, imported) {
+    const entrypoint = importer === action.entrypoint.name
+        ? action.entrypoint
+        : Entrypoint.createRoot(action.services, importer, [imported], undefined);
+    const imports = new Map([[source, [imported]]]);
+    const [resolved] = yield* action.getNext('resolveImports', entrypoint, {
+        imports,
+        phase: 'initial',
+    });
+    // Non-relative sources (package names, aliases) can still be importer-
+    // dependent because of nested packages, tsconfig boundaries, and bundler
+    // aliases. Cache only within the same importer context.
+    if (!isRelativeSource(source)) {
+        const cache = getWeakCacheMap(dependencyResolutionCaches, action.services.cache);
+        const cacheKey = dependencyResolutionCacheKey(importer, source, imported);
+        if (resolved?.resolved) {
+            cache.set(cacheKey, resolved);
+            return resolved;
+        }
+        const cached = cache.get(cacheKey);
+        if (cached?.resolved) {
+            return cached;
+        }
+    }
+    return resolved ?? null;
+}

package/types/transform/generators/resolveStaticOxcValues/environment.d.ts

@@ -0,0 +1,12 @@
+import type { Program } from 'oxc-parser';
+import type { ITransformAction } from '../../types';
+import type { StaticResolveDebugEvent } from './types';
+export declare const isInsideRoot: (filename: string, root: string) => boolean;
+export declare const nodeModulesPattern: RegExp;
+export declare const isLocalStaticMetadataFile: (filename: string, root: string) => boolean;
+export declare const isEnvDisabled: (value: string) => boolean;
+export declare const getEvalStrategy: (action: ITransformAction) => import("@wyw-in-js/shared").EvalStrategy;
+export declare const getStaticStrategyFailure: (filename: string, dependencyNames: Iterable<string>) => Error;
+export declare const debugStaticResolve: (action: ITransformAction, event: StaticResolveDebugEvent) => void;
+export declare const parseProgram: (code: string, filename: string) => Program;
+export declare const getStaticBindings: (action: ITransformAction) => Record<string, Record<string, unknown>> | undefined;

package/types/transform/generators/resolveStaticOxcValues/environment.js

@@ -0,0 +1,32 @@
+/* eslint-disable no-restricted-syntax,no-continue,@typescript-eslint/no-use-before-define */
+import { isAbsolute, relative } from 'path';
+import { parseOxcProgram } from '../../../utils/oxc/parse';
+import { stripQueryAndHash } from '../../../utils/parseRequest';
+export const isInsideRoot = (filename, root) => {
+    const relativePath = relative(root, filename);
+    return (relativePath === '' ||
+        (!!relativePath &&
+            !relativePath.startsWith('..') &&
+            !isAbsolute(relativePath)));
+};
+export const nodeModulesPattern = /[\\/]node_modules[\\/]/;
+export const isLocalStaticMetadataFile = (filename, root) => {
+    const strippedFilename = stripQueryAndHash(filename);
+    if (isInsideRoot(strippedFilename, root)) {
+        return true;
+    }
+    return (isAbsolute(strippedFilename) && !nodeModulesPattern.test(strippedFilename));
+};
+export const isEnvDisabled = (value) => value === '0' || value === 'false' || value === 'no' || value === 'off';
+export const getEvalStrategy = (action) => action.services.options.pluginOptions.eval?.strategy ?? 'execute';
+export const getStaticStrategyFailure = (filename, dependencyNames) => new Error(`[wyw-in-js] eval.strategy: "static" cannot fall back to the build-time evaluator for ${filename}. ` +
+    `Unresolved values: ${[...dependencyNames].join(', ')}.`);
+export const debugStaticResolve = (action, event) => {
+    const labels = Object.fromEntries(Object.entries({
+        ...event,
+        type: 'staticResolve',
+    }).filter(([, value]) => value !== undefined));
+    action.services.eventEmitter.single(labels);
+};
+export const parseProgram = (code, filename) => parseOxcProgram(code, filename, 'unambiguous');
+export const getStaticBindings = (action) => action.services.options.pluginOptions?.staticBindings;

package/types/transform/generators/resolveStaticOxcValues/exportResolver.d.ts

@@ -0,0 +1,4 @@
+import type { ITransformAction, SyncScenarioFor } from '../../types';
+import type { ImportBinding, StaticExportResult } from './types';
+export declare function resolveImportValue(action: ITransformAction, importer: string, binding: Pick<ImportBinding, 'imported' | 'source'>, stack: Set<string>, memo: Map<string, StaticExportResult | null>): SyncScenarioFor<StaticExportResult | null>;
+export declare function resolveStaticExport(action: ITransformAction, filename: string, exportedName: string, stack: Set<string>, memo: Map<string, StaticExportResult | null>): SyncScenarioFor<StaticExportResult | null>;

package/types/transform/generators/resolveStaticOxcValues/exportResolver.js

@@ -0,0 +1,358 @@
+/* eslint-disable no-restricted-syntax,no-continue,@typescript-eslint/no-use-before-define */
+import { evaluateOxcStaticExpressionAt, isOxcStaticSerializableValue, lookupStaticBinding, } from '../../../utils/collectOxcTemplateDependencies';
+import { getStaticExportCachedResult, getStaticFileAnalysis, getStaticMetadataPreevalResult, setStaticExportCachedResult, } from './cache';
+import { resolveDependency } from './dependencies';
+import { debugStaticResolve, getStaticBindings } from './environment';
+import { findExportTarget, typeScriptEnumStaticExportValue, } from './exportTargets';
+import { resolveObjectAssignStaticExport } from './objectAssignStaticExport';
+import { resolveProcessorStaticExport } from './processorStaticExport';
+import { bindStaticResolvedValue, collectImportBindings, } from './staticExpression';
+import { collectStaticExpressionDependencies } from './staticExpressionDependencies';
+import { resolveZeroArgFunctionStaticExport } from './zeroArgFunctionStaticExport';
+export function* resolveImportValue(action, importer, binding, stack, memo) {
+    const dependency = yield* resolveDependency(action, importer, binding.source, binding.imported);
+    if (!dependency?.resolved) {
+        debugStaticResolve(action, {
+            filename: importer,
+            imported: binding.imported,
+            phase: 'import',
+            reason: 'dependency-unresolved',
+            source: binding.source,
+            status: 'rejected',
+        });
+        return null;
+    }
+    const resolved = yield* resolveStaticExport(action, dependency.resolved, binding.imported, stack, memo);
+    if (!resolved) {
+        debugStaticResolve(action, {
+            dependency: dependency.resolved,
+            filename: importer,
+            imported: binding.imported,
+            phase: 'import',
+            reason: 'resolve-failed',
+            source: binding.source,
+            status: 'rejected',
+        });
+        return null;
+    }
+    debugStaticResolve(action, {
+        dependency: dependency.resolved,
+        filename: importer,
+        imported: binding.imported,
+        phase: 'import',
+        source: binding.source,
+        status: 'resolved',
+    });
+    return {
+        callable: resolved.callable,
+        dependencies: [
+            dependency.resolved,
+            ...resolved.dependencies.filter((item) => item !== dependency.resolved),
+        ],
+        sideEffectDependencies: resolved.sideEffectDependencies,
+        value: resolved.value,
+    };
+}
+export function* resolveStaticExport(action, filename, exportedName, stack, memo) {
+    const memoKey = `${filename}\0${exportedName}`;
+    if (memo.has(memoKey)) {
+        return memo.get(memoKey) ?? null;
+    }
+    if (stack.has(memoKey)) {
+        memo.set(memoKey, null);
+        debugStaticResolve(action, {
+            exported: exportedName,
+            filename,
+            phase: 'export',
+            reason: 'cyclic-export',
+            status: 'rejected',
+        });
+        return null;
+    }
+    stack.add(memoKey);
+    const analysis = getStaticFileAnalysis(action, filename);
+    if (!analysis) {
+        memo.set(memoKey, null);
+        stack.delete(memoKey);
+        debugStaticResolve(action, {
+            exported: exportedName,
+            filename,
+            phase: 'export',
+            reason: 'ignored-or-non-oxc',
+            status: 'rejected',
+        });
+        return null;
+    }
+    const { code, codeHash, program } = analysis;
+    const finish = (result) => {
+        memo.set(memoKey, result);
+        stack.delete(memoKey);
+        setStaticExportCachedResult(action, filename, exportedName, codeHash, result);
+        return result;
+    };
+    const cachedResult = getStaticExportCachedResult(action, filename, exportedName, codeHash);
+    if (cachedResult !== undefined) {
+        memo.set(memoKey, cachedResult);
+        stack.delete(memoKey);
+        return cachedResult;
+    }
+    const enumValue = typeScriptEnumStaticExportValue(program, exportedName);
+    if (enumValue) {
+        debugStaticResolve(action, {
+            exported: exportedName,
+            filename,
+            phase: 'export',
+            reason: 'typescript-enum',
+            status: 'resolved',
+        });
+        return finish({
+            dependencies: [filename],
+            value: enumValue,
+        });
+    }
+    const target = findExportTarget(program, exportedName);
+    if (!target) {
+        debugStaticResolve(action, {
+            exported: exportedName,
+            filename,
+            phase: 'export',
+            reason: 'no-export-target',
+            status: 'rejected',
+        });
+        return finish(null);
+    }
+    if (target.kind === 'import') {
+        const resolved = yield* resolveImportValue(action, filename, target, stack, memo);
+        debugStaticResolve(action, {
+            exported: exportedName,
+            filename,
+            imported: target.imported,
+            phase: 'export',
+            reason: resolved ? undefined : 'resolve-failed',
+            source: target.source,
+            status: resolved ? 'resolved' : 'rejected',
+        });
+        return finish(resolved);
+    }
+    const resolvers = {
+        resolveImportValue,
+        resolveStaticExport,
+    };
+    const objectAssignResult = yield* resolveObjectAssignStaticExport(action, filename, code, program, target, stack, memo, resolvers);
+    if (objectAssignResult) {
+        debugStaticResolve(action, {
+            exported: exportedName,
+            filename,
+            phase: 'export',
+            reason: 'object-assign',
+            status: 'resolved',
+        });
+        return finish(objectAssignResult);
+    }
+    const zeroArgFunctionResult = yield* resolveZeroArgFunctionStaticExport(action, filename, code, program, target, stack, memo, resolveImportValue);
+    if (zeroArgFunctionResult) {
+        debugStaticResolve(action, {
+            exported: exportedName,
+            filename,
+            phase: 'export',
+            reason: 'zero-arg-function',
+            status: 'resolved',
+        });
+        return finish(zeroArgFunctionResult);
+    }
+    // Pre-fetch the source file's preeval result so processor className
+    // bindings (`const x = css\`\``) can short-circuit dependency walks
+    // and seed the evaluator's env. The TaggedTemplateExpression init
+    // isn't safe-static by itself; the className IS.
+    const sourcePreevalForExpression = getStaticMetadataPreevalResult(action, filename, code, codeHash);
+    const preResolvedLocals = sourcePreevalForExpression?.processorClassNames
+        ? new Set(Object.keys(sourcePreevalForExpression.processorClassNames))
+        : undefined;
+    // Build the set of import-local names registered as pure helpers via
+    // pluginOptions.staticBindings. The dependency walker admits
+    // CallExpressions whose callee is one of these so `cx(a, b)` and
+    // `isFlagPresent('x')` stop tripping isSafeStaticExpression.
+    const staticBindingsForExportShape = getStaticBindings(action);
+    const staticHelperLocals = new Set();
+    if (staticBindingsForExportShape) {
+        const fileImports = collectImportBindings(program);
+        for (const [local, binding] of fileImports) {
+            if (!binding.imported ||
+                binding.imported === '*' ||
+                binding.imported === 'default') {
+                continue;
+            }
+            let override = lookupStaticBinding(staticBindingsForExportShape, binding.source, binding.imported);
+            if (!override.found) {
+                const dep = yield* resolveDependency(action, filename, binding.source, binding.imported);
+                if (dep?.resolved) {
+                    override = lookupStaticBinding(staticBindingsForExportShape, dep.resolved, binding.imported);
+                }
+            }
+            if (override.found && typeof override.value === 'function') {
+                staticHelperLocals.add(local);
+            }
+        }
+    }
+    const staticDependencies = collectStaticExpressionDependencies(program, target, {
+        ...(preResolvedLocals ? { preResolvedLocals } : {}),
+        ...(staticHelperLocals.size > 0 ? { staticHelperLocals } : {}),
+    });
+    if (!staticDependencies) {
+        debugStaticResolve(action, {
+            exported: exportedName,
+            filename,
+            phase: 'export',
+            reason: 'unsupported-expression',
+            status: 'rejected',
+        });
+        const metadataResult = yield* resolveProcessorStaticExport(action, filename, code, codeHash, program, exportedName, stack, memo, resolvers);
+        if (metadataResult) {
+            debugStaticResolve(action, {
+                exported: exportedName,
+                filename,
+                phase: 'export',
+                status: 'resolved',
+            });
+            return finish(metadataResult);
+        }
+        // Fallback: the metadata path rejected (e.g. non-empty-css-artifact
+        // when the css\`\` template has interpolations the source-preeval
+        // can't fold). The processor still computed a className for this
+        // binding during applyOxcProcessors; surface it as the export's
+        // value. Keep the source file in sideEffectDependencies so its CSS
+        // registers at runtime.
+        //
+        // Two shapes resolve here:
+        //   export const x = css\`...\`         (TaggedTemplateExpression init)
+        //   export const x = sameFileCssConst   (Identifier alias)
+        let lookupName = null;
+        if (target.expression.type === 'TaggedTemplateExpression') {
+            lookupName = target.localName ?? null;
+        }
+        else if (target.expression.type === 'Identifier') {
+            lookupName = target.expression.name;
+        }
+        if (lookupName) {
+            const sourcePreeval = getStaticMetadataPreevalResult(action, filename, code, codeHash);
+            const className = sourcePreeval?.processorClassNames[lookupName];
+            if (className) {
+                debugStaticResolve(action, {
+                    exported: exportedName,
+                    filename,
+                    phase: 'export',
+                    reason: 'processor-class-name',
+                    status: 'resolved',
+                });
+                return finish({
+                    dependencies: [filename],
+                    sideEffectDependencies: [filename],
+                    value: className,
+                });
+            }
+        }
+        debugStaticResolve(action, {
+            exported: exportedName,
+            filename,
+            phase: 'export',
+            reason: 'resolve-failed',
+            status: 'rejected',
+        });
+        return finish(null);
+    }
+    const env = new Map();
+    const dependencies = new Set([filename]);
+    const sideEffectDependencies = new Set();
+    const staticBindingsForExport = getStaticBindings(action);
+    for (const binding of staticDependencies.imports) {
+        // staticBindings overrides take precedence here too — same shape as
+        // the candidate path. Try the raw specifier first, then the
+        // resolved absolute path on miss.
+        let override = lookupStaticBinding(staticBindingsForExport, binding.source, binding.imported);
+        if (!override.found && staticBindingsForExport) {
+            const dep = yield* resolveDependency(action, filename, binding.source, binding.imported);
+            if (dep?.resolved) {
+                override = lookupStaticBinding(staticBindingsForExport, dep.resolved, binding.imported);
+            }
+        }
+        if (override.found) {
+            env.set(binding.local, override.value);
+            continue;
+        }
+        const resolved = yield* resolveImportValue(action, filename, binding, stack, memo);
+        if (!resolved) {
+            debugStaticResolve(action, {
+                exported: exportedName,
+                filename,
+                imported: binding.imported,
+                phase: 'export',
+                reason: 'resolve-failed',
+                source: binding.source,
+                status: 'rejected',
+            });
+            return finish(null);
+        }
+        if (!bindStaticResolvedValue(env, target.expression, binding.local, resolved)) {
+            debugStaticResolve(action, {
+                exported: exportedName,
+                filename,
+                imported: binding.imported,
+                phase: 'export',
+                reason: 'callable-usage-unsupported',
+                source: binding.source,
+                status: 'rejected',
+            });
+            return finish(null);
+        }
+        resolved.dependencies.forEach((item) => dependencies.add(item));
+        resolved.sideEffectDependencies?.forEach((item) => sideEffectDependencies.add(item));
+    }
+    // Seed env with the source file's selector-only processor class names
+    // so expressions like `baseClassName + ' ' + hoverClassName` can fold
+    // — `baseClassName`'s init is a TaggedTemplateExpression the evaluator
+    // can't unfold by walking the AST, but its className is already known
+    // from applyOxcProcessors.
+    if (sourcePreevalForExpression?.processorClassNames) {
+        for (const [name, className] of Object.entries(sourcePreevalForExpression.processorClassNames)) {
+            if (!env.has(name)) {
+                env.set(name, className);
+            }
+        }
+    }
+    const value = evaluateOxcStaticExpressionAt(code, filename, {
+        end: target.expression.end,
+        start: target.expression.start,
+    }, env, getStaticBindings(action));
+    if (!isOxcStaticSerializableValue(value)) {
+        const metadataResult = yield* resolveProcessorStaticExport(action, filename, code, codeHash, program, exportedName, stack, memo, resolvers);
+        if (metadataResult) {
+            debugStaticResolve(action, {
+                exported: exportedName,
+                filename,
+                phase: 'export',
+                status: 'resolved',
+            });
+            return finish(metadataResult);
+        }
+        debugStaticResolve(action, {
+            exported: exportedName,
+            filename,
+            phase: 'export',
+            reason: 'non-serializable',
+            status: 'rejected',
+        });
+        return finish(null);
+    }
+    const result = {
+        dependencies: [...dependencies],
+        sideEffectDependencies: [...sideEffectDependencies],
+        value,
+    };
+    debugStaticResolve(action, {
+        exported: exportedName,
+        filename,
+        phase: 'export',
+        status: 'resolved',
+    });
+    return finish(result);
+}

package/types/transform/generators/resolveStaticOxcValues/exportTargets.d.ts

@@ -0,0 +1,20 @@
+import type { ExportSpecifier, Node, Program, VariableDeclaration } from 'oxc-parser';
+import type { ExportTarget } from './types';
+export declare const getExportSpecifierNames: (specifier: ExportSpecifier) => {
+    exported: string;
+    local: string;
+};
+export declare const findExportTarget: (program: Program, exportedName: string) => ExportTarget | null;
+export declare const exportedLocalName: (program: Program, exportedName: string) => string | null;
+export declare const isIdentifierNamed: (node: Node, name: string) => boolean;
+export declare const enumLiteralValue: (node: Node) => number | string | null;
+export declare const enumMemberKey: (node: Node, computed: boolean) => string | null;
+export declare const enumSimpleAssignment: (node: Node, enumParamName: string) => {
+    key: string;
+    value: number | string;
+} | null;
+export declare const collectEnumIifeAssignments: (call: Node, localName: string) => Record<string, number | string> | null;
+export declare const enumIifeLocalName: (statement: Node) => string | null;
+export declare const isEnumVarDeclaration: (statement: Node) => statement is VariableDeclaration;
+export declare const isTypeScriptEnumOnlyModule: (program: Program) => boolean;
+export declare const typeScriptEnumStaticExportValue: (program: Program, exportedName: string) => Record<string, number | string> | null;