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

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

@@ -0,0 +1,285 @@
+/* eslint-disable no-restricted-syntax,no-continue,@typescript-eslint/no-use-before-define */
+import { collectLocalConstExpressions } from './programAnalysis';
+import { collectImportBindings, moduleExportName, unwrapExpression, } from './staticExpression';
+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;
+};

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

@@ -0,0 +1,41 @@
+import type { Expression, Node, Program } from 'oxc-parser';
+import type { ITransformAction, SyncScenarioFor } from '../../types';
+import type { ExportTarget, StaticExportResolverContext, StaticExportResult } from './types';
+export declare const isObjectAssignCallee: (program: Program, expr: Node) => boolean;
+export declare const isSafeObjectAssignAliasExpression: (program: Program, expr: Node, seen?: Set<string>) => boolean;
+export declare const objectAssignTargetExpression: (program: Program, expr: Node) => Expression | null;
+export declare const objectAssignAliasExpressions: (program: Program, expr: Node) => Expression[] | null;
+export declare const isFunctionBoundaryNode: (node: Node) => boolean;
+export declare const callHasArgumentRootName: (expr: Node, targetName: string) => boolean;
+export declare const isSafeObjectAssignAliasAugmentation: (program: Program, expr: Node, targetName: string) => boolean;
+export declare const hasOnlySafeObjectAssignCallArgumentUses: (program: Program, targetName: string) => boolean;
+export declare const objectAssignAugmentationAliasExpressions: (program: Program, targetName: string) => Expression[] | null;
+export declare const objectAssignAliasExpressionsForTarget: (program: Program, target: Extract<ExportTarget, {
+    kind: "expression";
+}>) => Expression[] | null;
+export declare const resolveObjectAssignProcessorExpression: (program: Program, expr: Expression) => Expression;
+export type ObjectAssignAliasResolution = {
+    dependencies: string[];
+    sideEffectDependencies: string[];
+    values: Record<string, unknown>[];
+};
+export type ObjectAssignAliasPropertyResolution = {
+    dependencies: string[];
+    sideEffectDependencies: string[];
+    value: unknown;
+};
+export type ObjectAssignAliasPropertyEntry = {
+    key: string;
+    value: Expression;
+};
+export declare const mergeStaticObjectAssignAliases: (targetValue: unknown, aliasValues: Record<string, unknown>[]) => unknown | null;
+export declare const objectAssignAliasObjectExpression: (program: Program, alias: Expression, seen?: Set<string>) => Expression | null;
+export declare const objectAssignAliasPropertyEntries: (program: Program, alias: Expression) => ObjectAssignAliasPropertyEntry[] | null;
+export declare function resolveObjectAssignAliasExpressionValue(action: ITransformAction, filename: string, code: string, program: Program, expression: Expression, ignoredMutableCallArgumentNames: Set<string>, stack: Set<string>, memo: Map<string, StaticExportResult | null>, resolvers: StaticExportResolverContext): SyncScenarioFor<ObjectAssignAliasPropertyResolution | null>;
+export declare function resolveObjectAssignAliasPropertyValue(action: ITransformAction, filename: string, code: string, program: Program, expression: Expression, ignoredMutableCallArgumentNames: Set<string>, stack: Set<string>, memo: Map<string, StaticExportResult | null>, resolvers: StaticExportResolverContext): SyncScenarioFor<ObjectAssignAliasPropertyResolution | null>;
+export declare function resolveObjectAssignAliasValue(action: ITransformAction, filename: string, code: string, program: Program, alias: Expression, ignoredMutableCallArgumentNames: Set<string>, stack: Set<string>, memo: Map<string, StaticExportResult | null>, resolvers: StaticExportResolverContext): SyncScenarioFor<{
+    dependencies: string[];
+    sideEffectDependencies: string[];
+    value: Record<string, unknown>;
+} | null>;
+export declare function resolveObjectAssignAliasValues(action: ITransformAction, filename: string, code: string, program: Program, aliases: Expression[], stack: Set<string>, memo: Map<string, StaticExportResult | null>, resolvers: StaticExportResolverContext): SyncScenarioFor<ObjectAssignAliasResolution | null>;

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

