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

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

@@ -0,0 +1,88 @@
+/* eslint-disable no-restricted-syntax,no-continue,@typescript-eslint/no-use-before-define */
+import { evaluateOxcStaticExpressionAt } from '../../../utils/collectOxcTemplateDependencies';
+import { getStaticBindings } from './environment';
+import { findTopLevelConstExpression } from './programAnalysis';
+import { collectImportBindings, bindStaticResolvedValue, } from './staticExpression';
+import { collectStaticExpressionDependencies } from './staticExpressionDependencies';
+import { mergeStaticObjectAssignAliases, objectAssignAliasExpressionsForTarget, objectAssignTargetExpression, resolveObjectAssignAliasValues, } from './objectAssign';
+import { isStaticWYWMetaValue } from './processorStaticModel';
+export function* resolveObjectAssignStaticExport(action, filename, code, program, target, stack, memo, resolvers) {
+    const objectAssignAliases = objectAssignAliasExpressionsForTarget(program, target);
+    const objectAssignTarget = objectAssignTargetExpression(program, target.expression);
+    if (!objectAssignTarget) {
+        return null;
+    }
+    const imports = collectImportBindings(program);
+    if (objectAssignTarget.type === 'Identifier') {
+        const importBinding = imports.get(objectAssignTarget.name);
+        if (importBinding) {
+            const resolved = yield* resolvers.resolveImportValue(action, filename, importBinding, stack, memo);
+            if (!resolved || !isStaticWYWMetaValue(resolved.value)) {
+                return null;
+            }
+            const dependencies = new Set([
+                filename,
+                ...resolved.dependencies.filter((item) => item !== filename),
+            ]);
+            const sideEffectDependencies = new Set(resolved.sideEffectDependencies ?? []);
+            const aliasValues = objectAssignAliases
+                ? yield* resolveObjectAssignAliasValues(action, filename, code, program, objectAssignAliases, stack, memo, resolvers)
+                : null;
+            const mergedValue = aliasValues
+                ? mergeStaticObjectAssignAliases(resolved.value, aliasValues.values)
+                : null;
+            aliasValues?.dependencies.forEach((item) => dependencies.add(item));
+            aliasValues?.sideEffectDependencies.forEach((item) => sideEffectDependencies.add(item));
+            return {
+                dependencies: [...dependencies],
+                sideEffectDependencies: [...sideEffectDependencies],
+                value: mergedValue ?? resolved.value,
+            };
+        }
+    }
+    const expression = objectAssignTarget.type === 'Identifier'
+        ? findTopLevelConstExpression(program, objectAssignTarget.name) ??
+            objectAssignTarget
+        : objectAssignTarget;
+    const staticDependencies = collectStaticExpressionDependencies(program, {
+        ...target,
+        expression,
+    });
+    if (!staticDependencies) {
+        return null;
+    }
+    const env = new Map();
+    const dependencies = new Set([filename]);
+    const sideEffectDependencies = new Set();
+    for (const binding of staticDependencies.imports) {
+        const resolved = yield* resolvers.resolveImportValue(action, filename, binding, stack, memo);
+        if (!resolved) {
+            return null;
+        }
+        if (!bindStaticResolvedValue(env, expression, binding.local, resolved)) {
+            return null;
+        }
+        resolved.dependencies.forEach((item) => dependencies.add(item));
+        resolved.sideEffectDependencies?.forEach((item) => sideEffectDependencies.add(item));
+    }
+    const value = evaluateOxcStaticExpressionAt(code, filename, {
+        end: expression.end,
+        start: expression.start,
+    }, env, getStaticBindings(action));
+    if (!isStaticWYWMetaValue(value)) {
+        return null;
+    }
+    const aliasValues = objectAssignAliases
+        ? yield* resolveObjectAssignAliasValues(action, filename, code, program, objectAssignAliases, stack, memo, resolvers)
+        : null;
+    const mergedValue = aliasValues
+        ? mergeStaticObjectAssignAliases(value, aliasValues.values)
+        : null;
+    aliasValues?.dependencies.forEach((item) => dependencies.add(item));
+    aliasValues?.sideEffectDependencies.forEach((item) => sideEffectDependencies.add(item));
+    return {
+        dependencies: [...dependencies],
+        sideEffectDependencies: [...sideEffectDependencies],
+        value: mergedValue ?? value,
+    };
+}

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

