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

package/types/utils/applyOxcProcessors/applyOxcProcessors.js

@@ -0,0 +1,167 @@
+import { collectOxcProcessorImportsFromProgram } from '../collectOxcExportsAndImports';
+import { collectOxcExpressionDependencies } from '../collectOxcTemplateDependencies';
+import { EventEmitter } from '../EventEmitter';
+import { isOxcNode } from '../oxc/ast';
+import { applyOxcReplacements } from '../oxc/replacements';
+import { buildOxcCodeFrameError, createOxcLocationLookup, } from '../oxc/sourceLocations';
+import { getProcessorForImport } from '../processorLookup';
+import { resolveProcessorStaticClassName } from '../processorStaticSemantics';
+import { collectUsedNames } from './cleanupBindings';
+import { addCandidateInlineConstants, collectSameFileProcessorObjectStaticValuesByLocal, collectSameFileProcessorStaticValuesByLocal, collectWYWMetaExtendsHelperNames, getSameFileProcessorObjectProperty, } from './sameFileStaticValues';
+import { collectSameFileProcessorStaticValues, getTagOwner, isTagReferenced, } from './displayName';
+import { buildParams } from './expressionValues';
+import { createProcessor, shouldCollectStaticExpressionValues, } from './processorFactory';
+import { collectProcessorUsages, collectUsageExpressionSpans, } from './processorUsages';
+import { removeUnusedAfterReplacement } from './cleanupRemovals';
+import { insertAddedImports, parseOxc } from './shared';
+export const applyOxcProcessors = (code, fileContext, options, callback, cleanupUnused = false) => {
+    const filename = fileContext.filename ?? 'unknown.js';
+    const eventEmitter = options.eventEmitter ?? EventEmitter.dummy;
+    const collectStaticExpressionValues = shouldCollectStaticExpressionValues(options);
+    let workingCode = code;
+    let program = parseOxc(workingCode, filename);
+    const definedProcessors = new Map();
+    const removableImportLocals = new Set();
+    const removableExpressionRefs = new Set();
+    eventEmitter.perf('transform:preeval:processTemplate:imports', () => {
+        const imports = eventEmitter.perf('transform:preeval:processTemplate:imports:analysis', () => collectOxcProcessorImportsFromProgram(program, workingCode));
+        eventEmitter.perf('transform:preeval:processTemplate:imports:lookup', () => {
+            imports.forEach((item) => {
+                const localName = item.local.name ?? item.local.code;
+                if (item.imported === 'side-effect' || !localName) {
+                    return;
+                }
+                const [processor, tagSource] = getProcessorForImport({
+                    imported: item.imported,
+                    source: item.source,
+                }, filename, options);
+                if (processor) {
+                    definedProcessors.set(localName, [processor, tagSource]);
+                    removableImportLocals.add(localName);
+                    const rootLocalName = localName.split('.')[0];
+                    if (rootLocalName) {
+                        removableImportLocals.add(rootLocalName);
+                    }
+                }
+            });
+        });
+    });
+    if (definedProcessors.size === 0) {
+        return {
+            code: workingCode,
+            processorClassNamesByLocal: new Map(),
+            processors: [],
+            staticValueCandidates: [],
+            staticValues: [],
+        };
+    }
+    let processorUsages = eventEmitter.perf('transform:preeval:processTemplate:usages', () => collectProcessorUsages(program, definedProcessors));
+    if (processorUsages.length === 0) {
+        return {
+            code: workingCode,
+            processorClassNamesByLocal: new Map(),
+            processors: [],
+            staticValueCandidates: [],
+            staticValues: [],
+        };
+    }
+    const targetExpressionSpans = processorUsages.flatMap(collectUsageExpressionSpans);
+    const extracted = targetExpressionSpans.length > 0
+        ? eventEmitter.perf('transform:preeval:processTemplate:deps', () => collectOxcExpressionDependencies(workingCode, filename, collectStaticExpressionValues, targetExpressionSpans, options.staticBindings))
+        : {
+            code: workingCode,
+            dependencyNames: [],
+            expressionValues: [],
+            staticValueCandidates: [],
+            staticValues: [],
+        };
+    if (extracted.code !== workingCode) {
+        workingCode = extracted.code;
+        program = eventEmitter.perf('transform:preeval:processTemplate:reparse', () => parseOxc(workingCode, filename));
+        processorUsages = eventEmitter.perf('transform:preeval:processTemplate:usages', () => collectProcessorUsages(program, definedProcessors));
+    }
+    const templateExpressionValues = extracted.expressionValues.map((value) => ({
+        ...value,
+        buildCodeFrameError: (message) => buildOxcCodeFrameError(code, value.ex.loc, message),
+    }));
+    const loc = createOxcLocationLookup(workingCode);
+    const usedNames = eventEmitter.perf('transform:preeval:processTemplate:usedNames', () => collectUsedNames(program));
+    const addedImports = [];
+    const replacements = [];
+    const processors = [];
+    const processorClassNamesByLocal = new Map();
+    const sameFileProcessorsByLocal = new Map();
+    const sameFileProcessorObjectsByLocal = new Map();
+    extracted.dependencyNames.forEach((name) => removableImportLocals.add(name));
+    eventEmitter.perf('transform:preeval:processTemplate:processors', () => {
+        processorUsages.forEach((usage, idx) => {
+            const params = buildParams(usage, workingCode, loc, filename, templateExpressionValues, usage.collapseQualifiedCallee);
+            if (!params) {
+                return;
+            }
+            const created = createProcessor(usage.definedProcessor, params, usage.target, usage.replacementTarget, usage.ancestors, fileContext, options, workingCode, loc, idx, isTagReferenced(program, usage.ancestors), usedNames, replacements);
+            if (!created) {
+                return;
+            }
+            const { astService, processor } = created;
+            const owner = getTagOwner(usage.ancestors);
+            if (owner?.type === 'VariableDeclarator') {
+                const { id } = owner;
+                if (isOxcNode(id) && id.type === 'Identifier') {
+                    removableExpressionRefs.add(id.name);
+                    sameFileProcessorsByLocal.set(id.name, processor);
+                    // Cross-file map (used as a className-only fallback in
+                    // resolveStaticExport) is restricted to processors whose
+                    // runtime value IS the className string. Styled-component
+                    // bindings emit a richer value and must reach consumers via
+                    // resolveProcessorStaticExport so composition still works.
+                    const staticClassName = resolveProcessorStaticClassName(processor);
+                    if (staticClassName) {
+                        processorClassNamesByLocal.set(id.name, staticClassName);
+                    }
+                    else {
+                        const replacement = processor.value;
+                        if ((replacement?.type === 'StringLiteral' ||
+                            replacement?.type === 'Literal') &&
+                            typeof replacement.value === 'string') {
+                            processorClassNamesByLocal.set(id.name, processor.className);
+                        }
+                    }
+                }
+            }
+            const objectProperty = getSameFileProcessorObjectProperty(usage.ancestors);
+            if (objectProperty) {
+                const existing = sameFileProcessorObjectsByLocal.get(objectProperty.localName);
+                const object = existing ?? {
+                    properties: new Map(),
+                    propertyNames: objectProperty.propertyNames,
+                };
+                object.properties.set(objectProperty.propertyName, processor);
+                sameFileProcessorObjectsByLocal.set(objectProperty.localName, object);
+            }
+            processors.push(processor);
+            callback(processor);
+            addedImports.push(...astService.getAddedImports());
+        });
+    });
+    const sameFileProcessorStaticValuesByLocal = collectSameFileProcessorStaticValuesByLocal(sameFileProcessorsByLocal, extracted.expressionValues);
+    const sameFileProcessorObjectStaticValuesByLocal = collectSameFileProcessorObjectStaticValuesByLocal(sameFileProcessorObjectsByLocal, sameFileProcessorsByLocal, extracted.expressionValues);
+    sameFileProcessorObjectStaticValuesByLocal.forEach((value, local) => {
+        sameFileProcessorStaticValuesByLocal.set(local, value);
+    });
+    const replacedCode = applyOxcReplacements(workingCode, replacements);
+    const metadataExtendsHelperNames = collectWYWMetaExtendsHelperNames(replacedCode);
+    const staticValueCandidates = extracted.staticValueCandidates.filter((candidate) => candidate.imports.length > 0 ||
+        !metadataExtendsHelperNames.has(candidate.name));
+    const sameFileProcessorStaticValues = collectSameFileProcessorStaticValues(extracted.expressionValues, sameFileProcessorStaticValuesByLocal);
+    const codeWithAddedImports = insertAddedImports(replacedCode, program, addedImports);
+    return {
+        code: cleanupUnused
+            ? eventEmitter.perf('transform:preeval:processTemplate:cleanup', () => removeUnusedAfterReplacement(codeWithAddedImports, filename, removableImportLocals, new Set([...removableExpressionRefs, ...extracted.dependencyNames]), options.preserveSideEffectImportLocals ?? new Set()))
+            : codeWithAddedImports,
+        processorClassNamesByLocal,
+        processors,
+        staticValueCandidates: addCandidateInlineConstants(staticValueCandidates, sameFileProcessorStaticValuesByLocal),
+        staticValues: [...extracted.staticValues, ...sameFileProcessorStaticValues],
+    };
+};

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

