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

package/types/utils/collectOxcExportsAndImports.js

@@ -894,6 +894,14 @@ const getChildren = (node) => {
     return result;
 };
 const precollectRequireSources = (node, state) => {
+    // Cheap text precheck at the Program entry: if the file body has no
+    // 'require(' substring there can be no CommonJS require() init to collect.
+    // Skip the full AST walk — meaningful saving on ESM-only modules in large
+    // monorepos. Done at Program-level only so nested recursion doesn't pay
+    // the indexOf cost per node.
+    if (node.type === 'Program' && state.code.indexOf('require(') === -1) {
+        return;
+    }
     if (node.type === 'VariableDeclarator' && node.id.type === 'Identifier') {
         const source = node.init ? sourceFromRequireSyntax(node.init) : null;
         if (source) {

package/types/utils/collectOxcRuntime/normalizeRuntimeCode.d.ts

@@ -0,0 +1 @@
+export declare const normalizeRuntimeCode: (code: string, filename: string) => string;

package/types/utils/collectOxcRuntime/normalizeRuntimeCode.js

@@ -0,0 +1,185 @@
+/* eslint-disable no-restricted-syntax */
+import { parseSync } from 'oxc-parser';
+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;
+};
+export const normalizeRuntimeCode = (code, filename) => insertMissingSemicolons(ensureBlankLineAfterLeadingBlockComment(collapseRuntimeBlankLines(formatRuntimeObjectLiterals(code
+    .replace(/^\n+/, '')
+    .replace(/\n+$/, '')
+    .replace(/[ \t]+\n/g, '\n'), filename))), filename);

package/types/utils/collectOxcRuntime/sourceMap.d.ts

@@ -0,0 +1,2 @@
+import { type RawSourceMap } from 'source-map';
+export declare const createComposedRuntimeSourceMap: (generatedCode: string, originalCode: string, filename: string, inputSourceMap?: RawSourceMap) => RawSourceMap;

package/types/utils/collectOxcRuntime/sourceMap.js

@@ -0,0 +1,37 @@
+import { createRequire } from 'node:module';
+import { SourceMapGenerator } from 'source-map';
+const remapping = createRequire(import.meta.url)('@jridgewell/remapping');
+const countLines = (code) => code.split('\n').length;
+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();
+};
+export 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,
+    };
+};

package/types/utils/collectOxcRuntime/types.d.ts

@@ -0,0 +1,17 @@
+import type { StrictOptions } from '@wyw-in-js/shared';
+import type { RawSourceMap } from 'source-map';
+import type { WYWTransformMetadata } from '../TransformMetadata';
+export type OxcCollectOptions = Pick<StrictOptions, 'classNameSlug' | 'displayName' | 'eval' | 'extensions' | 'tagResolver' | 'variableNameConfig'> & {
+    preserveSideEffectImportOrderLocals?: Set<string>;
+    preserveSideEffectImportLocals?: Set<string>;
+};
+export type OxcCollectResult = {
+    code: string;
+    map: RawSourceMap;
+    metadata: WYWTransformMetadata | null;
+};
+export type RuntimeReplacement = {
+    end: number;
+    start: number;
+    value: string;
+};

package/types/utils/collectOxcRuntime/types.js

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

package/types/utils/collectOxcRuntime.d.ts

@@ -1,14 +1,4 @@
 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;
-};
+import type { RawSourceMap } from 'source-map';
+import type { OxcCollectOptions, OxcCollectResult } from './collectOxcRuntime/types';
 export declare const collectOxcRuntime: (code: string, filename: string, root: string, options: OxcCollectOptions, values: ValueCache, inputSourceMap?: RawSourceMap) => OxcCollectResult;
-export {};

package/types/utils/collectOxcRuntime.js

@@ -1,226 +1,6 @@
-/* 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);
+import { normalizeRuntimeCode } from './collectOxcRuntime/normalizeRuntimeCode';
+import { createComposedRuntimeSourceMap } from './collectOxcRuntime/sourceMap';
 export const collectOxcRuntime = (code, filename, root, options, values, inputSourceMap) => {
     const result = applyOxcProcessors(code, {
         filename,
@@ -230,16 +10,17 @@ export const collectOxcRuntime = (code, filename, root, options, values, inputSo
         processor.doRuntimeReplacement();
     }, true);
     const normalizedCode = normalizeRuntimeCode(result.code, filename);
+    const map = createComposedRuntimeSourceMap(normalizedCode, code, filename, inputSourceMap);
     if (result.processors.length === 0) {
         return {
             code: normalizedCode,
-            map: createComposedRuntimeSourceMap(normalizedCode, code, filename, inputSourceMap),
+            map,
             metadata: null,
         };
     }
     return {
         code: normalizedCode,
-        map: createComposedRuntimeSourceMap(normalizedCode, code, filename, inputSourceMap),
+        map,
         metadata: {
             dependencies: [],
             processors: result.processors,

package/types/utils/collectOxcTemplateDependencies/expressionExtraction.d.ts

@@ -0,0 +1,6 @@
+import type { ExpressionSpan, StaticBindings, TemplateExtractionResult } from './types';
+export declare const isOxcStaticSerializableValue: (value: unknown) => boolean;
+export declare const evaluateOxcStaticExpressionAt: (code: string, filename: string, expressionSpan: ExpressionSpan, env?: Map<string, unknown>, staticBindings?: StaticBindings) => unknown | undefined;
+export declare const evaluateOxcStaticExpression: (source: string, filename: string, env?: Map<string, unknown>, staticBindings?: StaticBindings) => unknown | undefined;
+export declare const collectOxcExpressionDependencies: (code: string, filename: string, evaluate?: boolean, targetExpressionSpans?: ExpressionSpan[], staticBindings?: StaticBindings) => TemplateExtractionResult;
+export declare const collectOxcTemplateDependencies: (code: string, filename: string, evaluate?: boolean, targetTemplateSpans?: ExpressionSpan[]) => TemplateExtractionResult;