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

package/types/utils/applyOxcProcessors/sameFileStaticValues.js

@@ -0,0 +1,211 @@
+/* eslint-disable no-restricted-syntax */
+import { isOxcNode } from '../oxc/ast';
+import { processorExpressionToStaticValue, resolveProcessorStaticRuntimeValue, unknownProcessorStaticValue, } from '../processorStaticSemantics';
+import { GENERATED_HELPER_NAME_RE, JS_IDENTIFIER_RE, WYW_META_EXTENDS_HELPER_RE, } from './shared';
+export const oxcLiteralValue = (expression) => {
+    const expressionWithValue = expression;
+    const expressionType = expression.type;
+    if (expressionType === 'StringLiteral' ||
+        expressionType === 'NumericLiteral' ||
+        expressionType === 'BooleanLiteral' ||
+        expressionType === 'Literal') {
+        return expressionWithValue.value;
+    }
+    if (expressionType === 'NullLiteral') {
+        return null;
+    }
+    return unknownProcessorStaticValue;
+};
+export const oxcPropertyKeyName = (key) => {
+    if (key.type === 'Identifier') {
+        return key.name;
+    }
+    const value = oxcLiteralValue(key);
+    return typeof value === 'string' ? value : null;
+};
+export const collectStaticObjectPropertyNames = (objectExpression) => {
+    if (objectExpression.type !== 'ObjectExpression') {
+        return null;
+    }
+    const { properties } = objectExpression;
+    if (!properties) {
+        return null;
+    }
+    const names = new Set();
+    for (const property of properties) {
+        const propertyType = property.type;
+        if (propertyType !== 'ObjectProperty' && propertyType !== 'Property') {
+            return null;
+        }
+        if (!property.key || !property.value) {
+            return null;
+        }
+        const name = oxcPropertyKeyName(property.key);
+        if (!name || names.has(name)) {
+            return null;
+        }
+        names.add(name);
+    }
+    return names;
+};
+export const getSameFileProcessorObjectProperty = (ancestors) => {
+    let propertyIndex = -1;
+    for (let idx = ancestors.length - 1; idx >= 0; idx -= 1) {
+        if (ancestors[idx].type === 'Property') {
+            propertyIndex = idx;
+            break;
+        }
+    }
+    if (propertyIndex <= 0) {
+        return null;
+    }
+    const property = ancestors[propertyIndex];
+    const objectExpression = ancestors[propertyIndex - 1];
+    if (!property.key || objectExpression.type !== 'ObjectExpression') {
+        return null;
+    }
+    const propertyName = oxcPropertyKeyName(property.key);
+    const propertyNames = collectStaticObjectPropertyNames(objectExpression);
+    if (!propertyName || !propertyNames) {
+        return null;
+    }
+    for (let idx = propertyIndex - 2; idx >= 0; idx -= 1) {
+        const ancestor = ancestors[idx];
+        if (ancestor.type === 'VariableDeclarator') {
+            const { id, init } = ancestor;
+            if (isOxcNode(id) &&
+                id.type === 'Identifier' &&
+                init === objectExpression) {
+                return {
+                    localName: id.name,
+                    propertyName,
+                    propertyNames,
+                };
+            }
+        }
+    }
+    return null;
+};
+export const createSameFileProcessorStaticValueResolver = (processorsByLocal, expressionValues) => {
+    const expressionSourceByName = new Map();
+    expressionValues.forEach((value) => {
+        if (value.ex.type === 'Identifier') {
+            expressionSourceByName.set(value.ex.name, value.source);
+        }
+    });
+    const memo = new Map();
+    const resolving = new Set();
+    function resolveLocal(local) {
+        if (memo.has(local)) {
+            return memo.get(local);
+        }
+        const processor = processorsByLocal.get(local);
+        if (!processor || resolving.has(local)) {
+            return unknownProcessorStaticValue;
+        }
+        resolving.add(local);
+        const contractValue = resolveProcessorStaticRuntimeValue(processor);
+        const value = contractValue !== unknownProcessorStaticValue
+            ? contractValue
+            : processorExpressionToStaticValue(processor.value, (helperName) => {
+                const source = expressionSourceByName.get(helperName);
+                return source ? resolveLocal(source) : unknownProcessorStaticValue;
+            });
+        resolving.delete(local);
+        memo.set(local, value);
+        return value;
+    }
+    function resolveProcessor(processor) {
+        const contractValue = resolveProcessorStaticRuntimeValue(processor);
+        if (contractValue !== unknownProcessorStaticValue) {
+            return contractValue;
+        }
+        return processorExpressionToStaticValue(processor.value, (helperName) => {
+            const source = expressionSourceByName.get(helperName);
+            return source ? resolveLocal(source) : unknownProcessorStaticValue;
+        });
+    }
+    return { resolveLocal, resolveProcessor };
+};
+export const collectSameFileProcessorStaticValuesByLocal = (processorsByLocal, expressionValues) => {
+    const { resolveLocal } = createSameFileProcessorStaticValueResolver(processorsByLocal, expressionValues);
+    const result = new Map();
+    processorsByLocal.forEach((_processor, local) => {
+        const value = resolveLocal(local);
+        if (value !== unknownProcessorStaticValue) {
+            result.set(local, value);
+        }
+    });
+    return result;
+};
+export const collectSameFileProcessorObjectStaticValuesByLocal = (processorObjectsByLocal, processorsByLocal, expressionValues) => {
+    const { resolveProcessor } = createSameFileProcessorStaticValueResolver(processorsByLocal, expressionValues);
+    const result = new Map();
+    for (const [local, object] of processorObjectsByLocal) {
+        if (object.properties.size === object.propertyNames.size) {
+            const value = {};
+            let complete = true;
+            for (const propertyName of object.propertyNames) {
+                const processor = object.properties.get(propertyName);
+                if (!processor) {
+                    complete = false;
+                    break;
+                }
+                const propertyValue = resolveProcessor(processor);
+                if (propertyValue === unknownProcessorStaticValue) {
+                    complete = false;
+                    break;
+                }
+                value[propertyName] = propertyValue;
+            }
+            if (complete) {
+                result.set(local, value);
+            }
+        }
+    }
+    return result;
+};
+export const collectWYWMetaExtendsHelperNames = (code) => {
+    const names = new Set();
+    let match = WYW_META_EXTENDS_HELPER_RE.exec(code);
+    while (match) {
+        const name = match[1];
+        if (name && GENERATED_HELPER_NAME_RE.test(name)) {
+            names.add(name);
+        }
+        match = WYW_META_EXTENDS_HELPER_RE.exec(code);
+    }
+    return names;
+};
+export const collectCandidateInlineConstants = (candidate, processorStaticValuesByLocal) => {
+    const inlineConstants = {};
+    let hasInlineConstant = false;
+    let match = JS_IDENTIFIER_RE.exec(candidate.source);
+    while (match) {
+        const name = match[0];
+        if (processorStaticValuesByLocal.has(name)) {
+            inlineConstants[name] = processorStaticValuesByLocal.get(name);
+            hasInlineConstant = true;
+        }
+        match = JS_IDENTIFIER_RE.exec(candidate.source);
+    }
+    return hasInlineConstant ? inlineConstants : null;
+};
+export const addCandidateInlineConstants = (candidates, processorStaticValuesByLocal) => {
+    if (processorStaticValuesByLocal.size === 0) {
+        return candidates;
+    }
+    return candidates.map((candidate) => {
+        const inlineConstants = collectCandidateInlineConstants(candidate, processorStaticValuesByLocal);
+        if (!inlineConstants) {
+            return candidate;
+        }
+        return {
+            ...candidate,
+            inlineConstants: {
+                ...candidate.inlineConstants,
+                ...inlineConstants,
+            },
+        };
+    });
+};

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

