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

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

@@ -0,0 +1,351 @@
+/* eslint-disable no-restricted-syntax,no-continue,@typescript-eslint/no-use-before-define */
+import { evaluateOxcStaticExpressionAt, isOxcStaticSerializableValue, lookupStaticBinding } from "../../../utils/collectOxcTemplateDependencies.js";
+import { getStaticExportCachedResult, getStaticFileAnalysis, getStaticMetadataPreevalResult, setStaticExportCachedResult } from "./cache.js";
+import { resolveDependency } from "./dependencies.js";
+import { debugStaticResolve, getStaticBindings } from "./environment.js";
+import { findExportTarget, typeScriptEnumStaticExportValue } from "./exportTargets.js";
+import { resolveObjectAssignStaticExport } from "./objectAssignStaticExport.js";
+import { resolveProcessorStaticExport } from "./processorStaticExport.js";
+import { bindStaticResolvedValue, collectImportBindings } from "./staticExpression.js";
+import { collectStaticExpressionDependencies } from "./staticExpressionDependencies.js";
+import { resolveZeroArgFunctionStaticExport } from "./zeroArgFunctionStaticExport.js";
+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);
+}
+//# sourceMappingURL=exportResolver.js.map

package/esm/transform/generators/resolveStaticOxcValues/exportResolver.js.map

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

package/esm/transform/generators/resolveStaticOxcValues/exportTargets.js