@@ -0,0 +1,12 @@
+import type { Node, Program } from 'oxc-parser';
+import type { TopLevelStatementInfo } from './types';
+export declare const collectUsedNames: (program: Program) => Set<string>;
+export declare const isNodeReference: (node: Node, parent: Node | null) => boolean;
+export declare const collectReferencedNames: (root: Node) => Set<string>;
+export declare const collectImportLocalNames: (node: Node) => string[];
+export declare const getImportSpecifierLocalName: (node: Node) => string | null;
+export declare const collectDeclaredNames: (node: Node) => string[];
+export declare const collectTopLevelBindings: (statement: Node) => Set<string>;
+export declare const collectTopLevelStatementInfos: (program: Program) => TopLevelStatementInfo[];
+export declare const collectTopLevelBindingsFromStatements: (statements: TopLevelStatementInfo[]) => Set<string>;
+export declare const collectRemovableNamesFromStatements: (statements: TopLevelStatementInfo[], initialNames: Set<string>) => Set<string>;

package/types/utils/applyOxcProcessors/cleanupBindings.js

@@ -0,0 +1,189 @@
+/* eslint-disable no-restricted-syntax */
+import { isNotNull } from '../isNotNull';
+import { getOxcNodeChildren, isOxcNode, walkOxc } from '../oxc/ast';
+export const collectUsedNames = (program) => {
+    const names = new Set();
+    walkOxc(program, (node) => {
+        if (node.type === 'Identifier') {
+            names.add(node.name);
+        }
+    });
+    return names;
+};
+export const isNodeReference = (node, parent) => {
+    if (node.type === 'Identifier') {
+        const parentRecord = parent;
+        if (!parentRecord) {
+            return true;
+        }
+        if (parent?.type === 'ImportDeclaration' ||
+            parent?.type === 'ImportSpecifier' ||
+            parent?.type === 'ImportDefaultSpecifier' ||
+            parent?.type === 'ImportNamespaceSpecifier') {
+            return false;
+        }
+        if (parent?.type === 'MemberExpression' &&
+            parentRecord.property === node &&
+            !parentRecord.computed) {
+            return false;
+        }
+        if ((parent?.type === 'VariableDeclarator' ||
+            parent?.type === 'FunctionDeclaration' ||
+            parent?.type === 'ClassDeclaration' ||
+            parent?.type === 'ClassExpression') &&
+            parentRecord.id === node) {
+            return false;
+        }
+        if ((parent?.type === 'PropertyDefinition' ||
+            parent?.type === 'MethodDefinition') &&
+            parentRecord.key === node &&
+            !parentRecord.computed) {
+            return false;
+        }
+        if (parent?.type === 'Property' &&
+            parentRecord.key === node &&
+            parentRecord.value !== node &&
+            !parentRecord.computed) {
+            return false;
+        }
+        return true;
+    }
+    if (node.type === 'JSXIdentifier') {
+        const parentRecord = parent;
+        if (parent?.type === 'JSXAttribute' && parentRecord?.name === node) {
+            return false;
+        }
+        return true;
+    }
+    return false;
+};
+export const collectReferencedNames = (root) => {
+    const names = new Set();
+    const walk = (node, parent = null) => {
+        if (node.type === 'ImportDeclaration') {
+            return;
+        }
+        if (isNodeReference(node, parent) &&
+            'name' in node &&
+            typeof node.name === 'string') {
+            names.add(node.name);
+        }
+        getOxcNodeChildren(node).forEach((child) => walk(child, node));
+    };
+    walk(root);
+    return names;
+};
+export const collectImportLocalNames = (node) => {
+    if (node.type !== 'ImportDeclaration') {
+        return [];
+    }
+    const { specifiers } = node;
+    if (!Array.isArray(specifiers)) {
+        return [];
+    }
+    return specifiers
+        .map((specifier) => {
+        const { local } = specifier;
+        return isOxcNode(local) &&
+            'name' in local &&
+            typeof local.name === 'string'
+            ? local.name
+            : null;
+    })
+        .filter(isNotNull);
+};
+export const getImportSpecifierLocalName = (node) => {
+    const { local } = node;
+    return isOxcNode(local) && 'name' in local && typeof local.name === 'string'
+        ? local.name
+        : null;
+};
+export const collectDeclaredNames = (node) => {
+    if (node.type === 'Identifier') {
+        return [node.name];
+    }
+    if (node.type === 'RestElement') {
+        return collectDeclaredNames(node.argument);
+    }
+    if (node.type === 'AssignmentPattern') {
+        return collectDeclaredNames(node.left);
+    }
+    if (node.type === 'ObjectPattern') {
+        return node.properties.flatMap((property) => property.type === 'RestElement'
+            ? collectDeclaredNames(property.argument)
+            : collectDeclaredNames(property.value));
+    }
+    if (node.type === 'ArrayPattern') {
+        return node.elements.flatMap((element) => element ? collectDeclaredNames(element) : []);
+    }
+    if (node.type === 'TSParameterProperty') {
+        return collectDeclaredNames(node.parameter);
+    }
+    return [];
+};
+export const collectTopLevelBindings = (statement) => {
+    const bindings = new Set();
+    if (statement.type === 'ImportDeclaration') {
+        collectImportLocalNames(statement).forEach((name) => bindings.add(name));
+        return bindings;
+    }
+    if (statement.type === 'VariableDeclaration') {
+        const { declarations } = statement;
+        if (!Array.isArray(declarations)) {
+            return bindings;
+        }
+        declarations.forEach((declarator) => {
+            const { id } = declarator;
+            if (isOxcNode(id)) {
+                collectDeclaredNames(id).forEach((name) => bindings.add(name));
+            }
+        });
+        return bindings;
+    }
+    if ((statement.type === 'FunctionDeclaration' ||
+        statement.type === 'ClassDeclaration' ||
+        statement.type === 'TSEnumDeclaration') &&
+        'id' in statement) {
+        const { id } = statement;
+        if (isOxcNode(id) && id.type === 'Identifier') {
+            bindings.add(id.name);
+        }
+        return bindings;
+    }
+    if (statement.type === 'ExportNamedDeclaration') {
+        const { declaration } = statement;
+        return isOxcNode(declaration)
+            ? collectTopLevelBindings(declaration)
+            : bindings;
+    }
+    return bindings;
+};
+export const collectTopLevelStatementInfos = (program) => program.body.map((statement) => ({
+    bindings: collectTopLevelBindings(statement),
+    node: statement,
+    references: collectReferencedNames(statement),
+}));
+export const collectTopLevelBindingsFromStatements = (statements) => new Set(statements.flatMap((statement) => [...statement.bindings]));
+export const collectRemovableNamesFromStatements = (statements, initialNames) => {
+    const removable = new Set(initialNames);
+    const bindingToStatement = new Map();
+    statements.forEach((statement) => {
+        statement.bindings.forEach((name) => {
+            bindingToStatement.set(name, statement);
+        });
+    });
+    const queue = [...removable];
+    while (queue.length > 0) {
+        const name = queue.shift();
+        const statement = bindingToStatement.get(name);
+        if (statement) {
+            statement.references.forEach((reference) => {
+                if (bindingToStatement.has(reference) && !removable.has(reference)) {
+                    removable.add(reference);
+                    queue.push(reference);
+                }
+            });
+        }
+    }
+    return removable;
+};

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

