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

package/types/utils/parseOxc.d.ts

@@ -0,0 +1,11 @@
+import type { Program } from 'oxc-parser';
+type OxcSourceType = 'module' | 'unambiguous';
+type ParsedOxc = {
+    module: {
+        hasModuleSyntax: boolean;
+    };
+    program: Program;
+};
+export declare const parseOxcCached: (filename: string, code: string, sourceType: OxcSourceType) => ParsedOxc;
+export declare const parseOxcProgramCached: (filename: string, code: string, sourceType: OxcSourceType) => Program;
+export {};

package/types/utils/parseOxc.js

@@ -0,0 +1,38 @@
+import { parseSync } from 'oxc-parser';
+const MAX_PARSE_CACHE_ENTRIES = 200;
+const parseCache = new Map();
+const getAstType = (filename) => filename.endsWith('.ts') || filename.endsWith('.tsx') ? 'ts' : 'js';
+const makeCacheKey = (filename, code, sourceType) => `${sourceType}\0${filename}\0${code}`;
+const setCachedParse = (key, value) => {
+    parseCache.set(key, value);
+    if (parseCache.size > MAX_PARSE_CACHE_ENTRIES) {
+        const oldestKey = parseCache.keys().next().value;
+        if (oldestKey) {
+            parseCache.delete(oldestKey);
+        }
+    }
+    return value;
+};
+export const parseOxcCached = (filename, code, sourceType) => {
+    const cacheKey = makeCacheKey(filename, code, sourceType);
+    const cached = parseCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const parsed = parseSync(filename, code, {
+        astType: getAstType(filename),
+        range: true,
+        sourceType,
+    });
+    const fatalError = parsed.errors.find((error) => error.severity === 'Error');
+    if (fatalError) {
+        throw new Error(fatalError.message);
+    }
+    return setCachedParse(cacheKey, {
+        module: {
+            hasModuleSyntax: parsed.module.hasModuleSyntax,
+        },
+        program: parsed.program,
+    });
+};
+export const parseOxcProgramCached = (filename, code, sourceType) => parseOxcCached(filename, code, sourceType).program;

