@wyw-in-js/transform 1.0.3 → 1.0.5

package/types/transform/generators/processImports.js

@@ -1,10 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processImports = processImports;
+const importOverrides_1 = require("../../utils/importOverrides");
+const warnedSlowImportsByServices = new WeakMap();
+function emitWarning(services, message) {
+    if (services.emitWarning) {
+        services.emitWarning(message);
+        return;
+    }
+    // eslint-disable-next-line no-console
+    console.warn(message);
+}
+function getWarnedSlowImports(services) {
+    const cached = warnedSlowImportsByServices.get(services);
+    if (cached)
+        return cached;
+    const created = new Set();
+    warnedSlowImportsByServices.set(services, created);
+    return created;
+}
+function isWarningEnabled(value) {
+    return Boolean(value) && value !== '0' && value !== 'false';
+}
 /**
  * Creates new entrypoints and emits processEntrypoint for each resolved import
  */
 function* processImports() {
+    const slowImportWarningsEnabled = isWarningEnabled(process.env.WYW_WARN_SLOW_IMPORTS);
+    const slowImportThresholdMs = (() => {
+        const raw = process.env.WYW_WARN_SLOW_IMPORTS_MS;
+        if (!raw)
+            return 50;
+        const parsed = Number(raw);
+        if (!Number.isFinite(parsed))
+            return 50;
+        return parsed;
+    })();
+    const warnedSlowImports = slowImportWarningsEnabled
+        ? getWarnedSlowImports(this.services)
+        : null;
+    const { root } = this.services.options;
     for (const dependency of this.data.resolved) {
         const { resolved, only } = dependency;
         if (!resolved) {
@@ -15,6 +50,41 @@ function* processImports() {
         if (nextEntrypoint === 'loop' || nextEntrypoint.ignored) {
             continue;
         }
+        const startedAt = slowImportWarningsEnabled ? performance.now() : 0;
         yield* this.getNext('processEntrypoint', nextEntrypoint, undefined, null);
+        if (slowImportWarningsEnabled &&
+            warnedSlowImports &&
+            slowImportThresholdMs > 0) {
+            const durationMs = performance.now() - startedAt;
+            if (durationMs >= slowImportThresholdMs) {
+                const { key: importKey } = (0, importOverrides_1.toImportKey)({
+                    source: dependency.source,
+                    resolved,
+                    root,
+                });
+                const dedupeKey = `${this.entrypoint.name}::${importKey}`;
+                if (!warnedSlowImports.has(dedupeKey)) {
+                    warnedSlowImports.add(dedupeKey);
+                    const warning = [
+                        `[wyw-in-js] Slow import during prepare stage`,
+                        ``,
+                        `file: ${this.entrypoint.name}`,
+                        `import: ${dependency.source}`,
+                        `resolved: ${resolved}`,
+                        `duration: ${durationMs.toFixed(1)}ms`,
+                        ``,
+                        `tip: if this import is runtime-only or heavy, mock it during evaluation via importOverrides:`,
+                        `  importOverrides: {`,
+                        `    '${importKey}': { mock: './path/to/mock' },`,
+                        `  }`,
+                        ``,
+                        `note: importOverrides affects only build-time evaluation (it does not change your bundler runtime behavior)`,
+                        ``,
+                        `note: configure threshold with WYW_WARN_SLOW_IMPORTS_MS (current: ${slowImportThresholdMs}ms)`,
+                    ].join('\n');
+                    emitWarning(this.services, warning);
+                }
+            }
+        }
     }
 }

package/types/transform/generators/resolveImports.js

@@ -20,7 +20,7 @@ function applyImportOverrides(services, entrypoint, resolvedImports) {
             resolved: dependency.resolved,
             root,
         });
-        const override = overrides[key];
+        const override = (0, importOverrides_1.getImportOverride)(overrides, key);
         if (!override) {
             return dependency;
         }

package/types/utils/importOverrides.d.ts

@@ -1,4 +1,4 @@
-import { type ImportOverride } from '@wyw-in-js/shared';
+import { type ImportOverride, type ImportOverrides } from '@wyw-in-js/shared';
 export type ImportKeyKind = 'file' | 'package';
 export type ImportKey = {
     key: string;
@@ -17,3 +17,4 @@ export declare function resolveMockSpecifier({ importer, mock, root, stack, }: {
     stack: string[];
 }): string;
 export declare function applyImportOverrideToOnly(only: string[], override: ImportOverride | undefined): string[];
+export declare function getImportOverride(importOverrides: ImportOverrides | undefined, key: string): ImportOverride | undefined;

package/types/utils/importOverrides.js

@@ -7,8 +7,10 @@ exports.toCanonicalFileKey = toCanonicalFileKey;
 exports.toImportKey = toImportKey;
 exports.resolveMockSpecifier = resolveMockSpecifier;
 exports.applyImportOverrideToOnly = applyImportOverrideToOnly;
+exports.getImportOverride = getImportOverride;
 const path_1 = __importDefault(require("path"));
 const shared_1 = require("@wyw-in-js/shared");
+const minimatch_1 = require("minimatch");
 function toCanonicalFileKey(resolved, root) {
     const rootDir = root ? path_1.default.resolve(root) : process.cwd();
     const normalizedResolved = path_1.default.resolve(resolved);
@@ -38,3 +40,64 @@ function applyImportOverrideToOnly(only, override) {
     }
     return only;
 }
+const compiledImportOverridesCache = new WeakMap();
+const minimatchOptions = {
+    dot: true,
+    nocomment: true,
+    nonegate: true,
+};
+function getPatternSpecificity(pattern) {
+    let wildcardCount = 0;
+    let escaped = false;
+    for (const char of pattern) {
+        if (escaped) {
+            escaped = false;
+        }
+        else if (char === '\\') {
+            escaped = true;
+        }
+        else if (char === '*' || char === '?') {
+            wildcardCount += 1;
+        }
+    }
+    return pattern.length - wildcardCount * 10;
+}
+function compileImportOverrides(importOverrides) {
+    const matchers = Object.entries(importOverrides)
+        .map(([pattern, override]) => {
+        return {
+            matcher: new minimatch_1.Minimatch(pattern, minimatchOptions),
+            override,
+            pattern,
+            specificity: getPatternSpecificity(pattern),
+        };
+    })
+        .sort((a, b) => {
+        const bySpecificity = b.specificity - a.specificity;
+        if (bySpecificity !== 0)
+            return bySpecificity;
+        const byLength = b.pattern.length - a.pattern.length;
+        if (byLength !== 0)
+            return byLength;
+        return a.pattern.localeCompare(b.pattern);
+    });
+    return { matchers };
+}
+function getCompiledImportOverrides(importOverrides) {
+    const cached = compiledImportOverridesCache.get(importOverrides);
+    if (cached)
+        return cached;
+    const compiled = compileImportOverrides(importOverrides);
+    compiledImportOverridesCache.set(importOverrides, compiled);
+    return compiled;
+}
+function getImportOverride(importOverrides, key) {
+    if (!importOverrides) {
+        return undefined;
+    }
+    const direct = importOverrides[key];
+    if (direct)
+        return direct;
+    const { matchers } = getCompiledImportOverrides(importOverrides);
+    return matchers.find(({ matcher }) => matcher.match(key))?.override;
+}

package/types/vm/createVmContext.js

@@ -39,7 +39,16 @@ const shared_1 = require("@wyw-in-js/shared");
 const process = __importStar(require("./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 happyDomUnavailable = false;
+function isErrRequireEsm(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        error.code === 'ERR_REQUIRE_ESM');
+}
 function createImportMetaEnvProxy() {
     const target = Object.create(null);
     const warnOnce = () => {
@@ -84,14 +93,51 @@ function createImportMetaEnvProxy() {
         },
     });
 }
+function requireHappyDom() {
+    const hook = globalThis[HAPPY_DOM_REQUIRE_HOOK];
+    if (typeof hook === 'function') {
+        return hook();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require('happy-dom');
+}
 function createWindow() {
-    const { Window, GlobalWindow } = require('happy-dom');
-    const HappyWindow = GlobalWindow || Window;
-    const win = new HappyWindow();
-    // TODO: browser doesn't expose Buffer, but a lot of dependencies use it
-    win.Buffer = Buffer;
-    win.Uint8Array = Uint8Array;
-    return win;
+    if (happyDomUnavailable)
+        return undefined;
+    try {
+        const { Window, GlobalWindow } = requireHappyDom();
+        const HappyWindow = GlobalWindow || Window;
+        const win = new HappyWindow();
+        // TODO: browser doesn't expose Buffer, but a lot of dependencies use it
+        win.Buffer = Buffer;
+        win.Uint8Array = Uint8Array;
+        return win;
+    }
+    catch (error) {
+        if (!isErrRequireEsm(error)) {
+            throw error;
+        }
+        const hasCustomRequireHook = typeof globalThis[HAPPY_DOM_REQUIRE_HOOK] ===
+            'function';
+        if (!hasCustomRequireHook) {
+            happyDomUnavailable = true;
+        }
+        if (happyDomRequireEsmWarned)
+            return undefined;
+        happyDomRequireEsmWarned = 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+).`,
+        ].join('\n'));
+        return undefined;
+    }
 }
 /**
  * `happy-dom` already has required references, so we don't need to set them.
@@ -125,8 +171,16 @@ function createBaseContext(win, additionalContext) {
     }
     return baseContext;
 }
+function createNothing() {
+    return {
+        teardown: () => { },
+        window: undefined,
+    };
+}
 function createHappyDOMWindow() {
     const win = createWindow();
+    if (!win)
+        return createNothing();
     return {
         teardown: () => {
             win.happyDOM.abort();
@@ -134,12 +188,6 @@ function createHappyDOMWindow() {
         window: win,
     };
 }
-function createNothing() {
-    return {
-        teardown: () => { },
-        window: undefined,
-    };
-}
 function createVmContext(filename, features, additionalContext, overrideContext = (i) => i) {
     const isHappyDOMEnabled = (0, shared_1.isFeatureEnabled)(features, 'happyDOM', filename);
     const { teardown, window } = isHappyDOMEnabled