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

package/types/utils/applyOxcProcessors/displayName.d.ts

@@ -0,0 +1,9 @@
+import type { ExpressionValue } from '@wyw-in-js/shared';
+import type { Node, Program } from 'oxc-parser';
+import type { OxcStaticValue } from '../collectOxcTemplateDependencies';
+import type { AnyNode } from './types';
+export declare const getPropertyKeyName: (property: AnyNode, code: string) => string | null;
+export declare const getDisplayName: (ancestors: Node[], idx: number, code: string, filename?: string | null) => string;
+export declare const getTagOwner: (ancestors: Node[]) => AnyNode | null;
+export declare const isTagReferenced: (program: Program, ancestors: Node[]) => boolean;
+export declare const collectSameFileProcessorStaticValues: (expressionValues: Omit<ExpressionValue, "buildCodeFrameError">[], processorStaticValuesByLocal: Map<string, unknown>) => OxcStaticValue[];

package/types/utils/applyOxcProcessors/displayName.js

@@ -0,0 +1,113 @@
+/* eslint-disable no-restricted-syntax */
+import { basename, dirname } from 'path';
+import { ValueType } from '@wyw-in-js/shared';
+import { isOxcNode, walkOxc } from '../oxc/ast';
+import { isNodeReference } from './cleanupBindings';
+export const getPropertyKeyName = (property, code) => {
+    const { key } = property;
+    if (!isOxcNode(key)) {
+        return null;
+    }
+    if (key.type === 'Identifier') {
+        return key.name;
+    }
+    if (key.type === 'Literal') {
+        return String(key.value);
+    }
+    return typeof key.start === 'number' && typeof key.end === 'number'
+        ? code.slice(key.start, key.end)
+        : null;
+};
+export const getDisplayName = (ancestors, idx, code, filename) => {
+    const owner = [...ancestors].reverse().find((node) => {
+        return (node.type === 'Property' ||
+            node.type === 'JSXOpeningElement' ||
+            node.type === 'VariableDeclarator');
+    });
+    if (owner?.type === 'Property') {
+        const keyName = getPropertyKeyName(owner, code);
+        if (keyName) {
+            return keyName;
+        }
+    }
+    else if (owner?.type === 'JSXOpeningElement') {
+        const { name } = owner;
+        if (isOxcNode(name) && name.type === 'JSXIdentifier') {
+            return name.name;
+        }
+    }
+    else if (owner?.type === 'VariableDeclarator') {
+        const { id } = owner;
+        if (isOxcNode(id) && id.type === 'Identifier') {
+            return id.name;
+        }
+    }
+    let displayName = basename(filename ?? 'unknown').replace(/\.[a-z\d]+$/, '');
+    if (filename && /^index\.[a-z\d]+$/.test(basename(filename))) {
+        displayName = basename(dirname(filename));
+    }
+    if (!displayName) {
+        throw new Error("Couldn't determine a name for the component. Ensure that it's either:\n" +
+            '- Assigned to a variable\n' +
+            '- Is an object property\n' +
+            '- Is a prop in a JSX element\n');
+    }
+    return `${displayName}${idx}`;
+};
+export const getTagOwner = (ancestors) => {
+    const owner = [...ancestors]
+        .reverse()
+        .find((node) => node.type === 'Property' ||
+        node.type === 'JSXOpeningElement' ||
+        node.type === 'VariableDeclarator');
+    return owner ?? null;
+};
+export const isTagReferenced = (program, ancestors) => {
+    const owner = getTagOwner(ancestors);
+    if (owner?.type !== 'VariableDeclarator') {
+        return true;
+    }
+    const { id } = owner;
+    if (!isOxcNode(id) || id.type !== 'Identifier') {
+        return true;
+    }
+    if (ancestors.some((node) => node.type === 'ExportNamedDeclaration')) {
+        return true;
+    }
+    let referenced = false;
+    walkOxc(program, (node, parent) => {
+        const referenceName = node.type === 'Identifier' || node.type === 'JSXIdentifier'
+            ? node.name
+            : null;
+        if (referenced ||
+            referenceName !== id.name ||
+            (node.type === 'Identifier' &&
+                node.start === id.start &&
+                node.end === id.end)) {
+            return;
+        }
+        referenced = isNodeReference(node, parent);
+    });
+    return referenced;
+};
+export const collectSameFileProcessorStaticValues = (expressionValues, processorStaticValuesByLocal) => {
+    const staticValues = [];
+    const seen = new Set();
+    expressionValues.forEach((value) => {
+        if (value.kind !== ValueType.LAZY) {
+            return;
+        }
+        const staticValue = processorStaticValuesByLocal.get(value.source);
+        if (staticValue === undefined ||
+            value.ex.type !== 'Identifier' ||
+            seen.has(value.ex.name)) {
+            return;
+        }
+        seen.add(value.ex.name);
+        staticValues.push({
+            name: value.ex.name,
+            value: staticValue,
+        });
+    });
+    return staticValues;
+};

