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

package/types/utils/collectOxcRuntime.d.ts

@@ -0,0 +1,14 @@
+import type { ValueCache } from '@wyw-in-js/processor-utils';
+import type { StrictOptions } from '@wyw-in-js/shared';
+import { type RawSourceMap } from 'source-map';
+import type { WYWTransformMetadata } from './TransformMetadata';
+type OxcCollectOptions = Pick<StrictOptions, 'classNameSlug' | 'displayName' | 'evaluate' | 'extensions' | 'tagResolver' | 'variableNameConfig'> & {
+    preserveSideEffectImportLocals?: Set<string>;
+};
+type OxcCollectResult = {
+    code: string;
+    map: RawSourceMap;
+    metadata: WYWTransformMetadata | null;
+};
+export declare const collectOxcRuntime: (code: string, filename: string, root: string, options: OxcCollectOptions, values: ValueCache, inputSourceMap?: RawSourceMap) => OxcCollectResult;
+export {};

package/types/utils/collectOxcRuntime.js

@@ -0,0 +1,250 @@
+/* eslint-disable no-restricted-syntax */
+import { createRequire } from 'node:module';
+import { parseSync } from 'oxc-parser';
+import { SourceMapGenerator } from 'source-map';
+import { applyOxcProcessors } from './applyOxcProcessors';
+const remapping = createRequire(import.meta.url)('@jridgewell/remapping');
+const countLines = (code) => code.split('\n').length;
+const parseOxc = (code, filename) => {
+    const parsed = parseSync(filename, code, {
+        astType: filename.endsWith('.ts') || filename.endsWith('.tsx') ? 'ts' : 'js',
+        range: true,
+        sourceType: 'module',
+    });
+    const fatalError = parsed.errors.find((error) => error.severity === 'Error');
+    if (fatalError) {
+        throw new Error(fatalError.message);
+    }
+    return parsed.program;
+};
+const applyReplacements = (code, replacements) => {
+    let result = code;
+    replacements
+        .sort((a, b) => b.start - a.start)
+        .forEach((replacement) => {
+        result =
+            result.slice(0, replacement.start) +
+                replacement.value +
+                result.slice(replacement.end);
+    });
+    return result;
+};
+const shouldTerminateWithSemicolon = (node, parent, key) => {
+    if (node.type === 'VariableDeclaration' && parent) {
+        if ((parent.type === 'ForStatement' ||
+            parent.type === 'ForInStatement' ||
+            parent.type === 'ForOfStatement') &&
+            key &&
+            ['init', 'left'].includes(key)) {
+            return false;
+        }
+        if (parent.type === 'ExportNamedDeclaration') {
+            return false;
+        }
+    }
+    if (node.type === 'ImportDeclaration' ||
+        node.type === 'ExpressionStatement' ||
+        node.type === 'ReturnStatement' ||
+        node.type === 'ThrowStatement' ||
+        node.type === 'VariableDeclaration') {
+        return true;
+    }
+    if (node.type === 'ExportNamedDeclaration') {
+        if (node.declaration) {
+            return node.declaration.type === 'VariableDeclaration';
+        }
+        return Array.isArray(node.specifiers) && node.specifiers.length > 0;
+    }
+    return false;
+};
+const getChildren = (node) => {
+    const result = [];
+    const record = node;
+    Object.keys(record).forEach((key) => {
+        if (key === 'type' || key === 'start' || key === 'end' || key === 'range') {
+            return;
+        }
+        const value = record[key];
+        if (value && typeof value === 'object' && 'type' in value) {
+            result.push({ key, node: value });
+            return;
+        }
+        if (Array.isArray(value)) {
+            value.forEach((item) => {
+                if (item && typeof item === 'object' && 'type' in item) {
+                    result.push({ key, node: item });
+                }
+            });
+        }
+    });
+    return result;
+};
+const getLineIndent = (code, offset) => {
+    const lineStart = code.lastIndexOf('\n', offset - 1) + 1;
+    let idx = lineStart;
+    while (idx < code.length && (code[idx] === ' ' || code[idx] === '\t')) {
+        idx += 1;
+    }
+    return code.slice(lineStart, idx).replace(/\t/g, '  ');
+};
+const isPlainObjectProperty = (property) => property.type === 'Property' &&
+    property.kind === 'init' &&
+    property.method !== true;
+const isFormattableObjectExpression = (node) => node.type === 'ObjectExpression' &&
+    node.properties.every((property) => property.type === 'SpreadElement' || isPlainObjectProperty(property));
+const hasNestedObjectValue = (node) => node.type === 'ObjectExpression' &&
+    node.properties.some((property) => isPlainObjectProperty(property) &&
+        property.value.type === 'ObjectExpression');
+const printFormattedObjectExpression = (node, code, baseIndent) => {
+    if (node.type !== 'ObjectExpression' ||
+        node.properties.length === 0 ||
+        !isFormattableObjectExpression(node)) {
+        return code.slice(node.start, node.end);
+    }
+    const lines = node.properties.map((property) => {
+        if (property.type === 'SpreadElement') {
+            return `${baseIndent}  ...${code.slice(property.argument.start, property.argument.end)}`;
+        }
+        const keySource = property.computed
+            ? `[${code.slice(property.key.start, property.key.end)}]`
+            : code.slice(property.key.start, property.key.end);
+        const valueSource = property.value.type === 'ObjectExpression'
+            ? printFormattedObjectExpression(property.value, code, `${baseIndent}  `)
+            : code.slice(property.value.start, property.value.end).trim();
+        return `${baseIndent}  ${keySource}: ${valueSource}`;
+    });
+    return `{\n${lines.join(',\n')}\n${baseIndent}}`;
+};
+const formatRuntimeObjectLiterals = (code, filename) => {
+    const replacements = [];
+    const walk = (node, parent = null) => {
+        if (node.type === 'ObjectExpression') {
+            const shouldFormat = (parent?.type === 'VariableDeclarator' && hasNestedObjectValue(node)) ||
+                parent?.type === 'CallExpression';
+            if (shouldFormat) {
+                replacements.push({
+                    end: node.end,
+                    start: node.start,
+                    value: printFormattedObjectExpression(node, code, getLineIndent(code, node.start)),
+                });
+                return;
+            }
+        }
+        getChildren(node).forEach((child) => walk(child.node, node));
+    };
+    walk(parseOxc(code, filename));
+    return replacements.length > 0 ? applyReplacements(code, replacements) : code;
+};
+const collapseRuntimeBlankLines = (code) => {
+    const lines = code.split('\n');
+    const result = [];
+    for (let idx = 0; idx < lines.length; idx += 1) {
+        const line = lines[idx];
+        if (line.trim() !== '') {
+            result.push(line);
+        }
+        else {
+            let nextIdx = idx;
+            while (nextIdx < lines.length && lines[nextIdx]?.trim() === '') {
+                nextIdx += 1;
+            }
+            const previousNonEmpty = [...result]
+                .reverse()
+                .find((entry) => entry.trim() !== '');
+            const nextNonEmpty = lines
+                .slice(nextIdx)
+                .find((entry) => entry.trim() !== '');
+            if (previousNonEmpty && nextNonEmpty) {
+                const trimmedPrevious = previousNonEmpty.trim();
+                if (trimmedPrevious.startsWith('//') ||
+                    trimmedPrevious.endsWith('*/')) {
+                    result.push('');
+                }
+            }
+            idx = nextIdx - 1;
+        }
+    }
+    return result.join('\n');
+};
+const ensureBlankLineAfterLeadingBlockComment = (code) => code.replace(/^(\/\*[\s\S]*?\*\/)\n(?!\n)/, '$1\n\n');
+const insertMissingSemicolons = (code, filename) => {
+    const replacements = [];
+    const hasTrailingSemicolon = (node) => code.slice(node.start, node.end).trimEnd().endsWith(';');
+    const walk = (node, parent = null, key = null) => {
+        if (shouldTerminateWithSemicolon(node, parent, key) &&
+            !hasTrailingSemicolon(node)) {
+            replacements.push({
+                end: node.end,
+                start: node.end,
+                value: ';',
+            });
+        }
+        getChildren(node).forEach((child) => walk(child.node, node, child.key));
+    };
+    walk(parseOxc(code, filename));
+    return replacements.length > 0 ? applyReplacements(code, replacements) : code;
+};
+const createLineSourceMap = (generatedCode, originalCode, filename) => {
+    const generator = new SourceMapGenerator({
+        file: filename,
+    });
+    const generatedLines = countLines(generatedCode);
+    const originalLines = countLines(originalCode);
+    for (let line = 1; line <= generatedLines; line += 1) {
+        generator.addMapping({
+            generated: {
+                column: 0,
+                line,
+            },
+            original: {
+                column: 0,
+                line: Math.min(line, originalLines),
+            },
+            source: filename,
+        });
+    }
+    generator.setSourceContent(filename, originalCode);
+    return generator.toJSON();
+};
+const createComposedRuntimeSourceMap = (generatedCode, originalCode, filename, inputSourceMap) => {
+    const runtimeMap = createLineSourceMap(generatedCode, originalCode, filename);
+    if (!inputSourceMap) {
+        return runtimeMap;
+    }
+    const composed = remapping([runtimeMap, inputSourceMap], () => null);
+    return {
+        ...composed,
+        file: runtimeMap.file,
+    };
+};
+const normalizeRuntimeCode = (code, filename) => insertMissingSemicolons(ensureBlankLineAfterLeadingBlockComment(collapseRuntimeBlankLines(formatRuntimeObjectLiterals(code
+    .replace(/^\n+/, '')
+    .replace(/\n+$/, '')
+    .replace(/[ \t]+\n/g, '\n'), filename))), filename);
+export const collectOxcRuntime = (code, filename, root, options, values, inputSourceMap) => {
+    const result = applyOxcProcessors(code, {
+        filename,
+        root,
+    }, options, (processor) => {
+        processor.build(values);
+        processor.doRuntimeReplacement();
+    }, true);
+    const normalizedCode = normalizeRuntimeCode(result.code, filename);
+    if (result.processors.length === 0) {
+        return {
+            code: normalizedCode,
+            map: createComposedRuntimeSourceMap(normalizedCode, code, filename, inputSourceMap),
+            metadata: null,
+        };
+    }
+    return {
+        code: normalizedCode,
+        map: createComposedRuntimeSourceMap(normalizedCode, code, filename, inputSourceMap),
+        metadata: {
+            dependencies: [],
+            processors: result.processors,
+            replacements: [],
+            rules: {},
+        },
+    };
+};

