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

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/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 Node resolver fallback 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] Node 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 node 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);
-};
+}>;

package/types/vm/createVmContext.js

@@ -1,47 +1,11 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createVmContext = createVmContext;
-const vm = __importStar(require("vm"));
-const shared_1 = require("@wyw-in-js/shared");
-const process = __importStar(require("./process"));
+import * as vm from 'vm';
+import { isFeatureEnabled } from '@wyw-in-js/shared';
+import * as process from './process';
 const NOOP = () => { };
 const IMPORT_META_ENV = '__wyw_import_meta_env';
 const HAPPY_DOM_REQUIRE_HOOK = '__wyw_requireHappyDom';
 let importMetaEnvWarned = false;
-let happyDomRequireEsmWarned = false;
+let happyDomLoadWarned = false;
 let happyDomUnavailable = false;
 function isErrRequireEsm(error) {
     return (typeof error === 'object' &&
@@ -93,19 +57,23 @@ function createImportMetaEnvProxy() {
         },
     });
 }
-function requireHappyDom() {
+let happyDomImportPromise = null;
+async function loadHappyDom() {
     const hook = globalThis[HAPPY_DOM_REQUIRE_HOOK];
     if (typeof hook === 'function') {
-        return hook();
+        const result = hook();
+        return Promise.resolve(result);
     }
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    return require('happy-dom');
+    if (!happyDomImportPromise) {
+        happyDomImportPromise = import('happy-dom');
+    }
+    return happyDomImportPromise;
 }
-function createWindow() {
+async function createWindow() {
     if (happyDomUnavailable)
         return undefined;
     try {
-        const { Window, GlobalWindow } = requireHappyDom();
+        const { Window, GlobalWindow } = await loadHappyDom();
         const HappyWindow = GlobalWindow || Window;
         const win = new HappyWindow();
         // TODO: browser doesn't expose Buffer, but a lot of dependencies use it
@@ -114,27 +82,22 @@ function createWindow() {
         return win;
     }
     catch (error) {
-        if (!isErrRequireEsm(error)) {
-            throw error;
+        if (isErrRequireEsm(error)) {
+            // This can happen if a custom hook still uses require() for ESM.
         }
-        const hasCustomRequireHook = typeof globalThis[HAPPY_DOM_REQUIRE_HOOK] ===
-            'function';
-        if (!hasCustomRequireHook) {
+        else if (!happyDomUnavailable) {
             happyDomUnavailable = true;
         }
-        if (happyDomRequireEsmWarned)
+        if (happyDomLoadWarned)
             return undefined;
-        happyDomRequireEsmWarned = true;
+        happyDomLoadWarned = true;
         // eslint-disable-next-line no-console
         console.warn([
             `[wyw-in-js] DOM emulation is enabled (features.happyDOM), but "happy-dom" could not be loaded in this build-time runtime.`,
-            `This usually happens because "happy-dom" is ESM-only and cannot be loaded via require() in a CJS build.`,
-            ``,
             `WyW will continue without DOM emulation (as if features.happyDOM:false).`,
             ``,
             `To silence this warning: set features: { happyDOM: false }.`,
-            `To get real DOM emulation in Node 20+, WyW needs an ESM-only eval architecture (planned for v2.0.0),`,
-            `or a runtime that supports require(ESM) (Node 24+).`,
+            `To restore DOM emulation, ensure "happy-dom" can be imported in the build-time runtime.`,
         ].join('\n'));
         return undefined;
     }
@@ -177,8 +140,8 @@ function createNothing() {
         window: undefined,
     };
 }
-function createHappyDOMWindow() {
-    const win = createWindow();
+async function createHappyDOMWindow() {
+    const win = await createWindow();
     if (!win)
         return createNothing();
     return {
@@ -188,10 +151,10 @@ function createHappyDOMWindow() {
         window: win,
     };
 }
-function createVmContext(filename, features, additionalContext, overrideContext = (i) => i) {
-    const isHappyDOMEnabled = (0, shared_1.isFeatureEnabled)(features, 'happyDOM', filename);
+export async function createVmContext(filename, features, additionalContext, overrideContext = (i) => i) {
+    const isHappyDOMEnabled = isFeatureEnabled(features, 'happyDOM', filename);
     const { teardown, window } = isHappyDOMEnabled
-        ? createHappyDOMWindow()
+        ? await createHappyDOMWindow()
         : createNothing();
     const envContext = {
         [IMPORT_META_ENV]: createImportMetaEnvProxy(),

package/types/vm/process.js

@@ -1,32 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.env = exports.features = exports.uvCounters = exports.memoryUsage = exports.uptime = exports.dlopen = exports.umask = exports.chdir = exports.kill = exports.exit = exports.cwd = exports.binding = exports.argv = exports.browser = exports.pid = exports.title = exports.execPath = exports.arch = exports.platform = exports.nextTick = void 0;
 /**
  * It contains API for mocked process variable available in node environment used to evaluate scripts with node's `vm` in ./module.ts
  */
-const nextTick = (fn) => setTimeout(fn, 0);
-exports.nextTick = nextTick;
-exports.platform = 'browser';
-exports.arch = 'browser';
-exports.execPath = 'browser';
-exports.title = 'browser';
-exports.pid = 1;
-exports.browser = true;
-exports.argv = [];
-const binding = function binding() {
+export const nextTick = (fn) => setTimeout(fn, 0);
+export const platform = 'browser';
+export const arch = 'browser';
+export const execPath = 'browser';
+export const title = 'browser';
+export const pid = 1;
+export const browser = true;
+export const argv = [];
+export const binding = function binding() {
     throw new Error('No such module. (Possibly not yet loaded)');
 };
-exports.binding = binding;
-const cwd = () => '/';
-exports.cwd = cwd;
+export const cwd = () => '/';
 const noop = () => { };
-exports.exit = noop;
-exports.kill = noop;
-exports.chdir = noop;
-exports.umask = noop;
-exports.dlopen = noop;
-exports.uptime = noop;
-exports.memoryUsage = noop;
-exports.uvCounters = noop;
-exports.features = {};
-exports.env = process.env;
+export const exit = noop;
+export const kill = noop;
+export const chdir = noop;
+export const umask = noop;
+export const dlopen = noop;
+export const uptime = noop;
+export const memoryUsage = noop;
+export const uvCounters = noop;
+export const features = {};
+export const { env } = process;

package/esm/babel.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=babel.js.map

package/esm/babel.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"babel.js","names":[],"sources":["../src/babel.ts"],"sourcesContent":["import type core from '@babel/core';\n\nexport type Core = typeof core;\n"],"mappings":"","ignoreList":[]}