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

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

@@ -0,0 +1,298 @@
+import { createOxcStaticCallableValue } from "../../../utils/collectOxcTemplateDependencies.js";
+import { getOxcNodeChildren } from "../../../utils/oxc/ast.js";
+import { parseProgram } from "./environment.js";
+export const moduleExportName = (node) => node.type === "Literal" ? String(node.value) : node.name;
+export const unwrapExpression = (expr) => {
+	let current = expr;
+	for (;;) {
+		if (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSNonNullExpression" || current.type === "TSInstantiationExpression" || current.type === "TSTypeAssertion" || current.type === "ParenthesizedExpression") {
+			current = current.expression;
+			continue;
+		}
+		return current;
+	}
+};
+export const isProcessEnvMember = (node) => {
+	if (node.type !== "MemberExpression" || node.computed) {
+		return false;
+	}
+	if (node.property.type !== "Identifier" || node.property.name !== "env") {
+		return false;
+	}
+	return node.object.type === "Identifier" && node.object.name === "process";
+};
+export const isSafeLiteral = (node) => {
+	if (node.type !== "Literal") {
+		return false;
+	}
+	const { value } = node;
+	return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+};
+export const isSafeStaticExpression = (expr, options = {}) => {
+	const unwrapped = unwrapExpression(expr);
+	if (isSafeLiteral(unwrapped)) {
+		return true;
+	}
+	if (unwrapped.type === "Identifier") {
+		return true;
+	}
+	if (unwrapped.type === "TemplateLiteral") {
+		return unwrapped.expressions.every((item) => isSafeStaticExpression(item, options));
+	}
+	if (unwrapped.type === "UnaryExpression") {
+		return isSafeStaticExpression(unwrapped.argument, options);
+	}
+	if (unwrapped.type === "BinaryExpression" || unwrapped.type === "LogicalExpression") {
+		return isSafeStaticExpression(unwrapped.left, options) && isSafeStaticExpression(unwrapped.right, options);
+	}
+	if (unwrapped.type === "ConditionalExpression") {
+		return isSafeStaticExpression(unwrapped.test, options) && isSafeStaticExpression(unwrapped.consequent, options) && isSafeStaticExpression(unwrapped.alternate, options);
+	}
+	if (unwrapped.type === "MemberExpression") {
+		return isSafeStaticExpression(unwrapped.object, options) && (unwrapped.computed ? isSafeStaticExpression(unwrapped.property, options) : unwrapped.property.type === "Identifier");
+	}
+	if (options.allowMetadataCalls && unwrapped.type === "CallExpression") {
+		return unwrapped.callee.type === "Identifier" && unwrapped.arguments.length === 0;
+	}
+	if (unwrapped.type === "CallExpression" && options.staticHelperLocals && unwrapped.callee.type === "Identifier" && options.staticHelperLocals.has(unwrapped.callee.name)) {
+		return unwrapped.arguments.every((argument) => argument.type === "SpreadElement" ? isSafeStaticExpression(argument.argument, options) : isSafeStaticExpression(argument, options));
+	}
+	if (options.allowMetadataCalls && (unwrapped.type === "ArrowFunctionExpression" || unwrapped.type === "FunctionExpression")) {
+		return !unwrapped.async && unwrapped.params.length === 0 && !!unwrapped.body && isSafeFunctionBodyExpression(unwrapped.body, options);
+	}
+	if (unwrapped.type === "ArrayExpression") {
+		return unwrapped.elements.every((item) => {
+			if (!item) {
+				return false;
+			}
+			return item.type === "SpreadElement" ? isSafeStaticExpression(item.argument, options) : isSafeStaticExpression(item, options);
+		});
+	}
+	if (unwrapped.type === "ObjectExpression") {
+		return unwrapped.properties.every((property) => {
+			if (property.type === "SpreadElement") {
+				return isSafeStaticExpression(property.argument);
+			}
+			const propertyNode = property;
+			if (propertyNode.method) {
+				return false;
+			}
+			// Computed keys are admissible as long as the key expression
+			// itself is safe-static — the downstream evaluator already folds
+			// them against the env. Common shape: `[\`${imp} &\`]: { ... }`.
+			if (propertyNode.computed && (!propertyNode.key || typeof propertyNode.key !== "object" || !isSafeStaticExpression(propertyNode.key, options))) {
+				return false;
+			}
+			return propertyNode.value && typeof propertyNode.value === "object" && isSafeStaticExpression(propertyNode.value, options);
+		});
+	}
+	return false;
+};
+export const isTypeOnlyImport = (statement) => {
+	if (statement.importKind === "type") {
+		return true;
+	}
+	return statement.specifiers.every((specifier) => specifier.type === "ImportSpecifier" && specifier.importKind === "type");
+};
+export const getImportBinding = (statement, specifier, options = {}) => {
+	const local = specifier.local?.name;
+	if (!local) {
+		return null;
+	}
+	if (specifier.type === "ImportNamespaceSpecifier") {
+		return options.includeNamespace ? {
+			imported: "*",
+			local,
+			source: statement.source.value
+		} : null;
+	}
+	if (specifier.type === "ImportDefaultSpecifier") {
+		return {
+			imported: "default",
+			local,
+			source: statement.source.value
+		};
+	}
+	if (specifier.type !== "ImportSpecifier") {
+		return null;
+	}
+	if (statement.importKind === "type" || specifier.importKind === "type") {
+		return null;
+	}
+	return {
+		imported: moduleExportName(specifier.imported),
+		local,
+		source: statement.source.value
+	};
+};
+export const collectImportBindings = (program, options = {}) => {
+	const result = new Map();
+	program.body.forEach((statement) => {
+		if (statement.type !== "ImportDeclaration" || isTypeOnlyImport(statement)) {
+			return;
+		}
+		statement.specifiers.forEach((specifier) => {
+			const binding = getImportBinding(statement, specifier, options);
+			if (binding) {
+				result.set(binding.local, binding);
+			}
+		});
+	});
+	return result;
+};
+export const parseStaticExpressionSource = (source, filename) => {
+	try {
+		const program = parseProgram(`const __wyw_static_value = ${source};`, filename);
+		const declaration = program.body[0];
+		if (declaration?.type !== "VariableDeclaration") {
+			return null;
+		}
+		const [declarator] = declaration.declarations;
+		return declarator?.init ?? null;
+	} catch {
+		return null;
+	}
+};
+export const isRuntimeCallbackExpression = (expression) => {
+	const unwrapped = expression ? unwrapExpression(expression) : null;
+	return unwrapped?.type === "ArrowFunctionExpression" || unwrapped?.type === "FunctionExpression";
+};
+export const runtimeCallbackPlaceholder = () => undefined;
+export const isIdentifierBindingPosition = (node, parent) => {
+	if (node.type !== "Identifier" || !parent) {
+		return false;
+	}
+	if (parent.type === "VariableDeclarator" && parent.id === node || parent.type === "FunctionDeclaration" && parent.id === node || parent.type === "FunctionExpression" && parent.id === node || parent.type === "ClassDeclaration" && parent.id === node || parent.type === "ClassExpression" && parent.id === node) {
+		return true;
+	}
+	if ((parent.type === "ArrowFunctionExpression" || parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression") && parent.params.some((param) => param === node)) {
+		return true;
+	}
+	return parent.type === "ImportSpecifier" && parent.local === node || parent.type === "ImportDefaultSpecifier" && parent.local === node || parent.type === "ImportNamespaceSpecifier" && parent.local === node;
+};
+export const isPropertyKeyOnlyIdentifier = (node, parent) => node.type === "Identifier" && !!parent && (parent.type === "MemberExpression" && parent.property === node && !parent.computed || parent.type === "Property" && parent.key === node && !parent.computed && !parent.shorthand);
+export const expressionUsesNameOnlyAsZeroArgCalls = (expression, name) => {
+	let seen = false;
+	let valid = true;
+	const walk = (node, parent) => {
+		if (!valid) {
+			return;
+		}
+		if (node.type === "Identifier" && node.name === name && !isIdentifierBindingPosition(node, parent) && !isPropertyKeyOnlyIdentifier(node, parent)) {
+			if (parent?.type === "CallExpression" && parent.callee === node && parent.arguments.length === 0) {
+				seen = true;
+			} else {
+				valid = false;
+				return;
+			}
+		}
+		getOxcNodeChildren(node).forEach((child) => walk(child, node));
+	};
+	walk(expression, null);
+	return seen && valid;
+};
+export const bindStaticResolvedValue = (env, expression, local, resolved, options = {}) => {
+	if (resolved.callable === "zero-arg") {
+		if (!expressionUsesNameOnlyAsZeroArgCalls(expression, local)) {
+			return false;
+		}
+		env.set(local, createOxcStaticCallableValue(resolved.value));
+		return true;
+	}
+	env.set(local, options.wrapNonCallable ? createOxcStaticCallableValue(resolved.value) : resolved.value);
+	return true;
+};
+export const isSafeFunctionBodyExpression = (body, options) => {
+	if (body.type !== "BlockStatement") {
+		return isSafeStaticExpression(body, options);
+	}
+	return body.body.every((statement) => {
+		if (statement.type === "VariableDeclaration") {
+			return statement.kind === "const" && statement.declarations.every((declarator) => declarator.init && declarator.id.type === "Identifier" && isSafeStaticExpression(declarator.init, options));
+		}
+		return statement.type === "ReturnStatement" && !!statement.argument && isSafeStaticExpression(statement.argument, options);
+	});
+};
+export const collectStaticFunctionBodyReferences = (body, references, options) => {
+	if (body.type !== "BlockStatement") {
+		return collectStaticExpressionReferences(body, references, options);
+	}
+	return body.body.every((statement) => {
+		if (statement.type === "VariableDeclaration") {
+			return statement.kind === "const" && statement.declarations.every((declarator) => declarator.init && declarator.id.type === "Identifier" && collectStaticExpressionReferences(declarator.init, references, options));
+		}
+		return statement.type === "ReturnStatement" && !!statement.argument && collectStaticExpressionReferences(statement.argument, references, options);
+	});
+};
+export const collectStaticExpressionReferences = (expr, references, options = {}) => {
+	const unwrapped = unwrapExpression(expr);
+	if (isSafeLiteral(unwrapped)) {
+		return true;
+	}
+	if (unwrapped.type === "Identifier") {
+		references.add(unwrapped.name);
+		return true;
+	}
+	if (unwrapped.type === "TemplateLiteral") {
+		return unwrapped.expressions.every((item) => collectStaticExpressionReferences(item, references, options));
+	}
+	if (unwrapped.type === "UnaryExpression") {
+		return collectStaticExpressionReferences(unwrapped.argument, references, options);
+	}
+	if (unwrapped.type === "BinaryExpression" || unwrapped.type === "LogicalExpression") {
+		return collectStaticExpressionReferences(unwrapped.left, references, options) && collectStaticExpressionReferences(unwrapped.right, references, options);
+	}
+	if (unwrapped.type === "ConditionalExpression") {
+		return collectStaticExpressionReferences(unwrapped.test, references, options) && collectStaticExpressionReferences(unwrapped.consequent, references, options) && collectStaticExpressionReferences(unwrapped.alternate, references, options);
+	}
+	if (unwrapped.type === "MemberExpression") {
+		if (isProcessEnvMember(unwrapped) || isProcessEnvMember(unwrapped.object)) {
+			// process.env / process.env.X is an opaque build-time global —
+			// don't treat `process` as an unresolved local reference.
+			return true;
+		}
+		return collectStaticExpressionReferences(unwrapped.object, references, options) && (!unwrapped.computed || collectStaticExpressionReferences(unwrapped.property, references, options));
+	}
+	if (options.allowMetadataCalls && unwrapped.type === "CallExpression") {
+		if (unwrapped.callee.type !== "Identifier" || unwrapped.arguments.length !== 0) {
+			return false;
+		}
+		references.add(unwrapped.callee.name);
+		return true;
+	}
+	if (unwrapped.type === "CallExpression" && options.staticHelperLocals && unwrapped.callee.type === "Identifier" && options.staticHelperLocals.has(unwrapped.callee.name)) {
+		references.add(unwrapped.callee.name);
+		return unwrapped.arguments.every((argument) => argument.type === "SpreadElement" ? collectStaticExpressionReferences(argument.argument, references, options) : collectStaticExpressionReferences(argument, references, options));
+	}
+	if (options.allowMetadataCalls && (unwrapped.type === "ArrowFunctionExpression" || unwrapped.type === "FunctionExpression")) {
+		if (unwrapped.async || unwrapped.params.length !== 0) {
+			return false;
+		}
+		return !!unwrapped.body && collectStaticFunctionBodyReferences(unwrapped.body, references, options);
+	}
+	if (unwrapped.type === "ArrayExpression") {
+		return unwrapped.elements.every((item) => {
+			if (!item) {
+				return false;
+			}
+			return item.type === "SpreadElement" ? collectStaticExpressionReferences(item.argument, references, options) : collectStaticExpressionReferences(item, references, options);
+		});
+	}
+	if (unwrapped.type === "ObjectExpression") {
+		return unwrapped.properties.every((property) => {
+			if (property.type === "SpreadElement") {
+				return collectStaticExpressionReferences(property.argument, references, options);
+			}
+			const propertyNode = property;
+			if (!propertyNode.value || typeof propertyNode.value !== "object") {
+				return false;
+			}
+			if (propertyNode.computed && (!propertyNode.key || typeof propertyNode.key !== "object" || !collectStaticExpressionReferences(propertyNode.key, references, options))) {
+				return false;
+			}
+			return collectStaticExpressionReferences(propertyNode.value, references, options);
+		});
+	}
+	return false;
+};
+//# sourceMappingURL=staticExpression.js.map

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

@@ -0,0 +1 @@
+{"mappings":"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","names":[],"sources":["../../../../src/transform/generators/resolveStaticOxcValues/staticExpression.ts"],"version":3,"sourcesContent":["/* eslint-disable no-restricted-syntax,no-continue,@typescript-eslint/no-use-before-define */\n\nimport type {\n  Expression,\n  ImportDeclaration,\n  ImportSpecifier,\n  ModuleExportName,\n  Node,\n  Program,\n} from 'oxc-parser';\n\nimport { createOxcStaticCallableValue } from '../../../utils/collectOxcTemplateDependencies';\nimport { getOxcNodeChildren } from '../../../utils/oxc/ast';\nimport { parseProgram } from './environment';\nimport type {\n  AnyNode,\n  CollectImportBindingsOptions,\n  ImportBinding,\n  StaticExportResult,\n  StaticExpressionOptions,\n} from './types';\n\nexport const moduleExportName = (node: ModuleExportName): string =>\n  node.type === 'Literal' ? String(node.value) : node.name;\n\nexport const unwrapExpression = (expr: Node): Node => {\n  let current = expr;\n\n  for (;;) {\n    if (\n      current.type === 'TSAsExpression' ||\n      current.type === 'TSSatisfiesExpression' ||\n      current.type === 'TSNonNullExpression' ||\n      current.type === 'TSInstantiationExpression' ||\n      current.type === 'TSTypeAssertion' ||\n      current.type === 'ParenthesizedExpression'\n    ) {\n      current = current.expression;\n      continue;\n    }\n\n    return current;\n  }\n};\n\nexport const isProcessEnvMember = (node: Node): boolean => {\n  if (node.type !== 'MemberExpression' || node.computed) {\n    return false;\n  }\n\n  if (node.property.type !== 'Identifier' || node.property.name !== 'env') {\n    return false;\n  }\n\n  return node.object.type === 'Identifier' && node.object.name === 'process';\n};\n\nexport const isSafeLiteral = (\n  node: Node\n): node is Node & {\n  type: 'Literal';\n  value: boolean | null | number | string;\n} => {\n  if (node.type !== 'Literal') {\n    return false;\n  }\n\n  const { value } = node as AnyNode;\n  return (\n    value === null ||\n    typeof value === 'string' ||\n    typeof value === 'number' ||\n    typeof value === 'boolean'\n  );\n};\n\nexport const isSafeStaticExpression = (\n  expr: Node,\n  options: StaticExpressionOptions = {}\n): boolean => {\n  const unwrapped = unwrapExpression(expr);\n\n  if (isSafeLiteral(unwrapped)) {\n    return true;\n  }\n\n  if (unwrapped.type === 'Identifier') {\n    return true;\n  }\n\n  if (unwrapped.type === 'TemplateLiteral') {\n    return unwrapped.expressions.every((item) =>\n      isSafeStaticExpression(item, options)\n    );\n  }\n\n  if (unwrapped.type === 'UnaryExpression') {\n    return isSafeStaticExpression(unwrapped.argument, options);\n  }\n\n  if (\n    unwrapped.type === 'BinaryExpression' ||\n    unwrapped.type === 'LogicalExpression'\n  ) {\n    return (\n      isSafeStaticExpression(unwrapped.left, options) &&\n      isSafeStaticExpression(unwrapped.right, options)\n    );\n  }\n\n  if (unwrapped.type === 'ConditionalExpression') {\n    return (\n      isSafeStaticExpression(unwrapped.test, options) &&\n      isSafeStaticExpression(unwrapped.consequent, options) &&\n      isSafeStaticExpression(unwrapped.alternate, options)\n    );\n  }\n\n  if (unwrapped.type === 'MemberExpression') {\n    return (\n      isSafeStaticExpression(unwrapped.object, options) &&\n      (unwrapped.computed\n        ? isSafeStaticExpression(unwrapped.property, options)\n        : unwrapped.property.type === 'Identifier')\n    );\n  }\n\n  if (options.allowMetadataCalls && unwrapped.type === 'CallExpression') {\n    return (\n      unwrapped.callee.type === 'Identifier' && unwrapped.arguments.length === 0\n    );\n  }\n\n  if (\n    unwrapped.type === 'CallExpression' &&\n    options.staticHelperLocals &&\n    unwrapped.callee.type === 'Identifier' &&\n    options.staticHelperLocals.has(unwrapped.callee.name)\n  ) {\n    return unwrapped.arguments.every((argument) =>\n      argument.type === 'SpreadElement'\n        ? isSafeStaticExpression(argument.argument, options)\n        : isSafeStaticExpression(argument as Node, options)\n    );\n  }\n\n  if (\n    options.allowMetadataCalls &&\n    (unwrapped.type === 'ArrowFunctionExpression' ||\n      unwrapped.type === 'FunctionExpression')\n  ) {\n    return (\n      !unwrapped.async &&\n      unwrapped.params.length === 0 &&\n      !!unwrapped.body &&\n      isSafeFunctionBodyExpression(unwrapped.body, options)\n    );\n  }\n\n  if (unwrapped.type === 'ArrayExpression') {\n    return unwrapped.elements.every((item) => {\n      if (!item) {\n        return false;\n      }\n\n      return item.type === 'SpreadElement'\n        ? isSafeStaticExpression(item.argument, options)\n        : isSafeStaticExpression(item, options);\n    });\n  }\n\n  if (unwrapped.type === 'ObjectExpression') {\n    return unwrapped.properties.every((property) => {\n      if (property.type === 'SpreadElement') {\n        return isSafeStaticExpression(property.argument);\n      }\n\n      const propertyNode = property as AnyNode;\n      if (propertyNode.method) {\n        return false;\n      }\n\n      // Computed keys are admissible as long as the key expression\n      // itself is safe-static — the downstream evaluator already folds\n      // them against the env. Common shape: `[\\`${imp} &\\`]: { ... }`.\n      if (\n        propertyNode.computed &&\n        (!propertyNode.key ||\n          typeof propertyNode.key !== 'object' ||\n          !isSafeStaticExpression(propertyNode.key as Node, options))\n      ) {\n        return false;\n      }\n\n      return (\n        propertyNode.value &&\n        typeof propertyNode.value === 'object' &&\n        isSafeStaticExpression(propertyNode.value as Node, options)\n      );\n    });\n  }\n\n  return false;\n};\n\nexport const isTypeOnlyImport = (statement: ImportDeclaration): boolean => {\n  if (statement.importKind === 'type') {\n    return true;\n  }\n\n  return statement.specifiers.every(\n    (specifier) =>\n      specifier.type === 'ImportSpecifier' &&\n      (specifier as ImportSpecifier).importKind === 'type'\n  );\n};\n\nexport const getImportBinding = (\n  statement: ImportDeclaration,\n  specifier: ImportDeclaration['specifiers'][number],\n  options: CollectImportBindingsOptions = {}\n): ImportBinding | null => {\n  const local = specifier.local?.name;\n  if (!local) {\n    return null;\n  }\n\n  if (specifier.type === 'ImportNamespaceSpecifier') {\n    return options.includeNamespace\n      ? {\n          imported: '*',\n          local,\n          source: statement.source.value,\n        }\n      : null;\n  }\n\n  if (specifier.type === 'ImportDefaultSpecifier') {\n    return {\n      imported: 'default',\n      local,\n      source: statement.source.value,\n    };\n  }\n\n  if (specifier.type !== 'ImportSpecifier') {\n    return null;\n  }\n\n  if (\n    statement.importKind === 'type' ||\n    (specifier as ImportSpecifier).importKind === 'type'\n  ) {\n    return null;\n  }\n\n  return {\n    imported: moduleExportName((specifier as ImportSpecifier).imported),\n    local,\n    source: statement.source.value,\n  };\n};\n\nexport const collectImportBindings = (\n  program: Program,\n  options: CollectImportBindingsOptions = {}\n): Map<string, ImportBinding> => {\n  const result = new Map<string, ImportBinding>();\n\n  program.body.forEach((statement) => {\n    if (statement.type !== 'ImportDeclaration' || isTypeOnlyImport(statement)) {\n      return;\n    }\n\n    statement.specifiers.forEach((specifier) => {\n      const binding = getImportBinding(statement, specifier, options);\n      if (binding) {\n        result.set(binding.local, binding);\n      }\n    });\n  });\n\n  return result;\n};\nexport const parseStaticExpressionSource = (\n  source: string,\n  filename: string\n): Expression | null => {\n  try {\n    const program = parseProgram(\n      `const __wyw_static_value = ${source};`,\n      filename\n    );\n    const declaration = program.body[0];\n    if (declaration?.type !== 'VariableDeclaration') {\n      return null;\n    }\n\n    const [declarator] = declaration.declarations;\n    return declarator?.init ?? null;\n  } catch {\n    return null;\n  }\n};\n\nexport const isRuntimeCallbackExpression = (\n  expression: Expression | null\n): boolean => {\n  const unwrapped = expression ? unwrapExpression(expression) : null;\n  return (\n    unwrapped?.type === 'ArrowFunctionExpression' ||\n    unwrapped?.type === 'FunctionExpression'\n  );\n};\n\nexport const runtimeCallbackPlaceholder = (): undefined => undefined;\n\nexport const isIdentifierBindingPosition = (\n  node: Node,\n  parent: Node | null\n): boolean => {\n  if (node.type !== 'Identifier' || !parent) {\n    return false;\n  }\n\n  if (\n    (parent.type === 'VariableDeclarator' && parent.id === node) ||\n    (parent.type === 'FunctionDeclaration' && parent.id === node) ||\n    (parent.type === 'FunctionExpression' && parent.id === node) ||\n    (parent.type === 'ClassDeclaration' && parent.id === node) ||\n    (parent.type === 'ClassExpression' && parent.id === node)\n  ) {\n    return true;\n  }\n\n  if (\n    (parent.type === 'ArrowFunctionExpression' ||\n      parent.type === 'FunctionDeclaration' ||\n      parent.type === 'FunctionExpression') &&\n    parent.params.some((param) => param === node)\n  ) {\n    return true;\n  }\n\n  return (\n    (parent.type === 'ImportSpecifier' && parent.local === node) ||\n    (parent.type === 'ImportDefaultSpecifier' && parent.local === node) ||\n    (parent.type === 'ImportNamespaceSpecifier' && parent.local === node)\n  );\n};\n\nexport const isPropertyKeyOnlyIdentifier = (\n  node: Node,\n  parent: Node | null\n): boolean =>\n  node.type === 'Identifier' &&\n  !!parent &&\n  ((parent.type === 'MemberExpression' &&\n    parent.property === node &&\n    !parent.computed) ||\n    (parent.type === 'Property' &&\n      parent.key === node &&\n      !parent.computed &&\n      !parent.shorthand));\n\nexport const expressionUsesNameOnlyAsZeroArgCalls = (\n  expression: Node,\n  name: string\n): boolean => {\n  let seen = false;\n  let valid = true;\n\n  const walk = (node: Node, parent: Node | null): void => {\n    if (!valid) {\n      return;\n    }\n\n    if (\n      node.type === 'Identifier' &&\n      node.name === name &&\n      !isIdentifierBindingPosition(node, parent) &&\n      !isPropertyKeyOnlyIdentifier(node, parent)\n    ) {\n      if (\n        parent?.type === 'CallExpression' &&\n        parent.callee === node &&\n        parent.arguments.length === 0\n      ) {\n        seen = true;\n      } else {\n        valid = false;\n        return;\n      }\n    }\n\n    getOxcNodeChildren(node).forEach((child) => walk(child, node));\n  };\n\n  walk(expression, null);\n  return seen && valid;\n};\n\nexport const bindStaticResolvedValue = (\n  env: Map<string, unknown>,\n  expression: Node,\n  local: string,\n  resolved: StaticExportResult,\n  options: { wrapNonCallable?: boolean } = {}\n): boolean => {\n  if (resolved.callable === 'zero-arg') {\n    if (!expressionUsesNameOnlyAsZeroArgCalls(expression, local)) {\n      return false;\n    }\n\n    env.set(local, createOxcStaticCallableValue(resolved.value));\n    return true;\n  }\n\n  env.set(\n    local,\n    options.wrapNonCallable\n      ? createOxcStaticCallableValue(resolved.value)\n      : resolved.value\n  );\n  return true;\n};\nexport const isSafeFunctionBodyExpression = (\n  body: Node,\n  options: StaticExpressionOptions\n): boolean => {\n  if (body.type !== 'BlockStatement') {\n    return isSafeStaticExpression(body, options);\n  }\n\n  return body.body.every((statement) => {\n    if (statement.type === 'VariableDeclaration') {\n      return (\n        statement.kind === 'const' &&\n        statement.declarations.every(\n          (declarator) =>\n            declarator.init &&\n            declarator.id.type === 'Identifier' &&\n            isSafeStaticExpression(declarator.init, options)\n        )\n      );\n    }\n\n    return (\n      statement.type === 'ReturnStatement' &&\n      !!statement.argument &&\n      isSafeStaticExpression(statement.argument, options)\n    );\n  });\n};\n\nexport const collectStaticFunctionBodyReferences = (\n  body: Node,\n  references: Set<string>,\n  options: StaticExpressionOptions\n): boolean => {\n  if (body.type !== 'BlockStatement') {\n    return collectStaticExpressionReferences(body, references, options);\n  }\n\n  return body.body.every((statement) => {\n    if (statement.type === 'VariableDeclaration') {\n      return (\n        statement.kind === 'const' &&\n        statement.declarations.every(\n          (declarator) =>\n            declarator.init &&\n            declarator.id.type === 'Identifier' &&\n            collectStaticExpressionReferences(\n              declarator.init,\n              references,\n              options\n            )\n        )\n      );\n    }\n\n    return (\n      statement.type === 'ReturnStatement' &&\n      !!statement.argument &&\n      collectStaticExpressionReferences(statement.argument, references, options)\n    );\n  });\n};\n\nexport const collectStaticExpressionReferences = (\n  expr: Node,\n  references: Set<string>,\n  options: StaticExpressionOptions = {}\n): boolean => {\n  const unwrapped = unwrapExpression(expr);\n\n  if (isSafeLiteral(unwrapped)) {\n    return true;\n  }\n\n  if (unwrapped.type === 'Identifier') {\n    references.add(unwrapped.name);\n    return true;\n  }\n\n  if (unwrapped.type === 'TemplateLiteral') {\n    return unwrapped.expressions.every((item) =>\n      collectStaticExpressionReferences(item, references, options)\n    );\n  }\n\n  if (unwrapped.type === 'UnaryExpression') {\n    return collectStaticExpressionReferences(\n      unwrapped.argument,\n      references,\n      options\n    );\n  }\n\n  if (\n    unwrapped.type === 'BinaryExpression' ||\n    unwrapped.type === 'LogicalExpression'\n  ) {\n    return (\n      collectStaticExpressionReferences(unwrapped.left, references, options) &&\n      collectStaticExpressionReferences(unwrapped.right, references, options)\n    );\n  }\n\n  if (unwrapped.type === 'ConditionalExpression') {\n    return (\n      collectStaticExpressionReferences(unwrapped.test, references, options) &&\n      collectStaticExpressionReferences(\n        unwrapped.consequent,\n        references,\n        options\n      ) &&\n      collectStaticExpressionReferences(\n        unwrapped.alternate,\n        references,\n        options\n      )\n    );\n  }\n\n  if (unwrapped.type === 'MemberExpression') {\n    if (isProcessEnvMember(unwrapped) || isProcessEnvMember(unwrapped.object)) {\n      // process.env / process.env.X is an opaque build-time global —\n      // don't treat `process` as an unresolved local reference.\n      return true;\n    }\n\n    return (\n      collectStaticExpressionReferences(\n        unwrapped.object,\n        references,\n        options\n      ) &&\n      (!unwrapped.computed ||\n        collectStaticExpressionReferences(\n          unwrapped.property,\n          references,\n          options\n        ))\n    );\n  }\n\n  if (options.allowMetadataCalls && unwrapped.type === 'CallExpression') {\n    if (\n      unwrapped.callee.type !== 'Identifier' ||\n      unwrapped.arguments.length !== 0\n    ) {\n      return false;\n    }\n\n    references.add(unwrapped.callee.name);\n    return true;\n  }\n\n  if (\n    unwrapped.type === 'CallExpression' &&\n    options.staticHelperLocals &&\n    unwrapped.callee.type === 'Identifier' &&\n    options.staticHelperLocals.has(unwrapped.callee.name)\n  ) {\n    references.add(unwrapped.callee.name);\n    return unwrapped.arguments.every((argument) =>\n      argument.type === 'SpreadElement'\n        ? collectStaticExpressionReferences(\n            argument.argument,\n            references,\n            options\n          )\n        : collectStaticExpressionReferences(\n            argument as Node,\n            references,\n            options\n          )\n    );\n  }\n\n  if (\n    options.allowMetadataCalls &&\n    (unwrapped.type === 'ArrowFunctionExpression' ||\n      unwrapped.type === 'FunctionExpression')\n  ) {\n    if (unwrapped.async || unwrapped.params.length !== 0) {\n      return false;\n    }\n\n    return (\n      !!unwrapped.body &&\n      collectStaticFunctionBodyReferences(unwrapped.body, references, options)\n    );\n  }\n\n  if (unwrapped.type === 'ArrayExpression') {\n    return unwrapped.elements.every((item) => {\n      if (!item) {\n        return false;\n      }\n\n      return item.type === 'SpreadElement'\n        ? collectStaticExpressionReferences(item.argument, references, options)\n        : collectStaticExpressionReferences(item, references, options);\n    });\n  }\n\n  if (unwrapped.type === 'ObjectExpression') {\n    return unwrapped.properties.every((property) => {\n      if (property.type === 'SpreadElement') {\n        return collectStaticExpressionReferences(\n          property.argument,\n          references,\n          options\n        );\n      }\n\n      const propertyNode = property as AnyNode;\n      if (!propertyNode.value || typeof propertyNode.value !== 'object') {\n        return false;\n      }\n\n      if (\n        propertyNode.computed &&\n        (!propertyNode.key ||\n          typeof propertyNode.key !== 'object' ||\n          !collectStaticExpressionReferences(\n            propertyNode.key as Node,\n            references,\n            options\n          ))\n      ) {\n        return false;\n      }\n\n      return collectStaticExpressionReferences(\n        propertyNode.value as Node,\n        references,\n        options\n      );\n    });\n  }\n\n  return false;\n};\n"],"file":"staticExpression.js"}

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

@@ -0,0 +1,298 @@
+import { collectLocalConstExpressions } from "./programAnalysis.js";
+import { collectImportBindings, collectStaticExpressionReferences, isSafeLiteral, isSafeStaticExpression, unwrapExpression } from "./staticExpression.js";
+export const mutatingMethodNames = new Set([
+	"add",
+	"clear",
+	"copyWithin",
+	"delete",
+	"fill",
+	"pop",
+	"push",
+	"reverse",
+	"set",
+	"shift",
+	"sort",
+	"splice",
+	"unshift"
+]);
+export const rootIdentifierName = (expr) => {
+	const unwrapped = unwrapExpression(expr);
+	if (unwrapped.type === "Identifier") {
+		return unwrapped.name;
+	}
+	if (unwrapped.type === "MemberExpression") {
+		return rootIdentifierName(unwrapped.object);
+	}
+	if (unwrapped.type === "ChainExpression") {
+		return rootIdentifierName(unwrapped.expression);
+	}
+	return null;
+};
+export const staticMemberName = (expr) => {
+	const unwrapped = unwrapExpression(expr);
+	if (unwrapped.type === "Identifier") {
+		return unwrapped.name;
+	}
+	if (isSafeLiteral(unwrapped) && typeof unwrapped.value === "string") {
+		return unwrapped.value;
+	}
+	return null;
+};
+export const expressionMayProduceMutableValue = (expr, locals, visiting) => {
+	const unwrapped = unwrapExpression(expr);
+	if (unwrapped.type === "ObjectExpression" || unwrapped.type === "ArrayExpression") {
+		return true;
+	}
+	if (unwrapped.type === "Identifier") {
+		const local = locals.get(unwrapped.name);
+		if (!local || visiting.has(unwrapped.name)) {
+			return true;
+		}
+		visiting.add(unwrapped.name);
+		const result = expressionMayProduceMutableValue(local, locals, visiting);
+		visiting.delete(unwrapped.name);
+		return result;
+	}
+	if (unwrapped.type === "ConditionalExpression") {
+		return expressionMayProduceMutableValue(unwrapped.consequent, locals, visiting) || expressionMayProduceMutableValue(unwrapped.alternate, locals, visiting);
+	}
+	if (unwrapped.type === "LogicalExpression" || unwrapped.type === "MemberExpression") {
+		return true;
+	}
+	return false;
+};
+export const collectExpressionMutationHints = (expr, mutatedNames, callArgumentNames) => {
+	const unwrapped = unwrapExpression(expr);
+	if (unwrapped.type === "AssignmentExpression") {
+		const rootName = rootIdentifierName(unwrapped.left);
+		if (rootName) {
+			mutatedNames.add(rootName);
+		}
+		collectExpressionMutationHints(unwrapped.right, mutatedNames, callArgumentNames);
+		return;
+	}
+	if (unwrapped.type === "UpdateExpression") {
+		const rootName = rootIdentifierName(unwrapped.argument);
+		if (rootName) {
+			mutatedNames.add(rootName);
+		}
+		return;
+	}
+	if (unwrapped.type === "UnaryExpression") {
+		if (unwrapped.operator === "delete") {
+			const rootName = rootIdentifierName(unwrapped.argument);
+			if (rootName) {
+				mutatedNames.add(rootName);
+			}
+		}
+		collectExpressionMutationHints(unwrapped.argument, mutatedNames, callArgumentNames);
+		return;
+	}
+	if (unwrapped.type === "CallExpression") {
+		const callee = unwrapExpression(unwrapped.callee);
+		if (callee.type === "MemberExpression") {
+			const methodName = staticMemberName(callee.property);
+			const rootName = rootIdentifierName(callee.object);
+			if (rootName && methodName && mutatingMethodNames.has(methodName)) {
+				mutatedNames.add(rootName);
+			}
+			collectExpressionMutationHints(callee.object, mutatedNames, callArgumentNames);
+			if (callee.computed) {
+				collectExpressionMutationHints(callee.property, mutatedNames, callArgumentNames);
+			}
+		} else {
+			collectExpressionMutationHints(unwrapped.callee, mutatedNames, callArgumentNames);
+		}
+		unwrapped.arguments.forEach((argument) => {
+			const argumentNode = argument.type === "SpreadElement" ? argument.argument : argument;
+			const rootName = rootIdentifierName(argumentNode);
+			if (rootName) {
+				callArgumentNames.add(rootName);
+			}
+			collectExpressionMutationHints(argumentNode, mutatedNames, callArgumentNames);
+		});
+		return;
+	}
+	if (unwrapped.type === "TaggedTemplateExpression") {
+		collectExpressionMutationHints(unwrapped.tag, mutatedNames, callArgumentNames);
+		unwrapped.quasi.expressions.forEach((item) => collectExpressionMutationHints(item, mutatedNames, callArgumentNames));
+		return;
+	}
+	if (unwrapped.type === "ConditionalExpression") {
+		collectExpressionMutationHints(unwrapped.test, mutatedNames, callArgumentNames);
+		collectExpressionMutationHints(unwrapped.consequent, mutatedNames, callArgumentNames);
+		collectExpressionMutationHints(unwrapped.alternate, mutatedNames, callArgumentNames);
+		return;
+	}
+	if (unwrapped.type === "BinaryExpression" || unwrapped.type === "LogicalExpression") {
+		collectExpressionMutationHints(unwrapped.left, mutatedNames, callArgumentNames);
+		collectExpressionMutationHints(unwrapped.right, mutatedNames, callArgumentNames);
+		return;
+	}
+	if (unwrapped.type === "MemberExpression") {
+		collectExpressionMutationHints(unwrapped.object, mutatedNames, callArgumentNames);
+		if (unwrapped.computed) {
+			collectExpressionMutationHints(unwrapped.property, mutatedNames, callArgumentNames);
+		}
+		return;
+	}
+	if (unwrapped.type === "ArrayExpression") {
+		unwrapped.elements.forEach((item) => {
+			if (!item) {
+				return;
+			}
+			collectExpressionMutationHints(item.type === "SpreadElement" ? item.argument : item, mutatedNames, callArgumentNames);
+		});
+		return;
+	}
+	if (unwrapped.type === "ObjectExpression") {
+		unwrapped.properties.forEach((property) => {
+			if (property.type === "SpreadElement") {
+				collectExpressionMutationHints(property.argument, mutatedNames, callArgumentNames);
+				return;
+			}
+			const propertyNode = property;
+			if (propertyNode.computed && propertyNode.key) {
+				collectExpressionMutationHints(propertyNode.key, mutatedNames, callArgumentNames);
+			}
+			if (propertyNode.value && typeof propertyNode.value === "object") {
+				collectExpressionMutationHints(propertyNode.value, mutatedNames, callArgumentNames);
+			}
+		});
+	}
+};
+export const collectTopLevelMutationHints = (program, closureNames = null) => {
+	const callArgumentNames = new Set();
+	const mutatedNames = new Set();
+	const collectDeclaration = (declaration) => {
+		declaration.declarations.forEach((declarator) => {
+			if (closureNames) {
+				const declaredName = declarator.id.type === "Identifier" ? declarator.id.name : null;
+				if (!declaredName || !closureNames.has(declaredName)) {
+					return;
+				}
+			}
+			if (declarator.init) {
+				collectExpressionMutationHints(declarator.init, mutatedNames, callArgumentNames);
+			}
+		});
+	};
+	program.body.forEach((statement) => {
+		if (statement.type === "VariableDeclaration") {
+			collectDeclaration(statement);
+			return;
+		}
+		if (statement.type === "ExpressionStatement") {
+			collectExpressionMutationHints(statement.expression, mutatedNames, callArgumentNames);
+			return;
+		}
+		if (statement.type === "ExportNamedDeclaration") {
+			if (statement.declaration?.type === "VariableDeclaration") {
+				collectDeclaration(statement.declaration);
+			}
+			return;
+		}
+		if (statement.type === "ExportDefaultDeclaration") {
+			if (statement.declaration.type !== "FunctionDeclaration" && statement.declaration.type !== "ClassDeclaration") {
+				collectExpressionMutationHints(statement.declaration, mutatedNames, callArgumentNames);
+			}
+		}
+	});
+	return {
+		callArgumentNames,
+		mutatedNames
+	};
+};
+export const collectStaticExpressionDependencies = (program, target, options = {}) => {
+	const imports = collectImportBindings(program);
+	const locals = collectLocalConstExpressions(program);
+	const collectedImports = new Map();
+	const referencedNames = new Set();
+	const mutableReferencedNames = new Set();
+	const visitedLocals = new Set();
+	const visitingLocals = new Set();
+	const markMutable = (name, expression) => {
+		if (expressionMayProduceMutableValue(expression, locals, new Set())) {
+			mutableReferencedNames.add(name);
+		}
+	};
+	const collectLocal = (name) => {
+		// Pre-resolved locals (e.g. `const x = css\`\``) have a known value
+		// (the className string). Skip walking their init — its
+		// TaggedTemplateExpression isn't safe-static by itself, but the
+		// value is already determined.
+		if (options.preResolvedLocals?.has(name)) {
+			referencedNames.add(name);
+			visitedLocals.add(name);
+			return true;
+		}
+		const expression = locals.get(name);
+		if (!expression || visitingLocals.has(name)) {
+			return false;
+		}
+		referencedNames.add(name);
+		markMutable(name, expression);
+		if (visitedLocals.has(name)) {
+			return true;
+		}
+		visitingLocals.add(name);
+		const result = collectExpression(expression);
+		visitingLocals.delete(name);
+		if (result) {
+			visitedLocals.add(name);
+		}
+		return result;
+	};
+	const collectExpression = (expr) => {
+		if (!isSafeStaticExpression(expr, options)) {
+			return false;
+		}
+		const references = new Set();
+		if (!collectStaticExpressionReferences(expr, references, options)) {
+			return false;
+		}
+		for (const reference of references) {
+			referencedNames.add(reference);
+			const importBinding = imports.get(reference);
+			if (importBinding) {
+				collectedImports.set(`${importBinding.source}\0${importBinding.imported}\0${importBinding.local}`, importBinding);
+				mutableReferencedNames.add(reference);
+				continue;
+			}
+			if (!collectLocal(reference)) {
+				// Unknown identifier — neither an import nor a same-file local.
+				// Common case: undeclared globals like __DEV__ used in
+				// `typeof __DEV__ !== "undefined"` short-circuit guards. The
+				// evaluator returns undefined for unknowns, which the outer
+				// expression's logical short-circuits handle correctly. Don't
+				// reject the whole walk upfront — let the evaluator decide.
+				continue;
+			}
+		}
+		return true;
+	};
+	if (target.localName) {
+		referencedNames.add(target.localName);
+		markMutable(target.localName, target.expression);
+	}
+	if (!collectExpression(target.expression)) {
+		return null;
+	}
+	const closureNames = new Set(referencedNames);
+	if (target.localName) {
+		closureNames.add(target.localName);
+	}
+	const mutationHints = collectTopLevelMutationHints(program, closureNames);
+	for (const name of referencedNames) {
+		if (mutationHints.mutatedNames.has(name)) {
+			return null;
+		}
+	}
+	for (const name of mutableReferencedNames) {
+		if (mutationHints.callArgumentNames.has(name) && !options.ignoredMutableCallArgumentNames?.has(name)) {
+			return null;
+		}
+	}
+	return { imports: [...collectedImports.values()] };
+};
+//# sourceMappingURL=staticExpressionDependencies.js.map