@@ -0,0 +1,16 @@
+import type { Program } from 'oxc-parser';
+import type { Replacement, ScopedBindingInfo, ScopedCleanupScope, TopLevelStatementInfo } from './types';
+export declare const createScopedCleanupScope: (parent: ScopedCleanupScope | null) => ScopedCleanupScope;
+export declare const resolveScopedBinding: (scope: ScopedCleanupScope, name: string) => string | null;
+export declare const collectScopedBindingInfos: (program: Program) => Map<string, ScopedBindingInfo>;
+export declare const collectScopedRemovableBindingIds: (bindings: Map<string, ScopedBindingInfo>, initialNames: Set<string>) => Set<string>;
+export declare function expandImportRemovalRange(code: string, start: number, end: number): Replacement;
+export declare const collectUnusedScopedDeclarationRemovals: (code: string, bindings: Map<string, ScopedBindingInfo>, initialRemovableNames: Set<string>) => Replacement[];
+export declare const expandImportSpecifierRemovalRange: (code: string, start: number, end: number) => Replacement;
+export declare const mergeEmptyRemovalRanges: (removals: Replacement[]) => Replacement[];
+export declare const collectUnusedImportRemovals: (code: string, program: Program, referencedNames: Set<string>, removableNames: Set<string>, preserveSideEffectImportLocals: Set<string>) => Replacement[];
+export declare const collectUnusedTopLevelDeclarationRemovals: (code: string, program: Program, referencedNames: Set<string>, removableNames: Set<string>) => Replacement[];
+export declare const collectUnusedGeneratedHelperDeclarationRemovals: (code: string, program: Program, referencedNames: Set<string>) => Replacement[];
+export declare const collectTopLevelExpressionStatementRemovals: (code: string, statements: TopLevelStatementInfo[], topLevelBindings: Set<string>, removableExpressionRefs: Set<string>) => Replacement[];
+export declare const collectEmptyTopLevelBlockRemovals: (code: string, program: Program) => Replacement[];
+export declare const removeUnusedAfterReplacement: (code: string, filename: string, initialRemovableNames: Set<string>, removableExpressionRefs: Set<string>, preserveSideEffectImportLocals: Set<string>) => string;