package/types/utils/applyOxcProcessors/expressionValues.d.ts

@@ -0,0 +1,11 @@
+import type { Param, Params, SourceLocation } from '@wyw-in-js/processor-utils';
+import type { ExpressionValue } from '@wyw-in-js/shared';
+import type { Expression, TaggedTemplateExpression } from 'oxc-parser';
+import type { LocationLookup, ProcessorUsage } from './types';
+export declare const literalExpressionValue: (expression: Expression, code: string, source: string, location: SourceLocation) => ExpressionValue | null;
+export declare const expressionValue: (expression: Expression, code: string, loc: LocationLookup, filename?: string | null) => ExpressionValue;
+export declare const withCurrentExpressionLocation: (value: ExpressionValue, expression: Expression, loc: LocationLookup, filename?: string | null) => ExpressionValue;
+export declare const shiftExpressionValue: (expressionValues: ExpressionValue[], expression: Expression, code: string, loc: LocationLookup, filename?: string | null) => ExpressionValue;
+export declare const zipTemplate: (template: TaggedTemplateExpression, code: string, loc: LocationLookup, filename: string | null | undefined, expressionValues: ExpressionValue[]) => Param;
+export declare const buildCalleeParams: (node: Expression, code: string, loc: LocationLookup, filename: string | null | undefined, expressionValues: ExpressionValue[], collapseQualifiedCallee?: boolean) => Params | null;
+export declare const buildParams: (usage: ProcessorUsage, code: string, loc: LocationLookup, filename: string | null | undefined, expressionValues: ExpressionValue[], collapseQualifiedCallee: boolean) => Params | null;

package/types/utils/applyOxcProcessors/expressionValues.js