package/types/utils/parseRequest.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stripQueryAndHash = exports.parseRequest = void 0;
 const getFirstSuffixIndex = (request) => {
     const queryIdx = request.indexOf('?');
     const hashIdx = request.indexOf('#');
@@ -10,7 +7,7 @@ const getFirstSuffixIndex = (request) => {
         return queryIdx;
     return Math.min(queryIdx, hashIdx);
 };
-const parseRequest = (request) => {
+export const parseRequest = (request) => {
     const firstSuffixIndex = getFirstSuffixIndex(request);
     if (firstSuffixIndex === -1) {
         return { filename: request, hash: '', query: '' };
@@ -24,6 +21,4 @@ const parseRequest = (request) => {
     const hash = hashIdx === -1 ? '' : request.slice(hashIdx + 1);
     return { filename, hash, query };
 };
-exports.parseRequest = parseRequest;
-const stripQueryAndHash = (request) => (0, exports.parseRequest)(request).filename;
-exports.stripQueryAndHash = stripQueryAndHash;
+export const stripQueryAndHash = (request) => parseRequest(request).filename;

package/types/utils/peek.js

@@ -1,5 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.peek = void 0;
-const peek = (stack, offset = 1) => stack[stack.length - offset];
-exports.peek = peek;
+export const peek = (stack, offset = 1) => stack[stack.length - offset];

package/types/utils/processorLookup.d.ts

@@ -0,0 +1,8 @@
+import { BaseProcessor } from '@wyw-in-js/processor-utils';
+import type { TagSource } from '@wyw-in-js/processor-utils';
+import type { StrictOptions } from '@wyw-in-js/shared';
+export type ProcessorClass = new (...args: ConstructorParameters<typeof BaseProcessor>) => BaseProcessor;
+export declare const getProcessorForImport: ({ imported, source }: {
+    imported: string;
+    source: string;
+}, filename: string | null | undefined, options: Pick<StrictOptions, "tagResolver">) => [ProcessorClass | null, TagSource];

package/types/utils/processorLookup.js

@@ -0,0 +1,135 @@
+import { readFileSync } from 'fs';
+import { createRequire } from 'module';
+import { dirname, join } from 'path';
+import { BaseProcessor } from '@wyw-in-js/processor-utils';
+import { findPackageJSON, syncResolve } from '@wyw-in-js/shared';
+const nodeRequire = createRequire(import.meta.url);
+const definedTagsCache = new Map();
+const resolvedTagResolverSourceCache = new Map();
+const packageProcessorLookupCache = new Map();
+const tagResolverProcessorLookupCache = new WeakMap();
+const createTagResolverLookupCacheKey = (source, imported, filename) => `${filename ?? ''}\0${source}\0${imported}`;
+const createPackageLookupCacheKey = (source, imported) => `${source}\0${imported}`;
+const URL_SCHEME_RE = /^[A-Za-z][A-Za-z\d+.-]*:/;
+const isPackageLookupCandidate = (source) => {
+    if (!source ||
+        source.startsWith('.') ||
+        source.startsWith('/') ||
+        source.startsWith('\\') ||
+        source.startsWith('\0') ||
+        source.startsWith('@/') ||
+        source.startsWith('~/') ||
+        source.startsWith('#') ||
+        source.includes('?') ||
+        source.includes('#') ||
+        URL_SCHEME_RE.test(source)) {
+        return false;
+    }
+    if (source.startsWith('@')) {
+        const [scope, pkg] = source.split('/', 2);
+        return scope.length > 1 && !!pkg;
+    }
+    return true;
+};
+const getTagResolverLookupCache = (tagResolver) => {
+    const existing = tagResolverProcessorLookupCache.get(tagResolver);
+    if (existing) {
+        return existing;
+    }
+    const created = new Map();
+    tagResolverProcessorLookupCache.set(tagResolver, created);
+    return created;
+};
+const getResolvedTagResolverSource = (source, sourceFile) => {
+    if (!sourceFile) {
+        return undefined;
+    }
+    const key = `${sourceFile}\0${source}`;
+    if (resolvedTagResolverSourceCache.has(key)) {
+        return resolvedTagResolverSourceCache.get(key);
+    }
+    try {
+        const resolved = syncResolve(source, sourceFile, []);
+        resolvedTagResolverSourceCache.set(key, resolved);
+        return resolved;
+    }
+    catch {
+        resolvedTagResolverSourceCache.set(key, undefined);
+        return undefined;
+    }
+};
+const getDefinedTagsFromPackage = (pkgName, filename) => {
+    if (definedTagsCache.has(pkgName)) {
+        return definedTagsCache.get(pkgName);
+    }
+    const packageJSONPath = findPackageJSON(pkgName, filename);
+    if (!packageJSONPath) {
+        return undefined;
+    }
+    const packageDir = dirname(packageJSONPath);
+    const packageJSON = JSON.parse(readFileSync(packageJSONPath, 'utf8'));
+    const definedTags = packageJSON['wyw-in-js']?.tags;
+    const normalizedTags = definedTags
+        ? Object.entries(definedTags).reduce((acc, [key, value]) => ({
+            ...acc,
+            [key]: value.startsWith('.')
+                ? join(packageDir, value)
+                : nodeRequire.resolve(value, { paths: [packageDir] }),
+        }), {})
+        : undefined;
+    definedTagsCache.set(pkgName, normalizedTags);
+    return normalizedTags;
+};
+const isValidProcessorClass = (module) => module instanceof BaseProcessor.constructor;
+const getProcessorFromPackage = (packageName, tagName, filename) => {
+    const definedTags = getDefinedTagsFromPackage(packageName, filename);
+    const processorPath = definedTags?.[tagName];
+    if (!processorPath) {
+        return null;
+    }
+    const Processor = nodeRequire(processorPath).default;
+    if (!isValidProcessorClass(Processor)) {
+        return null;
+    }
+    return Processor;
+};
+const getProcessorFromFile = (processorPath) => {
+    const Processor = nodeRequire(processorPath).default;
+    if (!isValidProcessorClass(Processor)) {
+        return null;
+    }
+    return Processor;
+};
+export const getProcessorForImport = ({ imported, source }, filename, options) => {
+    const { tagResolver } = options;
+    const packageLookupCandidate = isPackageLookupCandidate(source);
+    if (!tagResolver && !packageLookupCandidate) {
+        return [null, { imported, source }];
+    }
+    const cacheKey = tagResolver
+        ? createTagResolverLookupCacheKey(source, imported, filename)
+        : createPackageLookupCacheKey(source, imported);
+    const lookupCache = tagResolver
+        ? getTagResolverLookupCache(tagResolver)
+        : packageProcessorLookupCache;
+    if (lookupCache.has(cacheKey)) {
+        return [lookupCache.get(cacheKey) ?? null, { imported, source }];
+    }
+    let customFile = null;
+    if (tagResolver) {
+        const tagResolverMeta = {
+            sourceFile: filename,
+            resolvedSource: getResolvedTagResolverSource(source, filename),
+        };
+        customFile = tagResolver(source, imported, tagResolverMeta);
+    }
+    let processor = null;
+    if (customFile) {
+        processor = getProcessorFromFile(customFile);
+    }
+    else if (packageLookupCandidate) {
+        processor = getProcessorFromPackage(source, imported, filename);
+    }
+    lookupCache.set(cacheKey, processor);
+    return [processor, { imported, source }];
+};

package/types/utils/processorStaticSemantics.d.ts

@@ -0,0 +1,13 @@
+import type { BaseProcessor, Expression as ProcessorExpression, ProcessorStaticContext, ProcessorStaticValue } from '@wyw-in-js/processor-utils';
+export declare const unknownProcessorStaticValue: unique symbol;
+export type UnknownProcessorStaticValue = typeof unknownProcessorStaticValue;
+export declare const createProcessorStaticContext: (processor: BaseProcessor) => ProcessorStaticContext;
+export declare const isProcessorStaticValue: (value: unknown) => value is ProcessorStaticValue;
+export declare const getProcessorStaticValue: (processor: BaseProcessor) => ProcessorStaticValue | null;
+export declare const processorStaticValueToRuntimeValue: (value: ProcessorStaticValue) => unknown | UnknownProcessorStaticValue;
+export declare const resolveProcessorStaticRuntimeValue: (processor: BaseProcessor) => unknown | UnknownProcessorStaticValue;
+export declare const resolveProcessorStaticClassName: (processor: BaseProcessor) => string | null;
+export declare const processorLiteralValue: (expression: ProcessorExpression) => unknown | UnknownProcessorStaticValue;
+export declare const processorPropertyKeyName: (key: ProcessorExpression) => string | null;
+export declare const processorObjectPropertyValue: (expression: ProcessorExpression, name: string) => ProcessorExpression | null;
+export declare const processorExpressionToStaticValue: (expression: ProcessorExpression, resolveHelperCall: (name: string) => unknown | UnknownProcessorStaticValue) => unknown | UnknownProcessorStaticValue;

package/types/utils/processorStaticSemantics.js

@@ -0,0 +1,191 @@
+export const unknownProcessorStaticValue = Symbol('unknownProcessorStaticValue');
+export const createProcessorStaticContext = (processor) => {
+    const processorWithInternals = processor;
+    return {
+        addDependency: () => { },
+        debug: () => { },
+        fileContext: processorWithInternals.context ??
+            {},
+        metadata: {
+            className: processor.className,
+            displayName: processor.displayName,
+            isReferenced: processor.isReferenced,
+            location: processor.location,
+            slug: processor.slug,
+            tagSource: processor.tagSource,
+        },
+        options: processorWithInternals.options ??
+            {},
+        unresolved: (reason, details) => ({
+            ...(details ? { details } : {}),
+            kind: 'unresolved',
+            reason,
+        }),
+    };
+};
+export const isProcessorStaticValue = (value) => {
+    if (typeof value !== 'object' || value === null || !('kind' in value)) {
+        return false;
+    }
+    const candidate = value;
+    switch (candidate.kind) {
+        case 'class-name':
+            return typeof candidate.className === 'string';
+        case 'opaque-component':
+            return (candidate.className === undefined ||
+                typeof candidate.className === 'string');
+        case 'runtime-callback':
+        case 'serializable':
+            return true;
+        case 'selector-chain':
+            return (typeof candidate.className === 'string' &&
+                Array.isArray(candidate.selectors) &&
+                candidate.selectors.every((selector) => typeof selector === 'string'));
+        case 'unresolved':
+            return typeof candidate.reason === 'string';
+        default:
+            return false;
+    }
+};
+export const getProcessorStaticValue = (processor) => {
+    if (!processor.getStaticValue) {
+        return null;
+    }
+    try {
+        const value = processor.getStaticValue(createProcessorStaticContext(processor));
+        return isProcessorStaticValue(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+};
+export const processorStaticValueToRuntimeValue = (value) => {
+    switch (value.kind) {
+        case 'class-name':
+            return value.value === undefined ? value.className : value.value;
+        case 'opaque-component':
+        case 'runtime-callback':
+            return value.value === undefined
+                ? unknownProcessorStaticValue
+                : value.value;
+        case 'selector-chain':
+        case 'serializable':
+            return value.value;
+        case 'unresolved':
+            return unknownProcessorStaticValue;
+        default:
+            return unknownProcessorStaticValue;
+    }
+};
+export const resolveProcessorStaticRuntimeValue = (processor) => {
+    const staticValue = getProcessorStaticValue(processor);
+    return staticValue
+        ? processorStaticValueToRuntimeValue(staticValue)
+        : unknownProcessorStaticValue;
+};
+export const resolveProcessorStaticClassName = (processor) => {
+    const staticValue = getProcessorStaticValue(processor);
+    if (staticValue?.kind !== 'class-name') {
+        return null;
+    }
+    const runtimeValue = processorStaticValueToRuntimeValue(staticValue);
+    return typeof runtimeValue === 'string'
+        ? runtimeValue
+        : staticValue.className;
+};
+export const processorLiteralValue = (expression) => {
+    const expressionWithValue = expression;
+    if (expression.type === 'StringLiteral' ||
+        expression.type === 'NumericLiteral' ||
+        expression.type === 'BooleanLiteral' ||
+        expression.type === 'Literal') {
+        return expressionWithValue.value;
+    }
+    if (expression.type === 'NullLiteral') {
+        return null;
+    }
+    return unknownProcessorStaticValue;
+};
+export const processorPropertyKeyName = (key) => {
+    if (key.type === 'Identifier') {
+        return key.name;
+    }
+    const value = processorLiteralValue(key);
+    return typeof value === 'string' ? value : null;
+};
+export const processorObjectPropertyValue = (expression, name) => {
+    if (expression.type !== 'ObjectExpression') {
+        return null;
+    }
+    const { properties } = expression;
+    if (!properties) {
+        return null;
+    }
+    for (const property of properties) {
+        if ((property.type === 'ObjectProperty' || property.type === 'Property') &&
+            property.key &&
+            processorPropertyKeyName(property.key) === name) {
+            return property.value ?? null;
+        }
+    }
+    return null;
+};
+export const processorExpressionToStaticValue = (expression, resolveHelperCall) => {
+    const literal = processorLiteralValue(expression);
+    if (literal !== unknownProcessorStaticValue) {
+        return literal;
+    }
+    if (expression.type === 'ArrayExpression') {
+        const { elements } = expression;
+        if (!elements) {
+            return unknownProcessorStaticValue;
+        }
+        const result = [];
+        for (const element of elements) {
+            if (element === null) {
+                result.push(null);
+            }
+            else {
+                const value = processorExpressionToStaticValue(element, resolveHelperCall);
+                if (value === unknownProcessorStaticValue) {
+                    return unknownProcessorStaticValue;
+                }
+                result.push(value);
+            }
+        }
+        return result;
+    }
+    if (expression.type === 'ObjectExpression') {
+        const metaExpression = processorObjectPropertyValue(expression, '__wyw_meta');
+        if (!metaExpression || metaExpression.type !== 'ObjectExpression') {
+            return unknownProcessorStaticValue;
+        }
+        const classNameExpression = processorObjectPropertyValue(metaExpression, 'className');
+        const className = classNameExpression
+            ? processorLiteralValue(classNameExpression)
+            : unknownProcessorStaticValue;
+        if (typeof className !== 'string') {
+            return unknownProcessorStaticValue;
+        }
+        const extendsExpression = processorObjectPropertyValue(metaExpression, 'extends');
+        const extended = extendsExpression
+            ? processorExpressionToStaticValue(extendsExpression, resolveHelperCall)
+            : null;
+        if (extended === unknownProcessorStaticValue) {
+            return unknownProcessorStaticValue;
+        }
+        return {
+            __wyw_meta: {
+                className,
+                extends: extended,
+            },
+        };
+    }
+    if (expression.type === 'CallExpression') {
+        const call = expression;
+        if (call.arguments?.length === 0 && call.callee?.type === 'Identifier') {
+            return resolveHelperCall(call.callee.name);
+        }
+    }
+    return unknownProcessorStaticValue;
+};

package/types/utils/resolveWithConditions.d.ts

@@ -0,0 +1,12 @@
+type ResolveFilenameParent = {
+    filename: string;
+    id: string;
+    paths: string[];
+};
+type ResolveFilenameModuleImplementation = {
+    _resolveFilename: (id: string, options: ResolveFilenameParent, isMain?: boolean, resolveOptions?: {
+        conditions?: Set<string>;
+    }) => string;
+};
+export declare const resolveFilenameWithConditions: (moduleImpl: ResolveFilenameModuleImplementation, id: string, parent: ResolveFilenameParent, conditions?: Set<string>) => string;
+export {};

package/types/utils/resolveWithConditions.js

@@ -0,0 +1,103 @@
+import { spawnSync } from 'child_process';
+import NativeModule from 'module';
+const NODE_CONDITIONAL_RESOLVE_SCRIPT = String.raw `
+const fs = require('node:fs');
+const Module = require('node:module');
+
+const input = JSON.parse(fs.readFileSync(0, 'utf8'));
+
+try {
+  const resolved = Module._resolveFilename(
+    input.id,
+    input.parent,
+    false,
+    input.conditions ? { conditions: new Set(input.conditions) } : undefined
+  );
+  fs.writeFileSync(1, JSON.stringify({ resolved }));
+} catch (error) {
+  fs.writeFileSync(
+    1,
+    JSON.stringify({
+      error: {
+        code:
+          error && typeof error === 'object' && 'code' in error
+            ? error.code
+            : undefined,
+        message: error instanceof Error ? error.message : String(error),
+      },
+    })
+  );
+  process.exitCode = 1;
+}
+`;
+const isBunRuntime = () => process.execPath.includes('bun');
+const nativeResolveFilename = NativeModule._resolveFilename;
+const resolveWithNodeProcess = (id, parent, conditions) => {
+    const nodeBinary = process.env.WYW_NODE_BINARY || 'node';
+    const result = spawnSync(nodeBinary, ['-e', NODE_CONDITIONAL_RESOLVE_SCRIPT], {
+        encoding: 'utf8',
+        input: JSON.stringify({
+            conditions: [...conditions],
+            id,
+            parent,
+        }),
+        maxBuffer: 1024 * 1024,
+    });
+    if (result.error) {
+        throw result.error;
+    }
+    let parsed = null;
+    const stdout = result.stdout.trim();
+    if (stdout) {
+        try {
+            parsed = JSON.parse(stdout);
+        }
+        catch {
+            throw new Error([
+                '[wyw-in-js] Failed to parse custom module resolver output.',
+                `stdout: ${stdout}`,
+                result.stderr ? `stderr: ${result.stderr.trim()}` : '',
+            ]
+                .filter(Boolean)
+                .join('\n'));
+        }
+    }
+    if (parsed?.error) {
+        const error = new Error(parsed.error.message);
+        error.code = parsed.error.code;
+        throw error;
+    }
+    if (result.status !== 0 || !parsed?.resolved) {
+        throw new Error([
+            '[wyw-in-js] Custom module resolver fallback failed.',
+            `status: ${result.status ?? 'null'}`,
+            result.stderr ? `stderr: ${result.stderr.trim()}` : '',
+        ]
+            .filter(Boolean)
+            .join('\n'));
+    }
+    return parsed.resolved;
+};
+export const resolveFilenameWithConditions = (moduleImpl, id, parent, conditions) => {
+    const resolveOptions = conditions ? { conditions } : undefined;
+    const usesNativeResolver = moduleImpl._resolveFilename === nativeResolveFilename;
+    if (!conditions || !isBunRuntime() || !usesNativeResolver) {
+        return moduleImpl._resolveFilename(id, parent, false, resolveOptions);
+    }
+    // Bun crashes on macOS/Silicon in this exact path:
+    //   Module._resolveFilename(specifier, parent, false, { conditions })
+    // We reproduced it both with a tiny standalone script and through the
+    // `EvalBroker > passes conditionNames to native fallback resolution` test,
+    // including on Bun 1.3.13. Keep this fallback narrow: only conditioned
+    // resolution under Bun goes through a short-lived Node subprocess.
+    //
+    // Cleanup criteria:
+    // 1. Bun passes the minimal local `_resolveFilename(..., { conditions })`
+    //    repro on macOS without segfaulting.
+    // 2. The conditionNames runner path passes without this fallback.
+    //
+    // As of 2026-04-20 we did not find an exact open upstream Bun issue for this
+    // `_resolveFilename(..., { conditions })` crash, so keep the comment factual
+    // and the workaround self-contained.
+    return resolveWithNodeProcess(id, parent, conditions);
+};

package/types/vm/createVmContext.d.ts

@@ -1,6 +1,6 @@
 import * as vm from 'vm';
 import type { FeatureFlags, StrictOptions } from '@wyw-in-js/shared';
-export declare function createVmContext(filename: string, features: FeatureFlags<'happyDOM'>, additionalContext: Partial<vm.Context>, overrideContext?: StrictOptions['overrideContext']): {
+export declare function createVmContext(filename: string, features: FeatureFlags<'happyDOM'>, additionalContext: Partial<vm.Context>, overrideContext?: StrictOptions['overrideContext']): Promise<{
     context: vm.Context;
     teardown: (() => void) | (() => void);
-};
+}>;