@@ -0,0 +1,352 @@
+/* eslint-disable no-restricted-syntax,no-continue,@typescript-eslint/no-use-before-define */
+import { evaluateOxcStaticExpressionAt } from '../../../utils/collectOxcTemplateDependencies';
+import { getOxcNodeChildren } from '../../../utils/oxc/ast';
+import { getStaticBindings } from './environment';
+import { findExportTarget } from './exportTargets';
+import { findTopLevelConstExpression, hasTopLevelBinding, objectPropertyKeyName, topLevelStatements, } from './programAnalysis';
+import { isPlainObjectRecord, isStaticObjectAssignAliasValue, isStaticWYWMetaValue, } from './processorStaticModel';
+import { bindStaticResolvedValue, isSafeStaticExpression, unwrapExpression, } from './staticExpression';
+import { collectStaticExpressionDependencies, rootIdentifierName, staticMemberName, } from './staticExpressionDependencies';
+export const isObjectAssignCallee = (program, expr) => {
+    const unwrapped = unwrapExpression(expr);
+    if (unwrapped.type !== 'MemberExpression' || unwrapped.computed) {
+        return false;
+    }
+    const methodName = staticMemberName(unwrapped.property);
+    return (methodName === 'assign' &&
+        unwrapped.object.type === 'Identifier' &&
+        unwrapped.object.name === 'Object' &&
+        !hasTopLevelBinding(program, 'Object'));
+};
+export const isSafeObjectAssignAliasExpression = (program, expr, seen = new Set()) => {
+    const unwrapped = unwrapExpression(expr);
+    if (unwrapped.type === 'Identifier') {
+        if (seen.has(unwrapped.name)) {
+            return false;
+        }
+        const local = findTopLevelConstExpression(program, unwrapped.name);
+        if (!local) {
+            return false;
+        }
+        seen.add(unwrapped.name);
+        const result = isSafeObjectAssignAliasExpression(program, local, seen);
+        seen.delete(unwrapped.name);
+        return result;
+    }
+    if (unwrapped.type !== 'ObjectExpression') {
+        return false;
+    }
+    return unwrapped.properties.every((property) => {
+        if (property.type === 'SpreadElement') {
+            return false;
+        }
+        const propertyNode = property;
+        if (propertyNode.computed ||
+            propertyNode.method ||
+            !propertyNode.value ||
+            typeof propertyNode.value !== 'object') {
+            return false;
+        }
+        return isSafeStaticExpression(propertyNode.value);
+    });
+};
+export const objectAssignTargetExpression = (program, expr) => {
+    const unwrapped = unwrapExpression(expr);
+    if (unwrapped.type !== 'CallExpression' ||
+        !isObjectAssignCallee(program, unwrapped.callee) ||
+        unwrapped.arguments.length < 2) {
+        return null;
+    }
+    const [target, ...aliases] = unwrapped.arguments;
+    if (!target || target.type === 'SpreadElement') {
+        return null;
+    }
+    if (aliases.some((alias) => alias.type === 'SpreadElement' ||
+        !isSafeObjectAssignAliasExpression(program, alias))) {
+        return null;
+    }
+    return target;
+};
+export const objectAssignAliasExpressions = (program, expr) => {
+    const unwrapped = unwrapExpression(expr);
+    if (unwrapped.type !== 'CallExpression' ||
+        !isObjectAssignCallee(program, unwrapped.callee) ||
+        unwrapped.arguments.length < 2) {
+        return null;
+    }
+    const [, ...aliases] = unwrapped.arguments;
+    if (aliases.some((alias) => alias.type === 'SpreadElement' ||
+        !isSafeObjectAssignAliasExpression(program, alias))) {
+        return null;
+    }
+    return aliases;
+};
+export const isFunctionBoundaryNode = (node) => node.type === 'ArrowFunctionExpression' ||
+    node.type === 'FunctionDeclaration' ||
+    node.type === 'FunctionExpression' ||
+    node.type === 'ClassDeclaration' ||
+    node.type === 'ClassExpression';
+export const callHasArgumentRootName = (expr, targetName) => {
+    const unwrapped = unwrapExpression(expr);
+    return (unwrapped.type === 'CallExpression' &&
+        unwrapped.arguments.some((argument) => {
+            const argumentNode = argument.type === 'SpreadElement' ? argument.argument : argument;
+            return rootIdentifierName(argumentNode) === targetName;
+        }));
+};
+export const isSafeObjectAssignAliasAugmentation = (program, expr, targetName) => {
+    const unwrapped = unwrapExpression(expr);
+    if (unwrapped.type !== 'CallExpression' ||
+        !isObjectAssignCallee(program, unwrapped.callee) ||
+        unwrapped.arguments.length < 2) {
+        return false;
+    }
+    const [target, ...aliases] = unwrapped.arguments;
+    if (!target || target.type === 'SpreadElement') {
+        return false;
+    }
+    const unwrappedTarget = unwrapExpression(target);
+    if (unwrappedTarget.type !== 'Identifier' ||
+        unwrappedTarget.name !== targetName) {
+        return false;
+    }
+    return aliases.every((alias) => alias.type !== 'SpreadElement' &&
+        isSafeObjectAssignAliasExpression(program, alias));
+};
+export const hasOnlySafeObjectAssignCallArgumentUses = (program, targetName) => {
+    let hasSafeUse = false;
+    let hasUnsafeUse = false;
+    const visit = (node) => {
+        if (hasUnsafeUse || isFunctionBoundaryNode(node)) {
+            return;
+        }
+        const unwrapped = unwrapExpression(node);
+        if (unwrapped.type === 'CallExpression') {
+            if (callHasArgumentRootName(unwrapped, targetName)) {
+                if (isSafeObjectAssignAliasAugmentation(program, unwrapped, targetName)) {
+                    hasSafeUse = true;
+                }
+                else {
+                    hasUnsafeUse = true;
+                    return;
+                }
+            }
+        }
+        getOxcNodeChildren(node).forEach(visit);
+    };
+    topLevelStatements(program).forEach(visit);
+    return hasSafeUse && !hasUnsafeUse;
+};
+export const objectAssignAugmentationAliasExpressions = (program, targetName) => {
+    const aliases = [];
+    let hasUnsafeUse = false;
+    const visit = (node) => {
+        if (hasUnsafeUse || isFunctionBoundaryNode(node)) {
+            return;
+        }
+        const unwrapped = unwrapExpression(node);
+        if (unwrapped.type === 'CallExpression') {
+            if (callHasArgumentRootName(unwrapped, targetName)) {
+                if (isSafeObjectAssignAliasAugmentation(program, unwrapped, targetName)) {
+                    const [, ...nextAliases] = unwrapped.arguments;
+                    aliases.push(...nextAliases);
+                }
+                else {
+                    hasUnsafeUse = true;
+                }
+                return;
+            }
+        }
+        getOxcNodeChildren(node).forEach(visit);
+    };
+    topLevelStatements(program).forEach(visit);
+    return !hasUnsafeUse && aliases.length > 0 ? aliases : null;
+};
+export const objectAssignAliasExpressionsForTarget = (program, target) => {
+    const aliases = [
+        ...(objectAssignAliasExpressions(program, target.expression) ?? []),
+        ...(target.localName
+            ? objectAssignAugmentationAliasExpressions(program, target.localName) ??
+                []
+            : []),
+    ];
+    return aliases.length > 0 ? aliases : null;
+};
+export const resolveObjectAssignProcessorExpression = (program, expr) => {
+    const objectAssignTarget = objectAssignTargetExpression(program, expr);
+    const target = objectAssignTarget ?? expr;
+    if (target.type !== 'Identifier') {
+        return target;
+    }
+    return findTopLevelConstExpression(program, target.name) ?? target;
+};
+export const mergeStaticObjectAssignAliases = (targetValue, aliasValues) => {
+    if (!isPlainObjectRecord(targetValue) || !isStaticWYWMetaValue(targetValue)) {
+        return null;
+    }
+    const result = { ...targetValue };
+    aliasValues.forEach((aliasValue) => {
+        Object.assign(result, aliasValue);
+    });
+    return result;
+};
+export const objectAssignAliasObjectExpression = (program, alias, seen = new Set()) => {
+    const unwrapped = unwrapExpression(alias);
+    if (unwrapped.type === 'ObjectExpression') {
+        return unwrapped;
+    }
+    if (unwrapped.type !== 'Identifier' || seen.has(unwrapped.name)) {
+        return null;
+    }
+    const local = findTopLevelConstExpression(program, unwrapped.name);
+    if (!local) {
+        return null;
+    }
+    seen.add(unwrapped.name);
+    const result = objectAssignAliasObjectExpression(program, local, seen);
+    seen.delete(unwrapped.name);
+    return result;
+};
+export const objectAssignAliasPropertyEntries = (program, alias) => {
+    const aliasObject = objectAssignAliasObjectExpression(program, alias);
+    if (!aliasObject || aliasObject.type !== 'ObjectExpression') {
+        return null;
+    }
+    const entries = [];
+    for (const property of aliasObject.properties) {
+        if (property.type === 'SpreadElement') {
+            return null;
+        }
+        const propertyNode = property;
+        if (propertyNode.computed ||
+            propertyNode.method ||
+            !propertyNode.key ||
+            !propertyNode.value ||
+            typeof propertyNode.key !== 'object' ||
+            typeof propertyNode.value !== 'object') {
+            return null;
+        }
+        const key = objectPropertyKeyName(propertyNode.key);
+        if (!key) {
+            return null;
+        }
+        entries.push({
+            key,
+            value: propertyNode.value,
+        });
+    }
+    return entries;
+};
+export function* resolveObjectAssignAliasExpressionValue(action, filename, code, program, expression, ignoredMutableCallArgumentNames, stack, memo, resolvers) {
+    const staticDependencies = collectStaticExpressionDependencies(program, {
+        expression,
+        kind: 'expression',
+    }, {
+        allowMetadataCalls: true,
+        ignoredMutableCallArgumentNames,
+    });
+    if (!staticDependencies) {
+        return null;
+    }
+    const env = new Map();
+    const dependencies = new Set();
+    const sideEffectDependencies = new Set();
+    for (const binding of staticDependencies.imports) {
+        const resolved = yield* resolvers.resolveImportValue(action, filename, binding, stack, memo);
+        if (!resolved ||
+            !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));
+    return isStaticObjectAssignAliasValue(value)
+        ? {
+            dependencies: [...dependencies],
+            sideEffectDependencies: [...sideEffectDependencies],
+            value,
+        }
+        : null;
+}
+export function* resolveObjectAssignAliasPropertyValue(action, filename, code, program, expression, ignoredMutableCallArgumentNames, stack, memo, resolvers) {
+    const expressionValue = yield* resolveObjectAssignAliasExpressionValue(action, filename, code, program, expression, ignoredMutableCallArgumentNames, stack, memo, resolvers);
+    if (expressionValue) {
+        return expressionValue;
+    }
+    const unwrapped = unwrapExpression(expression);
+    if (unwrapped.type !== 'Identifier' ||
+        !findExportTarget(program, unwrapped.name)) {
+        return null;
+    }
+    const resolved = yield* resolvers.resolveStaticExport(action, filename, unwrapped.name, stack, memo);
+    return resolved && isStaticObjectAssignAliasValue(resolved.value)
+        ? {
+            dependencies: resolved.dependencies,
+            sideEffectDependencies: resolved.sideEffectDependencies ?? [],
+            value: resolved.value,
+        }
+        : null;
+}
+export function* resolveObjectAssignAliasValue(action, filename, code, program, alias, ignoredMutableCallArgumentNames, stack, memo, resolvers) {
+    const aliasValue = yield* resolveObjectAssignAliasExpressionValue(action, filename, code, program, alias, ignoredMutableCallArgumentNames, stack, memo, resolvers);
+    if (aliasValue && isPlainObjectRecord(aliasValue.value)) {
+        return Object.values(aliasValue.value).every(isStaticObjectAssignAliasValue)
+            ? {
+                dependencies: aliasValue.dependencies,
+                sideEffectDependencies: aliasValue.sideEffectDependencies,
+                value: aliasValue.value,
+            }
+            : null;
+    }
+    const entries = objectAssignAliasPropertyEntries(program, alias);
+    if (!entries) {
+        return null;
+    }
+    const dependencies = new Set();
+    const sideEffectDependencies = new Set();
+    const value = {};
+    for (const entry of entries) {
+        const resolved = yield* resolveObjectAssignAliasPropertyValue(action, filename, code, program, entry.value, ignoredMutableCallArgumentNames, stack, memo, resolvers);
+        if (!resolved || !isStaticObjectAssignAliasValue(resolved.value)) {
+            return null;
+        }
+        value[entry.key] = resolved.value;
+        resolved.dependencies.forEach((item) => dependencies.add(item));
+        resolved.sideEffectDependencies.forEach((item) => sideEffectDependencies.add(item));
+    }
+    return {
+        dependencies: [...dependencies],
+        sideEffectDependencies: [...sideEffectDependencies],
+        value,
+    };
+}
+export function* resolveObjectAssignAliasValues(action, filename, code, program, aliases, stack, memo, resolvers) {
+    const dependencies = new Set();
+    const sideEffectDependencies = new Set();
+    const values = [];
+    const ignoredMutableCallArgumentNames = new Set();
+    aliases.forEach((alias) => {
+        const name = rootIdentifierName(alias);
+        if (name) {
+            ignoredMutableCallArgumentNames.add(name);
+        }
+    });
+    for (const alias of aliases) {
+        const aliasValue = yield* resolveObjectAssignAliasValue(action, filename, code, program, alias, ignoredMutableCallArgumentNames, stack, memo, resolvers);
+        if (!aliasValue) {
+            return null;
+        }
+        aliasValue.dependencies.forEach((item) => dependencies.add(item));
+        aliasValue.sideEffectDependencies.forEach((item) => sideEffectDependencies.add(item));
+        values.push(aliasValue.value);
+    }
+    return {
+        dependencies: [...dependencies],
+        sideEffectDependencies: [...sideEffectDependencies],
+        values,
+    };
+}

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

@@ -0,0 +1,6 @@
+import type { Program } from 'oxc-parser';
+import type { ITransformAction, SyncScenarioFor } from '../../types';
+import type { ExportTarget, StaticExportResolverContext, StaticExportResult } from './types';
+export declare function resolveObjectAssignStaticExport(action: ITransformAction, filename: string, code: string, program: Program, target: Extract<ExportTarget, {
+    kind: 'expression';
+}>, stack: Set<string>, memo: Map<string, StaticExportResult | null>, resolvers: StaticExportResolverContext): SyncScenarioFor<StaticExportResult | null>;