@@ -0,0 +1,170 @@
+import { ValueType } from '@wyw-in-js/shared';
+import { isNotNull } from '../isNotNull';
+import { buildOxcCodeFrameError } from '../oxc/sourceLocations';
+import { getMemberName, unwrapQualifiedExpression } from './processorUsages';
+import { GENERATED_HELPER_NAME_RE, getSourceLocation } from './shared';
+export const literalExpressionValue = (expression, code, source, location) => {
+    if (expression.type !== 'Literal') {
+        return null;
+    }
+    if (expression.value === null ||
+        typeof expression.value === 'string' ||
+        typeof expression.value === 'number' ||
+        typeof expression.value === 'boolean') {
+        let type;
+        if (expression.value === null) {
+            type = 'NullLiteral';
+        }
+        else if (typeof expression.value === 'string') {
+            type = 'StringLiteral';
+        }
+        else if (typeof expression.value === 'number') {
+            type = 'NumericLiteral';
+        }
+        else {
+            type = 'BooleanLiteral';
+        }
+        const ex = expression.value === null
+            ? { loc: location, type }
+            : {
+                loc: location,
+                type,
+                value: expression.value,
+            };
+        return {
+            buildCodeFrameError: (message) => buildOxcCodeFrameError(code, location, message),
+            ex,
+            kind: ValueType.CONST,
+            source,
+            value: expression.value,
+        };
+    }
+    return null;
+};
+export const expressionValue = (expression, code, loc, filename) => {
+    const source = code.slice(expression.start, expression.end);
+    const location = getSourceLocation(expression.start, expression.end, loc, filename);
+    const literal = literalExpressionValue(expression, code, source, location);
+    if (literal) {
+        return literal;
+    }
+    const helperCallName = expression.type === 'CallExpression' &&
+        expression.arguments.length === 0 &&
+        expression.callee.type === 'Identifier' &&
+        GENERATED_HELPER_NAME_RE.test(expression.callee.name)
+        ? expression.callee.name
+        : null;
+    let ex;
+    if (expression.type === 'Identifier') {
+        ex = { loc: location, name: expression.name, type: 'Identifier' };
+    }
+    else if (helperCallName) {
+        ex = { loc: location, name: helperCallName, type: 'Identifier' };
+    }
+    else {
+        ex = {
+            loc: location,
+            name: code.slice(expression.start, expression.end),
+            type: 'Identifier',
+        };
+    }
+    return {
+        buildCodeFrameError: (message) => buildOxcCodeFrameError(code, location, message),
+        ex,
+        kind: expression.type === 'ArrowFunctionExpression' ||
+            expression.type === 'FunctionExpression'
+            ? ValueType.FUNCTION
+            : ValueType.LAZY,
+        source,
+    };
+};
+export const withCurrentExpressionLocation = (value, expression, loc, filename) => {
+    const location = getSourceLocation(expression.start, expression.end, loc, filename);
+    if (value.kind === ValueType.CONST) {
+        return {
+            ...value,
+            ex: {
+                ...value.ex,
+                loc: location,
+            },
+        };
+    }
+    if (value.kind === ValueType.FUNCTION) {
+        return {
+            ...value,
+            ex: {
+                ...value.ex,
+                loc: location,
+            },
+        };
+    }
+    return {
+        ...value,
+        ex: {
+            ...value.ex,
+            loc: location,
+        },
+    };
+};
+export const shiftExpressionValue = (expressionValues, expression, code, loc, filename) => expressionValues.length > 0
+    ? withCurrentExpressionLocation(expressionValues.shift(), expression, loc, filename)
+    : expressionValue(expression, code, loc, filename);
+export const zipTemplate = (template, code, loc, filename, expressionValues) => {
+    const parts = template.quasi.quasis.flatMap((quasi, idx) => {
+        const expression = template.quasi.expressions[idx];
+        const templateElement = {
+            ...quasi,
+            loc: getSourceLocation(quasi.start, quasi.end, loc, filename),
+        };
+        return [
+            templateElement,
+            expression
+                ? shiftExpressionValue(expressionValues, expression, code, loc, filename)
+                : null,
+        ].filter(isNotNull);
+    });
+    return ['template', parts];
+};
+export const buildCalleeParams = (node, code, loc, filename, expressionValues, collapseQualifiedCallee = false) => {
+    const expression = unwrapQualifiedExpression(node);
+    if (collapseQualifiedCallee &&
+        (expression.type === 'Identifier' || expression.type === 'MemberExpression')) {
+        return [['callee', expression]];
+    }
+    if (expression.type === 'Identifier') {
+        return [['callee', { name: expression.name, type: 'Identifier' }]];
+    }
+    if (expression.type === 'MemberExpression') {
+        const params = buildCalleeParams(expression.object, code, loc, filename, expressionValues, collapseQualifiedCallee);
+        const member = getMemberName(expression);
+        return params && member ? [...params, ['member', member]] : null;
+    }
+    if (expression.type === 'CallExpression') {
+        const call = expression;
+        const params = buildCalleeParams(call.callee, code, loc, filename, expressionValues, collapseQualifiedCallee);
+        if (!params) {
+            return null;
+        }
+        const callValues = call.arguments
+            .filter((arg) => arg.type !== 'SpreadElement')
+            .map((arg) => shiftExpressionValue(expressionValues, arg, code, loc, filename));
+        return [...params, ['call', ...callValues]];
+    }
+    return null;
+};
+export const buildParams = (usage, code, loc, filename, expressionValues, collapseQualifiedCallee) => {
+    const params = buildCalleeParams(usage.callee, code, loc, filename, expressionValues, collapseQualifiedCallee);
+    if (!params) {
+        return null;
+    }
+    if (usage.kind === 'template') {
+        return [
+            ...params,
+            zipTemplate(usage.target, code, loc, filename, expressionValues),
+        ];
+    }
+    const callValues = usage.target.arguments
+        .filter((arg) => arg.type !== 'SpreadElement')
+        .map((arg) => shiftExpressionValue(expressionValues, arg, code, loc, filename));
+    return [...params, ['call', ...callValues]];
+};