@@ -0,0 +1,13 @@
+import type { Expression, Node, Program } from 'oxc-parser';
+import type { ITransformAction, SyncScenarioFor } from '../../types';
+import type { ImportBinding, OpaqueRuntimeImportProof } from './types';
+export declare const isKnownOpaqueRuntimeWrapperImport: (binding: ImportBinding | undefined) => boolean;
+export declare const isKnownOpaqueRuntimeWrapperCallee: (expr: Node, imports: Map<string, ImportBinding>) => boolean;
+export declare const isKnownOpaqueRuntimeImportSource: (source: string) => boolean;
+export declare const isKnownExternalRuntimeComponentImportSource: (source: string) => boolean;
+export declare const isOpaqueRuntimeComponentExpression: (program: Program, expr: Node, opaqueImportNames?: Set<string>, seen?: Set<string>) => boolean;
+export declare const collectOpaqueRuntimeReferenceNames: (program: Program, expr: Node, names: Set<string>, seenHelpers?: Set<string>) => void;
+export declare function resolveExportAsOpaqueRuntimeImport(action: ITransformAction, filename: string, exportedName: string, stack: Set<string>, memo: Map<string, OpaqueRuntimeImportProof | null>): SyncScenarioFor<OpaqueRuntimeImportProof | null>;
+export declare const knownOpaqueRuntimeSourceDependency: (importer: string, source: string) => string | null;
+export declare function resolveImportAsOpaqueRuntime(action: ITransformAction, importer: string, binding: Pick<ImportBinding, 'imported' | 'source'>, stack: Set<string>, memo: Map<string, OpaqueRuntimeImportProof | null>): SyncScenarioFor<OpaqueRuntimeImportProof | null>;
+export declare function collectOpaqueRuntimeImportProof(action: ITransformAction, filename: string, program: Program, expression: Expression): SyncScenarioFor<OpaqueRuntimeImportProof>;

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