package/types/utils/collectOxcTemplateDependencies.d.ts

@@ -0,0 +1,38 @@
+import type { ExpressionValue } from '@wyw-in-js/shared';
+type ExpressionSpan = {
+    end: number;
+    start: number;
+};
+export type OxcStaticImportReference = {
+    imported: 'default' | string;
+    importLocal?: string;
+    local: string;
+    source: string;
+};
+export type OxcStaticValue = {
+    name: string;
+    value: unknown;
+};
+export type OxcStaticValueCandidate = {
+    imports: OxcStaticImportReference[];
+    name: string;
+    source: string;
+};
+type TemplateExtractionResult = {
+    code: string;
+    dependencyNames: string[];
+    expressionValues: Omit<ExpressionValue, 'buildCodeFrameError'>[];
+    staticValueCandidates: OxcStaticValueCandidate[];
+    staticValues: OxcStaticValue[];
+};
+declare const oxcStaticCallableValue: unique symbol;
+type OxcStaticCallableValue = {
+    [oxcStaticCallableValue]: unknown;
+};
+export declare const createOxcStaticCallableValue: (value: unknown) => OxcStaticCallableValue;
+export declare const isOxcStaticSerializableValue: (value: unknown) => boolean;
+export declare const evaluateOxcStaticExpressionAt: (code: string, filename: string, expressionSpan: ExpressionSpan, staticBindings?: Map<string, unknown>) => unknown | undefined;
+export declare const evaluateOxcStaticExpression: (source: string, filename: string, staticBindings?: Map<string, unknown>) => unknown | undefined;
+export declare const collectOxcExpressionDependencies: (code: string, filename: string, evaluate?: boolean, targetExpressionSpans?: ExpressionSpan[]) => TemplateExtractionResult;
+export declare const collectOxcTemplateDependencies: (code: string, filename: string, evaluate?: boolean, targetTemplateSpans?: ExpressionSpan[]) => TemplateExtractionResult;
+export {};