package/types/utils/applyOxcProcessors/processorFactory.d.ts

@@ -0,0 +1,7 @@
+import type { Expression as ProcessorExpression, IFileContext, Params } from '@wyw-in-js/processor-utils';
+import type { StrictOptions } from '@wyw-in-js/shared';
+import type { Expression, Node } from 'oxc-parser';
+import type { CreatedProcessor, DefinedProcessor, LocationLookup, Replacement } from './types';
+export declare const isReplacementPure: (replacement: ProcessorExpression) => boolean;
+export declare const shouldCollectStaticExpressionValues: (options: Pick<StrictOptions, "eval">) => boolean;
+export declare const createProcessor: (definedProcessor: DefinedProcessor, params: Params, target: Expression, replacementTarget: Expression, ancestors: Node[], fileContext: IFileContext, options: Pick<StrictOptions, "classNameSlug" | "displayName" | "extensions" | "tagResolver">, code: string, loc: LocationLookup, idx: number, isReferenced: boolean, usedNames: Set<string>, replacements: Replacement[]) => CreatedProcessor | null;

package/types/utils/applyOxcProcessors/processorFactory.js

@@ -0,0 +1,70 @@
+import { BaseProcessor, expressionToCode } from '@wyw-in-js/processor-utils';
+import { createOxcAstService } from '../oxcAstService';
+import { buildOxcCodeFrameError } from '../oxc/sourceLocations';
+import { getDisplayName } from './displayName';
+import { getRootIdentifier } from './processorUsages';
+import { getSourceLocation } from './shared';
+let didWarnSkipSymbolMismatch = false;
+export const isReplacementPure = (replacement) => replacement.type === 'CallExpression';
+export const shouldCollectStaticExpressionValues = (options) => (options.eval?.strategy ?? 'hybrid') !== 'execute';
+export const createProcessor = (definedProcessor, params, target, replacementTarget, ancestors, fileContext, options, code, loc, idx, isReferenced, usedNames, replacements) => {
+    const [Processor, tagSource] = definedProcessor;
+    const astService = createOxcAstService(usedNames);
+    const replacer = (replacement, isPure) => {
+        const next = typeof replacement === 'function' ? replacement(target) : replacement;
+        const replacementCode = expressionToCode(next);
+        replacements.push({
+            start: replacementTarget.start,
+            end: replacementTarget.end,
+            value: isPure && isReplacementPure(next)
+                ? `/*#__PURE__*/${replacementCode}`
+                : replacementCode,
+        });
+    };
+    try {
+        let displayName;
+        try {
+            displayName = getDisplayName(ancestors, idx, code, fileContext.filename);
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                error.message.startsWith("Couldn't determine a name for the component")) {
+                let displayNameNode = target;
+                if (target.type === 'TaggedTemplateExpression') {
+                    displayNameNode = target.tag;
+                }
+                else if (target.type === 'CallExpression') {
+                    displayNameNode = target.callee;
+                }
+                const pointerNode = displayNameNode.type === 'MemberExpression'
+                    ? getRootIdentifier(displayNameNode) ?? displayNameNode
+                    : displayNameNode;
+                throw buildOxcCodeFrameError(code, getSourceLocation(pointerNode.start, pointerNode.end, loc, fileContext.filename), error.message);
+            }
+            throw error;
+        }
+        return {
+            astService,
+            processor: new Processor(params, tagSource, astService, getSourceLocation(target.start, target.end, loc, fileContext.filename), replacer, displayName, isReferenced, idx, options, fileContext),
+        };
+    }
+    catch (e) {
+        if (e === BaseProcessor.SKIP) {
+            return null;
+        }
+        if (typeof e === 'symbol' &&
+            e.description === BaseProcessor.SKIP.description) {
+            if (!didWarnSkipSymbolMismatch) {
+                didWarnSkipSymbolMismatch = true;
+                // eslint-disable-next-line no-console
+                console.warn([
+                    "[wyw-in-js] Processor threw Symbol('skip') that does not match BaseProcessor.SKIP identity.",
+                    'This usually means duplicate copies of @wyw-in-js/processor-utils (or the processor) are bundled/installed.',
+                    'Consider deduping dependencies to avoid subtle issues (instanceof checks, sentinels, etc).',
+                ].join('\n'));
+            }
+            return null;
+        }
+        throw e;
+    }
+};