@@ -0,0 +1,263 @@
+/* eslint-disable no-restricted-syntax,no-continue,@typescript-eslint/no-use-before-define */
+import { dirname, isAbsolute, resolve as resolvePath } from 'path';
+import { oxcShaker } from '../../../shaker';
+import { getOxcNodeChildren } from '../../../utils/oxc/ast';
+import { stripQueryAndHash } from '../../../utils/parseRequest';
+import { hashStaticContent, getStaticMetadataPreevalResult } from './cache';
+import { resolveDependency } from './dependencies';
+import { parseProgram } from './environment';
+import { findExportTarget } from './exportTargets';
+import { findTopLevelConstExpression, functionReturnExpression, isTopLevelFunctionOrClass, } from './programAnalysis';
+import { collectWYWMetaExtendsExpressionsDeep, isStaticMetaObjectExpression, } from './processorStaticModel';
+import { collectImportBindings, isSafeStaticExpression, unwrapExpression, } from './staticExpression';
+import { rootIdentifierName } from './staticExpressionDependencies';
+export const isKnownOpaqueRuntimeWrapperImport = (binding) => {
+    if (!binding) {
+        return false;
+    }
+    return (binding.imported === 'observer' &&
+        (binding.source === 'mobx-react' || binding.source === 'mobx-react-lite'));
+};
+export const isKnownOpaqueRuntimeWrapperCallee = (expr, imports) => {
+    const callee = unwrapExpression(expr);
+    if (callee.type === 'Identifier') {
+        return isKnownOpaqueRuntimeWrapperImport(imports.get(callee.name));
+    }
+    return false;
+};
+export const isKnownOpaqueRuntimeImportSource = (source) => /\.svg(?:$|[?#])/.test(source);
+export const isKnownExternalRuntimeComponentImportSource = (source) => source.startsWith('@radix-ui/react-');
+export const isOpaqueRuntimeComponentExpression = (program, expr, opaqueImportNames = new Set(), seen = new Set()) => {
+    const imports = collectImportBindings(program, { includeNamespace: true });
+    const unwrapped = unwrapExpression(expr);
+    if (isStaticMetaObjectExpression(unwrapped)) {
+        return false;
+    }
+    if (unwrapped.type === 'ArrowFunctionExpression' ||
+        unwrapped.type === 'FunctionExpression' ||
+        unwrapped.type === 'ClassExpression') {
+        return true;
+    }
+    if (unwrapped.type === 'CallExpression' &&
+        unwrapped.arguments.length === 1 &&
+        isKnownOpaqueRuntimeWrapperCallee(unwrapped.callee, imports)) {
+        const [argument] = unwrapped.arguments;
+        return argument.type !== 'SpreadElement'
+            ? isOpaqueRuntimeComponentExpression(program, argument, opaqueImportNames, seen)
+            : false;
+    }
+    if (unwrapped.type === 'CallExpression' &&
+        unwrapped.callee.type === 'Identifier') {
+        const allowParams = unwrapped.arguments.every((argument) => argument.type !== 'SpreadElement' && isSafeStaticExpression(argument));
+        const local = findTopLevelConstExpression(program, unwrapped.callee.name);
+        const returned = local
+            ? functionReturnExpression(local, { allowParams })
+            : null;
+        return returned
+            ? isOpaqueRuntimeComponentExpression(program, returned, opaqueImportNames, seen)
+            : false;
+    }
+    if (unwrapped.type === 'MemberExpression' && !unwrapped.computed) {
+        const name = rootIdentifierName(unwrapped);
+        const imported = name ? imports.get(name) : undefined;
+        return (!!name &&
+            !!imported &&
+            (opaqueImportNames.has(name) ||
+                isKnownExternalRuntimeComponentImportSource(imported.source)));
+    }
+    if (unwrapped.type !== 'Identifier') {
+        return false;
+    }
+    const { name } = unwrapped;
+    if (seen.has(name)) {
+        return false;
+    }
+    seen.add(name);
+    const imported = imports.get(name);
+    if (imported) {
+        return (opaqueImportNames.has(name) ||
+            isKnownOpaqueRuntimeImportSource(imported.source) ||
+            isKnownExternalRuntimeComponentImportSource(imported.source));
+    }
+    if (isTopLevelFunctionOrClass(program, name)) {
+        return true;
+    }
+    const local = findTopLevelConstExpression(program, name);
+    return local
+        ? isOpaqueRuntimeComponentExpression(program, local, opaqueImportNames, seen)
+        : false;
+};
+export const collectOpaqueRuntimeReferenceNames = (program, expr, names, seenHelpers = new Set()) => {
+    const unwrapped = unwrapExpression(expr);
+    if (unwrapped.type === 'CallExpression' &&
+        unwrapped.callee.type === 'Identifier') {
+        const allowParams = unwrapped.arguments.every((argument) => argument.type !== 'SpreadElement' && isSafeStaticExpression(argument));
+        if (seenHelpers.has(unwrapped.callee.name)) {
+            return;
+        }
+        const local = findTopLevelConstExpression(program, unwrapped.callee.name);
+        const returned = local
+            ? functionReturnExpression(local, { allowParams })
+            : null;
+        if (returned) {
+            seenHelpers.add(unwrapped.callee.name);
+            collectOpaqueRuntimeReferenceNames(program, returned, names, seenHelpers);
+            seenHelpers.delete(unwrapped.callee.name);
+            return;
+        }
+    }
+    if (unwrapped.type === 'Identifier') {
+        names.add(unwrapped.name);
+        return;
+    }
+    getOxcNodeChildren(unwrapped).forEach((child) => collectOpaqueRuntimeReferenceNames(program, child, names, seenHelpers));
+};
+export function* resolveExportAsOpaqueRuntimeImport(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);
+        return null;
+    }
+    stack.add(memoKey);
+    const loadedAndParsed = action.services.loadAndParseFn(action.services, filename, undefined, action.services.log);
+    if (loadedAndParsed.evaluator === 'ignored' ||
+        loadedAndParsed.evaluator !== oxcShaker) {
+        memo.set(memoKey, null);
+        stack.delete(memoKey);
+        return null;
+    }
+    const codeHash = hashStaticContent(loadedAndParsed.code);
+    const preevalResult = getStaticMetadataPreevalResult(action, filename, loadedAndParsed.code, codeHash);
+    const program = parseProgram(preevalResult?.baseCode ?? loadedAndParsed.code, filename);
+    const target = findExportTarget(program, exportedName);
+    if (!target) {
+        memo.set(memoKey, null);
+        stack.delete(memoKey);
+        return null;
+    }
+    if (target.kind === 'import') {
+        const resolved = yield* resolveImportAsOpaqueRuntime(action, filename, target, stack, memo);
+        memo.set(memoKey, resolved);
+        stack.delete(memoKey);
+        return resolved;
+    }
+    if (isOpaqueRuntimeComponentExpression(program, target.expression)) {
+        const resolved = {
+            dependencies: [filename],
+            names: new Set(),
+        };
+        memo.set(memoKey, resolved);
+        stack.delete(memoKey);
+        return resolved;
+    }
+    const imports = collectImportBindings(program, { includeNamespace: true });
+    const referencedNames = new Set();
+    collectOpaqueRuntimeReferenceNames(program, target.expression, referencedNames);
+    const opaqueImportNames = new Set();
+    const dependencies = new Set([filename]);
+    for (const name of referencedNames) {
+        const binding = imports.get(name);
+        if (!binding ||
+            binding.source === 'react' ||
+            isKnownOpaqueRuntimeWrapperImport(binding)) {
+            continue;
+        }
+        const proof = yield* resolveImportAsOpaqueRuntime(action, filename, binding, stack, memo);
+        if (!proof) {
+            continue;
+        }
+        opaqueImportNames.add(name);
+        proof.dependencies.forEach((dependency) => dependencies.add(dependency));
+    }
+    const resolved = isOpaqueRuntimeComponentExpression(program, target.expression, opaqueImportNames)
+        ? {
+            dependencies: [...dependencies],
+            names: opaqueImportNames,
+        }
+        : null;
+    memo.set(memoKey, resolved);
+    stack.delete(memoKey);
+    return resolved;
+}
+export const knownOpaqueRuntimeSourceDependency = (importer, source) => {
+    if (!isKnownOpaqueRuntimeImportSource(source)) {
+        return null;
+    }
+    const request = stripQueryAndHash(source);
+    if (isAbsolute(request)) {
+        return request;
+    }
+    return request.startsWith('.')
+        ? resolvePath(dirname(importer), request)
+        : null;
+};
+export function* resolveImportAsOpaqueRuntime(action, importer, binding, stack, memo) {
+    const knownSourceDependency = knownOpaqueRuntimeSourceDependency(importer, binding.source);
+    if (knownSourceDependency) {
+        return {
+            dependencies: [knownSourceDependency],
+            names: new Set(),
+        };
+    }
+    if (isKnownExternalRuntimeComponentImportSource(binding.source)) {
+        return {
+            dependencies: [],
+            names: new Set(),
+        };
+    }
+    const dependency = yield* resolveDependency(action, importer, binding.source, binding.imported);
+    if (!dependency?.resolved) {
+        return null;
+    }
+    if (isKnownOpaqueRuntimeImportSource(binding.source) ||
+        isKnownOpaqueRuntimeImportSource(dependency.resolved)) {
+        return {
+            dependencies: [dependency.resolved],
+            names: new Set(),
+        };
+    }
+    const resolved = yield* resolveExportAsOpaqueRuntimeImport(action, dependency.resolved, binding.imported, stack, memo);
+    return resolved
+        ? {
+            dependencies: [
+                dependency.resolved,
+                ...resolved.dependencies.filter((item) => item !== dependency.resolved),
+            ],
+            names: resolved.names,
+        }
+        : null;
+}
+export function* collectOpaqueRuntimeImportProof(action, filename, program, expression) {
+    const extendsExpressions = collectWYWMetaExtendsExpressionsDeep(program, expression);
+    if (extendsExpressions.length === 0) {
+        return {
+            dependencies: [],
+            names: new Set(),
+        };
+    }
+    const imports = collectImportBindings(program, { includeNamespace: true });
+    const referencedNames = new Set();
+    extendsExpressions.forEach((extendsExpression) => collectOpaqueRuntimeReferenceNames(program, extendsExpression, referencedNames));
+    const dependencies = new Set();
+    const names = new Set();
+    const memo = new Map();
+    for (const name of referencedNames) {
+        const binding = imports.get(name);
+        if (!binding || binding.source === 'react') {
+            continue;
+        }
+        const proof = yield* resolveImportAsOpaqueRuntime(action, filename, binding, new Set(), memo);
+        if (!proof) {
+            continue;
+        }
+        names.add(name);
+        proof.dependencies.forEach((dependency) => dependencies.add(dependency));
+    }
+    return {
+        dependencies: [...dependencies],
+        names,
+    };
+}

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