@@ -0,0 +1,253 @@
+import { collectLocalConstExpressions } from "./programAnalysis.js";
+import { collectImportBindings, moduleExportName, unwrapExpression } from "./staticExpression.js";
+export const getExportSpecifierNames = (specifier) => ({
+	exported: moduleExportName(specifier.exported),
+	local: moduleExportName(specifier.local)
+});
+export const findExportTarget = (program, exportedName) => {
+	const imports = collectImportBindings(program);
+	const locals = collectLocalConstExpressions(program);
+	for (const statement of program.body) {
+		if (statement.type === "ExportNamedDeclaration") {
+			if (statement.source) {
+				for (const specifier of statement.specifiers) {
+					if (specifier.type !== "ExportSpecifier") {
+						continue;
+					}
+					const names = getExportSpecifierNames(specifier);
+					if (names.exported === exportedName) {
+						return {
+							imported: names.local,
+							kind: "import",
+							source: statement.source.value
+						};
+					}
+				}
+				continue;
+			}
+			if (statement.declaration?.type === "VariableDeclaration") {
+				for (const declarator of statement.declaration.declarations) {
+					if (declarator.id.type === "Identifier" && declarator.id.name === exportedName && declarator.init) {
+						return {
+							expression: declarator.init,
+							kind: "expression",
+							localName: declarator.id.name
+						};
+					}
+				}
+				continue;
+			}
+			for (const specifier of statement.specifiers) {
+				if (specifier.type !== "ExportSpecifier") {
+					continue;
+				}
+				const names = getExportSpecifierNames(specifier);
+				if (names.exported !== exportedName) {
+					continue;
+				}
+				const importBinding = imports.get(names.local);
+				if (importBinding) {
+					return {
+						imported: importBinding.imported,
+						kind: "import",
+						source: importBinding.source
+					};
+				}
+				const local = locals.get(names.local);
+				if (local) {
+					return {
+						expression: local,
+						kind: "expression",
+						localName: names.local
+					};
+				}
+			}
+		}
+		if (exportedName === "default" && statement.type === "ExportDefaultDeclaration") {
+			const { declaration } = statement;
+			if (declaration.type === "Identifier") {
+				const importBinding = imports.get(declaration.name);
+				if (importBinding) {
+					return {
+						imported: importBinding.imported,
+						kind: "import",
+						source: importBinding.source
+					};
+				}
+				const local = locals.get(declaration.name);
+				if (local) {
+					return {
+						expression: local,
+						kind: "expression",
+						localName: declaration.name
+					};
+				}
+				return null;
+			}
+			return {
+				expression: declaration,
+				kind: "expression"
+			};
+		}
+	}
+	return null;
+};
+export const exportedLocalName = (program, exportedName) => {
+	for (const statement of program.body) {
+		if (statement.type === "ExportNamedDeclaration") {
+			if (statement.source || statement.declaration) {
+				continue;
+			}
+			for (const specifier of statement.specifiers) {
+				if (specifier.type !== "ExportSpecifier") {
+					continue;
+				}
+				const names = getExportSpecifierNames(specifier);
+				if (names.exported === exportedName) {
+					return names.local;
+				}
+			}
+		}
+		if (exportedName === "default" && statement.type === "ExportDefaultDeclaration" && statement.declaration.type === "Identifier") {
+			return statement.declaration.name;
+		}
+	}
+	return null;
+};
+export const isIdentifierNamed = (node, name) => node.type === "Identifier" && node.name === name;
+export const enumLiteralValue = (node) => {
+	const unwrapped = unwrapExpression(node);
+	if (unwrapped.type === "Literal") {
+		const { value } = unwrapped;
+		return typeof value === "string" || typeof value === "number" ? value : null;
+	}
+	if (unwrapped.type === "UnaryExpression") {
+		const argument = unwrapExpression(unwrapped.argument);
+		if ((unwrapped.operator === "-" || unwrapped.operator === "+") && argument.type === "Literal" && typeof argument.value === "number") {
+			return unwrapped.operator === "-" ? -argument.value : argument.value;
+		}
+	}
+	return null;
+};
+export const enumMemberKey = (node, computed) => {
+	const unwrapped = unwrapExpression(node);
+	if (!computed && unwrapped.type === "Identifier") {
+		return unwrapped.name;
+	}
+	const value = enumLiteralValue(unwrapped);
+	return typeof value === "string" || typeof value === "number" ? String(value) : null;
+};
+export const enumSimpleAssignment = (node, enumParamName) => {
+	const unwrapped = unwrapExpression(node);
+	if (unwrapped.type !== "AssignmentExpression" || unwrapped.operator !== "=") {
+		return null;
+	}
+	const left = unwrapExpression(unwrapped.left);
+	if (left.type !== "MemberExpression" || !isIdentifierNamed(unwrapExpression(left.object), enumParamName)) {
+		return null;
+	}
+	const key = enumMemberKey(left.property, left.computed);
+	const value = enumLiteralValue(unwrapped.right);
+	return key !== null && value !== null ? {
+		key,
+		value
+	} : null;
+};
+export const collectEnumIifeAssignments = (call, localName) => {
+	const unwrapped = unwrapExpression(call.type === "ExpressionStatement" ? call.expression : call);
+	if (unwrapped.type !== "CallExpression" || unwrapped.arguments.length !== 1) {
+		return null;
+	}
+	const callee = unwrapExpression(unwrapped.callee);
+	if (callee.type !== "FunctionExpression" || callee.async || !callee.body || callee.params.length !== 1 || callee.params[0]?.type !== "Identifier") {
+		return null;
+	}
+	const enumParamName = callee.params[0].name;
+	const argument = unwrapExpression(unwrapped.arguments[0]);
+	if (argument.type !== "LogicalExpression" || argument.operator !== "||") {
+		return null;
+	}
+	const fallback = unwrapExpression(argument.right);
+	if (!isIdentifierNamed(unwrapExpression(argument.left), localName) || fallback.type !== "AssignmentExpression" || fallback.operator !== "=" || !isIdentifierNamed(unwrapExpression(fallback.left), localName) || unwrapExpression(fallback.right).type !== "ObjectExpression") {
+		return null;
+	}
+	const result = {};
+	for (const statement of callee.body.body) {
+		if (statement.type !== "ExpressionStatement") {
+			return null;
+		}
+		const expression = unwrapExpression(statement.expression);
+		if (expression.type !== "AssignmentExpression" || expression.operator !== "=") {
+			return null;
+		}
+		const left = unwrapExpression(expression.left);
+		if (left.type === "MemberExpression" && isIdentifierNamed(unwrapExpression(left.object), enumParamName)) {
+			const numericEnumAssignment = enumSimpleAssignment(left.property, enumParamName);
+			const reverseValue = enumLiteralValue(expression.right);
+			if (numericEnumAssignment && typeof numericEnumAssignment.value === "number" && typeof reverseValue === "string") {
+				result[numericEnumAssignment.key] = numericEnumAssignment.value;
+				result[String(numericEnumAssignment.value)] = reverseValue;
+				continue;
+			}
+		}
+		const assignment = enumSimpleAssignment(expression, enumParamName);
+		if (!assignment) {
+			return null;
+		}
+		result[assignment.key] = assignment.value;
+	}
+	return Object.keys(result).length > 0 ? result : null;
+};
+export const enumIifeLocalName = (statement) => {
+	if (statement.type !== "ExpressionStatement") {
+		return null;
+	}
+	const expression = unwrapExpression(statement.expression);
+	if (expression.type !== "CallExpression" || expression.arguments.length !== 1) {
+		return null;
+	}
+	const argument = unwrapExpression(expression.arguments[0]);
+	if (argument.type !== "LogicalExpression" || argument.operator !== "||") {
+		return null;
+	}
+	const fallback = unwrapExpression(argument.right);
+	if (argument.left.type !== "Identifier" || fallback.type !== "AssignmentExpression" || fallback.left.type !== "Identifier") {
+		return null;
+	}
+	return argument.left.name === fallback.left.name ? argument.left.name : null;
+};
+export const isEnumVarDeclaration = (statement) => statement.type === "VariableDeclaration" && statement.kind === "var" && statement.declarations.length > 0 && statement.declarations.every((declarator) => declarator.id.type === "Identifier" && declarator.init === null);
+export const isTypeScriptEnumOnlyModule = (program) => program.body.every((statement) => {
+	if (isEnumVarDeclaration(statement)) {
+		return true;
+	}
+	const localName = enumIifeLocalName(statement);
+	if (localName) {
+		return collectEnumIifeAssignments(statement, localName) !== null;
+	}
+	if (statement.type === "ExportDefaultDeclaration") {
+		return statement.declaration.type === "Identifier";
+	}
+	return statement.type === "ExportNamedDeclaration" && !statement.source && !statement.declaration && statement.specifiers.every((specifier) => specifier.type === "ExportSpecifier");
+});
+export const typeScriptEnumStaticExportValue = (program, exportedName) => {
+	if (!isTypeScriptEnumOnlyModule(program)) {
+		return null;
+	}
+	const localName = exportedLocalName(program, exportedName);
+	if (!localName) {
+		return null;
+	}
+	const hasDeclaration = program.body.some((statement) => isEnumVarDeclaration(statement) && statement.declarations.some((declarator) => declarator.id.type === "Identifier" && declarator.id.name === localName));
+	if (!hasDeclaration) {
+		return null;
+	}
+	for (const statement of program.body) {
+		const enumValue = collectEnumIifeAssignments(statement, localName);
+		if (enumValue) {
+			return enumValue;
+		}
+	}
+	return null;
+};
+//# sourceMappingURL=exportTargets.js.map