package/types/utils/applyOxcProcessors/processorUsages.d.ts

@@ -0,0 +1,16 @@
+import type { Expression, MemberExpression, Node, Program } from 'oxc-parser';
+import type { DefinedProcessor, ExpressionSpan, OxcIdentifier, ProcessorUsage } from './types';
+export declare const getMemberName: (node: MemberExpression) => string | null;
+export declare const unwrapQualifiedExpression: (node: Expression) => Expression;
+export declare const getRootIdentifier: (node: Expression) => OxcIdentifier | null;
+export declare const getQualifiedName: (node: Expression) => string | null;
+export declare const resolveDefinedProcessor: (callee: Expression, definedProcessors: Map<string, DefinedProcessor>) => {
+    collapseQualifiedCallee: boolean;
+    definedProcessor: DefinedProcessor;
+} | null;
+export declare const isCallTagOfTaggedTemplate: (node: Node, parent: Node | null) => boolean;
+export declare const expandReplacementTarget: (target: Expression, ancestors: Node[]) => Expression;
+export declare const collectProcessorUsages: (program: Program, definedProcessors: Map<string, DefinedProcessor>) => ProcessorUsage[];
+export declare const expressionSpan: (expression: Expression) => ExpressionSpan;
+export declare const collectCallArgumentSpans: (node: Expression) => ExpressionSpan[];
+export declare const collectUsageExpressionSpans: (usage: ProcessorUsage) => ExpressionSpan[];

package/types/utils/applyOxcProcessors/processorUsages.js