@@ -0,0 +1,4 @@
+import type { Program } from 'oxc-parser';
+import type { ITransformAction, SyncScenarioFor } from '../../types';
+import type { StaticExportResolverContext, StaticExportResult } from './types';
+export declare function resolveProcessorStaticExport(action: ITransformAction, filename: string, code: string, codeHash: string, program: Program, exportedName: string, stack: Set<string>, memo: Map<string, StaticExportResult | null>, resolvers: StaticExportResolverContext): SyncScenarioFor<StaticExportResult | null>;

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

@@ -0,0 +1,191 @@
+/* eslint-disable no-restricted-syntax,no-continue,@typescript-eslint/no-use-before-define */
+import { evaluateOxcStaticExpressionAt, isOxcStaticSerializableValue, } from '../../../utils/collectOxcTemplateDependencies';
+import { getStaticMetadataPreevalResult } from './cache';
+import { debugStaticResolve, getStaticBindings, isLocalStaticMetadataFile, parseProgram, } from './environment';
+import { findExportTarget } from './exportTargets';
+import { collectOpaqueRuntimeImportProof } from './opaqueRuntime';
+import { mergeStaticObjectAssignAliases, objectAssignAliasExpressionsForTarget, resolveObjectAssignAliasValues, resolveObjectAssignProcessorExpression, } from './objectAssign';
+import { prepareProcessorTarget } from './processorTarget';
+import { collectProcessorImportLocals, isKnownProcessorClassValue, isProcessorClassValue, isSelectorOnlyProcessorValue, processorClassNameRuntimeValue, isStaticWYWMetaTreeValue, isStaticWYWMetaValue, } from './processorStaticModel';
+import { bindStaticResolvedValue } from './staticExpression';
+export function* resolveProcessorStaticExport(action, filename, code, codeHash, program, exportedName, stack, memo, resolvers) {
+    const root = action.services.options.root ?? process.cwd();
+    if (!isLocalStaticMetadataFile(filename, root)) {
+        debugStaticResolve(action, {
+            exported: exportedName,
+            filename,
+            phase: 'processor-metadata',
+            reason: 'outside-root',
+            status: 'rejected',
+        });
+        return null;
+    }
+    if (collectProcessorImportLocals(action, program, code, filename).size === 0) {
+        debugStaticResolve(action, {
+            exported: exportedName,
+            filename,
+            phase: 'processor-metadata',
+            reason: 'no-processor-imports',
+            status: 'rejected',
+        });
+        return null;
+    }
+    const preevalResult = getStaticMetadataPreevalResult(action, filename, code, codeHash);
+    if (!preevalResult) {
+        debugStaticResolve(action, {
+            exported: exportedName,
+            filename,
+            phase: 'processor-metadata',
+            reason: 'metadata-preeval-failed',
+            status: 'rejected',
+        });
+        return null;
+    }
+    if (!preevalResult.metadata) {
+        debugStaticResolve(action, {
+            exported: exportedName,
+            filename,
+            phase: 'processor-metadata',
+            reason: 'metadata-missing',
+            status: 'rejected',
+        });
+        return null;
+    }
+    const preevalCode = preevalResult.baseCode;
+    const preevalProgram = parseProgram(preevalCode, filename);
+    const target = findExportTarget(preevalProgram, exportedName);
+    if (!target || target.kind === 'import') {
+        debugStaticResolve(action, {
+            exported: exportedName,
+            filename,
+            phase: 'processor-metadata',
+            reason: 'processor-target-missing',
+            status: 'rejected',
+        });
+        return null;
+    }
+    const processorObjectAssignAliases = objectAssignAliasExpressionsForTarget(preevalProgram, target);
+    const processorExpression = resolveObjectAssignProcessorExpression(preevalProgram, target.expression);
+    const opaqueRuntimeImportProof = yield* collectOpaqueRuntimeImportProof(action, filename, preevalProgram, processorExpression);
+    const preparedTarget = prepareProcessorTarget(preevalCode, filename, preevalProgram, target, exportedName, opaqueRuntimeImportProof.names);
+    if (!preparedTarget) {
+        debugStaticResolve(action, {
+            exported: exportedName,
+            filename,
+            phase: 'processor-metadata',
+            reason: 'unsupported-processor-expression',
+            status: 'rejected',
+        });
+        return null;
+    }
+    const env = new Map();
+    const dependencies = new Set([filename]);
+    const sideEffectDependencies = new Set();
+    opaqueRuntimeImportProof.dependencies.forEach((dependency) => dependencies.add(dependency));
+    for (const binding of preparedTarget.dependencies.imports) {
+        const resolved = yield* resolvers.resolveImportValue(action, filename, binding, stack, memo);
+        if (!resolved) {
+            debugStaticResolve(action, {
+                exported: exportedName,
+                filename,
+                imported: binding.imported,
+                phase: 'processor-metadata',
+                reason: 'resolve-failed',
+                source: binding.source,
+                status: 'rejected',
+            });
+            return null;
+        }
+        if (!bindStaticResolvedValue(env, preparedTarget.expression, binding.local, resolved, {
+            wrapNonCallable: true,
+        })) {
+            debugStaticResolve(action, {
+                exported: exportedName,
+                filename,
+                imported: binding.imported,
+                phase: 'processor-metadata',
+                reason: 'callable-usage-unsupported',
+                source: binding.source,
+                status: 'rejected',
+            });
+            return null;
+        }
+        resolved.dependencies.forEach((dependency) => dependencies.add(dependency));
+        resolved.sideEffectDependencies?.forEach((dependency) => sideEffectDependencies.add(dependency));
+    }
+    const value = preparedTarget.evaluationCode && preparedTarget.evaluationSpan
+        ? evaluateOxcStaticExpressionAt(preparedTarget.evaluationCode, filename, preparedTarget.evaluationSpan, env, getStaticBindings(action))
+        : evaluateOxcStaticExpressionAt(preevalCode, filename, {
+            end: preparedTarget.expression.end,
+            start: preparedTarget.expression.start,
+        }, env, getStaticBindings(action));
+    if (!isOxcStaticSerializableValue(value)) {
+        debugStaticResolve(action, {
+            exported: exportedName,
+            filename,
+            phase: 'processor-metadata',
+            reason: 'non-serializable',
+            status: 'rejected',
+        });
+        return null;
+    }
+    let resolvedValue = value;
+    if (processorObjectAssignAliases && isStaticWYWMetaValue(value)) {
+        const aliasValues = yield* resolveObjectAssignAliasValues(action, filename, preevalCode, preevalProgram, processorObjectAssignAliases, stack, memo, resolvers);
+        const mergedValue = aliasValues
+            ? mergeStaticObjectAssignAliases(value, aliasValues.values)
+            : null;
+        if (mergedValue) {
+            resolvedValue = mergedValue;
+            aliasValues?.dependencies.forEach((dependency) => dependencies.add(dependency));
+            aliasValues?.sideEffectDependencies.forEach((dependency) => sideEffectDependencies.add(dependency));
+        }
+    }
+    const isStaticMeta = isStaticWYWMetaValue(resolvedValue);
+    const isStaticMetaTree = !isStaticMeta && isStaticWYWMetaTreeValue(resolvedValue);
+    const processors = preevalResult.metadata
+        .processors;
+    const processorClassNames = new Set(processors.map((processor) => processorClassNameRuntimeValue(processor)));
+    const isSelectorOnly = !isStaticMeta &&
+        !isStaticMetaTree &&
+        isSelectorOnlyProcessorValue(resolvedValue, processors, new Map());
+    const isSideEffectClassValue = !isStaticMeta &&
+        !isStaticMetaTree &&
+        !isSelectorOnly &&
+        (isProcessorClassValue(resolvedValue, processors, new Map()) ||
+            isKnownProcessorClassValue(resolvedValue, processorClassNames));
+    if (!isStaticMeta &&
+        !isStaticMetaTree &&
+        !isSelectorOnly &&
+        !isSideEffectClassValue) {
+        debugStaticResolve(action, {
+            exported: exportedName,
+            filename,
+            phase: 'processor-metadata',
+            reason: 'non-empty-css-artifact',
+            status: 'rejected',
+        });
+        return null;
+    }
+    let resolvedReason;
+    if (preparedTarget.opaqueRuntimeBase) {
+        resolvedReason = 'opaque-runtime-component';
+    }
+    else if (isSideEffectClassValue) {
+        resolvedReason = 'non-empty-css-artifact-side-effect';
+    }
+    debugStaticResolve(action, {
+        exported: exportedName,
+        filename,
+        phase: 'processor-metadata',
+        reason: resolvedReason,
+        status: 'resolved',
+    });
+    return {
+        dependencies: [...dependencies],
+        sideEffectDependencies: isSideEffectClassValue
+            ? [filename, ...sideEffectDependencies]
+            : [...sideEffectDependencies],
+        value: resolvedValue,
+    };
+}

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