@@ -0,0 +1,10 @@
+import type { SourceLocation } from '@wyw-in-js/processor-utils';
+import type { Program } from 'oxc-parser';
+import { type AddedImport } from '../oxcAstService';
+import { type OxcLocationLookup } from '../oxc/sourceLocations';
+export declare const GENERATED_HELPER_NAME_RE: RegExp;
+export declare const WYW_META_EXTENDS_HELPER_RE: RegExp;
+export declare const JS_IDENTIFIER_RE: RegExp;
+export declare const parseOxc: (code: string, filename: string) => Program;
+export declare const insertAddedImports: (code: string, program: Program, addedImports: AddedImport[]) => string;
+export declare const getSourceLocation: (start: number, end: number, loc: OxcLocationLookup, filename?: string | null) => SourceLocation;

package/types/utils/applyOxcProcessors/shared.js

@@ -0,0 +1,37 @@
+import { printOxcAstServiceImport } from '../oxcAstService';
+import { parseOxcProgram } from '../oxc/parse';
+import { createOxcSourceLocation, } from '../oxc/sourceLocations';
+export const GENERATED_HELPER_NAME_RE = /^_exp\d*$/;
+export const WYW_META_EXTENDS_HELPER_RE = /(?:\bextends|["']extends["'])\s*:\s*(_exp\d*)\s*\(\s*\)/g;
+export const JS_IDENTIFIER_RE = /[$A-Z_a-z][$\w]*/g;
+export const parseOxc = (code, filename) => {
+    return parseOxcProgram(code, filename, 'module');
+};
+export const insertAddedImports = (code, program, addedImports) => {
+    if (addedImports.length === 0) {
+        return code;
+    }
+    const uniqueImports = [
+        ...new Map(addedImports.map((item) => [
+            `${item.source}\0${item.imported}\0${item.local}`,
+            item,
+        ])).values(),
+    ];
+    const importBlock = uniqueImports.map(printOxcAstServiceImport).join('\n');
+    const lastImport = [...program.body]
+        .reverse()
+        .find((statement) => statement.type === 'ImportDeclaration');
+    const hashbangEnd = code.startsWith('#!')
+        ? (() => {
+            const newline = code.indexOf('\n');
+            return newline === -1 ? code.length : newline + 1;
+        })()
+        : 0;
+    const insertionPoint = lastImport?.end ?? hashbangEnd;
+    const prefix = code.slice(0, insertionPoint);
+    const suffix = code.slice(insertionPoint);
+    const leadingBreak = prefix.length > 0 && !prefix.endsWith('\n') ? '\n' : '';
+    const trailingBreak = suffix.length > 0 && !suffix.startsWith('\n') ? '\n' : '';
+    return `${prefix}${leadingBreak}${importBlock}${trailingBreak}${suffix}`;
+};
+export const getSourceLocation = (start, end, loc, filename) => createOxcSourceLocation(start, end, loc, filename);

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

@@ -0,0 +1,88 @@
+import type { BaseProcessor } from '@wyw-in-js/processor-utils';
+import type { CallExpression, Expression, Node, TaggedTemplateExpression } from 'oxc-parser';
+import type { OxcStaticValue, OxcStaticValueCandidate } from '../collectOxcTemplateDependencies';
+import type { OxcAstService } from '../oxcAstService';
+import type { OxcValueReplacement } from '../oxc/replacements';
+import type { OxcLocationLookup } from '../oxc/sourceLocations';
+import type { ProcessorClass } from '../processorLookup';
+export type DefinedProcessor = [
+    ProcessorClass,
+    {
+        imported: string;
+        source: string;
+    }
+];
+export type Replacement = OxcValueReplacement;
+export type ApplyOxcProcessorsResult = {
+    code: string;
+    processorClassNamesByLocal: Map<string, string>;
+    processors: BaseProcessor[];
+    staticValueCandidates: OxcStaticValueCandidate[];
+    staticValues: OxcStaticValue[];
+};
+export type AnyNode = Node & Record<string, unknown>;
+export type OxcIdentifier = Expression & {
+    name: string;
+    type: 'Identifier';
+};
+export type ProcessorUsage = {
+    ancestors: Node[];
+    callee: Expression;
+    collapseQualifiedCallee: boolean;
+    definedProcessor: DefinedProcessor;
+    kind: 'call';
+    replacementTarget: Expression;
+    target: CallExpression;
+} | {
+    ancestors: Node[];
+    callee: Expression;
+    collapseQualifiedCallee: boolean;
+    definedProcessor: DefinedProcessor;
+    kind: 'template';
+    replacementTarget: Expression;
+    target: TaggedTemplateExpression;
+};
+export type ExpressionSpan = {
+    end: number;
+    start: number;
+};
+export type CreatedProcessor = {
+    astService: OxcAstService;
+    processor: BaseProcessor;
+};
+export type QualifiedExpression = Expression & {
+    expressions?: Expression[];
+};
+export type CallExpressionLike = Expression & {
+    arguments: Node[];
+    callee: Expression;
+    type: 'CallExpression';
+};
+export type SequenceExpressionLike = Expression & {
+    expressions: Expression[];
+    type: 'SequenceExpression';
+};
+export type LocationLookup = OxcLocationLookup;
+export type TopLevelStatementInfo = {
+    bindings: Set<string>;
+    node: Node;
+    references: Set<string>;
+};
+export type ScopedBindingKind = 'function' | 'import' | 'param' | 'variable';
+export type ScopedBindingInfo = {
+    declaration: Node;
+    dependencies: Set<string>;
+    externalReferences: number;
+    id: string;
+    incomingFromBindings: Set<string>;
+    kind: ScopedBindingKind;
+    name: string;
+};
+export type ScopedCleanupScope = {
+    bindings: Map<string, string>;
+    parent: ScopedCleanupScope | null;
+};
+export type SameFileProcessorObject = {
+    properties: Map<string, BaseProcessor>;
+    propertyNames: Set<string>;
+};

package/types/utils/applyOxcProcessors/types.js

@@ -0,0 +1 @@
+export {};

package/types/utils/applyOxcProcessors.d.ts

@@ -1,16 +1 @@
-import { BaseProcessor } from '@wyw-in-js/processor-utils';
-import type { IFileContext } from '@wyw-in-js/processor-utils';
-import type { StrictOptions } from '@wyw-in-js/shared';
-import { EventEmitter } from './EventEmitter';
-import { type OxcStaticValue, type OxcStaticValueCandidate } from './collectOxcTemplateDependencies';
-type ApplyOxcProcessorsResult = {
-    code: string;
-    processors: BaseProcessor[];
-    staticValueCandidates: OxcStaticValueCandidate[];
-    staticValues: OxcStaticValue[];
-};
-export declare const applyOxcProcessors: (code: string, fileContext: IFileContext, options: Pick<StrictOptions, "classNameSlug" | "displayName" | "extensions" | "evaluate" | "tagResolver"> & {
-    eventEmitter?: EventEmitter;
-    preserveSideEffectImportLocals?: Set<string>;
-}, callback: (processor: BaseProcessor) => void, cleanupUnused?: boolean) => ApplyOxcProcessorsResult;
-export {};
+export { applyOxcProcessors } from './applyOxcProcessors/applyOxcProcessors';