@@ -0,0 +1,163 @@
+import { getOxcNodeChildren } from '../oxc/ast';
+export const getMemberName = (node) => {
+    if (node.computed) {
+        return node.property.type === 'Literal' &&
+            typeof node.property.value === 'string'
+            ? node.property.value
+            : null;
+    }
+    return node.property.type === 'Identifier' ? node.property.name : null;
+};
+export const unwrapQualifiedExpression = (node) => {
+    if (node.type === 'TSAsExpression' ||
+        node.type === 'TSSatisfiesExpression' ||
+        node.type === 'TSNonNullExpression' ||
+        node.type === 'TSTypeAssertion' ||
+        node.type === 'ParenthesizedExpression') {
+        return unwrapQualifiedExpression(node.expression);
+    }
+    if (node.type === 'SequenceExpression') {
+        const sequence = node;
+        return unwrapQualifiedExpression(sequence.expressions[sequence.expressions.length - 1] ?? node);
+    }
+    return node;
+};
+export const getRootIdentifier = (node) => {
+    const expression = unwrapQualifiedExpression(node);
+    if (expression.type === 'Identifier') {
+        return expression;
+    }
+    if (expression.type === 'MemberExpression') {
+        return getRootIdentifier(expression.object);
+    }
+    if (expression.type === 'CallExpression') {
+        return getRootIdentifier(expression.callee);
+    }
+    return null;
+};
+export const getQualifiedName = (node) => {
+    const expression = unwrapQualifiedExpression(node);
+    if (expression.type === 'Identifier') {
+        return expression.name;
+    }
+    if (expression.type === 'MemberExpression') {
+        const object = getQualifiedName(expression.object);
+        const member = getMemberName(expression);
+        return object && member ? `${object}.${member}` : null;
+    }
+    if (expression.type === 'CallExpression') {
+        return getQualifiedName(expression.callee);
+    }
+    return null;
+};
+export const resolveDefinedProcessor = (callee, definedProcessors) => {
+    const qualified = getQualifiedName(callee);
+    if (qualified) {
+        const definedProcessor = definedProcessors.get(qualified);
+        if (definedProcessor) {
+            return {
+                collapseQualifiedCallee: qualified.includes('.'),
+                definedProcessor,
+            };
+        }
+    }
+    const root = getRootIdentifier(callee);
+    if (!root) {
+        return null;
+    }
+    const definedProcessor = definedProcessors.get(root.name);
+    return definedProcessor
+        ? {
+            collapseQualifiedCallee: false,
+            definedProcessor,
+        }
+        : null;
+};
+export const isCallTagOfTaggedTemplate = (node, parent) => parent?.type === 'TaggedTemplateExpression' && parent.tag === node;
+export const expandReplacementTarget = (target, ancestors) => {
+    let current = target;
+    for (let idx = ancestors.length - 1; idx >= 0; idx -= 1) {
+        const ancestor = ancestors[idx];
+        if (ancestor.type === 'SequenceExpression' &&
+            ancestor.expressions[ancestor.expressions.length - 1] === current) {
+            current = ancestor;
+        }
+        else if (ancestor.type === 'ParenthesizedExpression' &&
+            ancestor.expression === current) {
+            current = ancestor;
+        }
+        else {
+            break;
+        }
+    }
+    return current;
+};
+export const collectProcessorUsages = (program, definedProcessors) => {
+    const usages = [];
+    const walk = (node, ancestors, parent = null) => {
+        if (node.type === 'TaggedTemplateExpression') {
+            const callee = node.tag;
+            const resolvedProcessor = resolveDefinedProcessor(callee, definedProcessors);
+            if (resolvedProcessor) {
+                usages.push({
+                    ancestors,
+                    callee,
+                    collapseQualifiedCallee: resolvedProcessor.collapseQualifiedCallee,
+                    definedProcessor: resolvedProcessor.definedProcessor,
+                    kind: 'template',
+                    replacementTarget: expandReplacementTarget(node, ancestors),
+                    target: node,
+                });
+            }
+        }
+        else if (node.type === 'CallExpression' &&
+            !isCallTagOfTaggedTemplate(node, parent)) {
+            const { callee } = node;
+            const resolvedProcessor = resolveDefinedProcessor(callee, definedProcessors);
+            if (resolvedProcessor) {
+                usages.push({
+                    ancestors,
+                    callee,
+                    collapseQualifiedCallee: resolvedProcessor.collapseQualifiedCallee,
+                    definedProcessor: resolvedProcessor.definedProcessor,
+                    kind: 'call',
+                    replacementTarget: expandReplacementTarget(node, ancestors),
+                    target: node,
+                });
+            }
+        }
+        getOxcNodeChildren(node).forEach((child) => walk(child, [...ancestors, node], node));
+    };
+    walk(program, []);
+    return usages.sort((a, b) => a.target.start - b.target.start);
+};
+export const expressionSpan = (expression) => ({
+    end: expression.end,
+    start: expression.start,
+});
+export const collectCallArgumentSpans = (node) => {
+    const expression = unwrapQualifiedExpression(node);
+    if (expression.type === 'CallExpression') {
+        const call = expression;
+        const calleeSpans = collectCallArgumentSpans(call.callee);
+        const argumentSpans = call.arguments.flatMap((arg) => arg.type === 'SpreadElement' ? [] : [expressionSpan(arg)]);
+        return [...calleeSpans, ...argumentSpans];
+    }
+    if (expression.type === 'MemberExpression') {
+        return collectCallArgumentSpans(expression.object);
+    }
+    return [];
+};
+export const collectUsageExpressionSpans = (usage) => {
+    const calleeSpans = collectCallArgumentSpans(usage.callee);
+    if (usage.kind === 'template') {
+        return [
+            ...calleeSpans,
+            ...usage.target.quasi.expressions.map((expression) => expressionSpan(expression)),
+        ];
+    }
+    return [
+        ...calleeSpans,
+        ...usage.target.arguments.flatMap((arg) => arg.type === 'SpreadElement' ? [] : [expressionSpan(arg)]),
+    ];
+};