@@ -0,0 +1,40 @@
+import type { BaseProcessor } from '@wyw-in-js/processor-utils';
+import type { Expression, Node, Program } from 'oxc-parser';
+import type { ITransformAction } from '../../types';
+export declare const collectProcessorImportLocals: (action: ITransformAction, program: Program, code: string, filename: string) => Set<string>;
+export declare const isStaticWYWMetaValue: (value: unknown, seen?: Set<unknown>) => boolean;
+export type StaticWYWSelectorMetaValue = {
+    __wyw_meta: {
+        className: string;
+        extends: StaticWYWSelectorMetaValue | null;
+    };
+};
+export declare const toStaticWYWSelectorMetaValue: (value: unknown, seen?: Set<unknown>) => StaticWYWSelectorMetaValue | null;
+export declare const staticWYWMetaExtendsReplacementCode: (value: unknown) => string | null;
+export declare const unknownStaticWYWMetaValue: unique symbol;
+export type UnknownStaticWYWMetaValue = typeof unknownStaticWYWMetaValue;
+export declare const zeroArgFunctionExpressionBody: (expr: Expression) => Expression | null;
+export declare const isNullLiteralExpression: (node: Node) => boolean;
+export declare const isNullReturningFunctionExpression: (expr: Expression) => boolean;
+export declare const createSameFileStaticWYWMetaHelperResolver: (code: string, filename: string) => ((seedValues: Map<string, unknown>) => Map<string, unknown>);
+export declare const staticWYWMetaTreeValueStatus: (value: unknown, seen?: Set<unknown>) => {
+    hasMetadata: boolean;
+    safe: boolean;
+};
+export declare const isStaticWYWMetaTreeValue: (value: unknown) => boolean;
+export type StaticProcessorInstance = BaseProcessor;
+export declare const processorClassNameRuntimeValue: (processor: StaticProcessorInstance) => string;
+export declare const isProcessorRuntimeClassName: (processor: StaticProcessorInstance, value: string) => boolean;
+export declare const isPlainObjectRecord: (value: unknown) => value is Record<string, unknown>;
+export declare const isStaticObjectAssignAliasValue: (value: unknown) => boolean;
+export declare const artifactCssText: (artifact: unknown) => string | null;
+export declare const isEmptyProcessorClassName: (value: string, processors: StaticProcessorInstance[], cache: Map<string, boolean>) => boolean;
+export declare const isProcessorClassName: (value: string, processors: StaticProcessorInstance[], cache: Map<string, boolean>) => boolean;
+export declare const isKnownProcessorClassName: (value: string, processorClassNames: ReadonlySet<string>) => boolean;
+export declare const isSelectorOnlyProcessorValue: (value: unknown, processors: StaticProcessorInstance[], cache: Map<string, boolean>, seen?: Set<unknown>) => boolean;
+export declare const isProcessorClassValue: (value: unknown, processors: StaticProcessorInstance[], cache: Map<string, boolean>, seen?: Set<unknown>) => boolean;
+export declare const isKnownProcessorClassValue: (value: unknown, processorClassNames: ReadonlySet<string>, seen?: Set<unknown>) => boolean;
+export declare const findWYWMetaExtendsExpression: (expr: Expression) => Expression | null;
+export declare const collectWYWMetaExtendsExpressionsDeep: (program: Program, expr: Expression) => Expression[];
+export declare const isStaticMetaObjectExpression: (expr: Node) => boolean;
+export declare const collectWYWMetaExtendsHelperNames: (program: Program) => Set<string>;