package/types/utils/applyOxcProcessors/sameFileStaticValues.d.ts

@@ -0,0 +1,23 @@
+import type { BaseProcessor } from '@wyw-in-js/processor-utils';
+import type { ExpressionValue } from '@wyw-in-js/shared';
+import type { Node } from 'oxc-parser';
+import type { OxcStaticValueCandidate } from '../collectOxcTemplateDependencies';
+import { type UnknownProcessorStaticValue } from '../processorStaticSemantics';
+import type { SameFileProcessorObject } from './types';
+export declare const oxcLiteralValue: (expression: Node) => unknown | UnknownProcessorStaticValue;
+export declare const oxcPropertyKeyName: (key: Node) => string | null;
+export declare const collectStaticObjectPropertyNames: (objectExpression: Node) => Set<string> | null;
+export declare const getSameFileProcessorObjectProperty: (ancestors: Node[]) => {
+    localName: string;
+    propertyName: string;
+    propertyNames: Set<string>;
+} | null;
+export declare const createSameFileProcessorStaticValueResolver: (processorsByLocal: Map<string, BaseProcessor>, expressionValues: Omit<ExpressionValue, "buildCodeFrameError">[]) => {
+    resolveLocal: (local: string) => unknown | UnknownProcessorStaticValue;
+    resolveProcessor: (processor: BaseProcessor) => unknown | UnknownProcessorStaticValue;
+};
+export declare const collectSameFileProcessorStaticValuesByLocal: (processorsByLocal: Map<string, BaseProcessor>, expressionValues: Omit<ExpressionValue, "buildCodeFrameError">[]) => Map<string, unknown>;
+export declare const collectSameFileProcessorObjectStaticValuesByLocal: (processorObjectsByLocal: Map<string, SameFileProcessorObject>, processorsByLocal: Map<string, BaseProcessor>, expressionValues: Omit<ExpressionValue, "buildCodeFrameError">[]) => Map<string, unknown>;
+export declare const collectWYWMetaExtendsHelperNames: (code: string) => Set<string>;
+export declare const collectCandidateInlineConstants: (candidate: OxcStaticValueCandidate, processorStaticValuesByLocal: Map<string, unknown>) => Record<string, unknown> | null;
+export declare const addCandidateInlineConstants: (candidates: OxcStaticValueCandidate[], processorStaticValuesByLocal: Map<string, unknown>) => OxcStaticValueCandidate[];