vitest 0.18.1 → 0.20.0

package/dist/{chunk-runtime-mocker.1d853e3a.mjs → chunk-runtime-mocker.0a8f7c5e.mjs}

@@ -1,8 +1,10 @@
-import { n as normalizeRequestId, i as isNodeBuiltin, b as toFilePath, V as ViteNodeRunner } from './chunk-vite-node-utils.8077cd3c.mjs';
+import { V as ViteNodeRunner } from './chunk-vite-node-client.a247c2c2.mjs';
 import { normalizePath } from 'vite';
-import { a as getWorkerState, M as isWindows, N as mergeSlashes, d as dirname, j as join, o as basename, q as resolve, s as slash, O as getType, P as getAllProperties } from './chunk-utils-global.0a7416cf.mjs';
+import { M as isWindows, N as mergeSlashes, d as dirname, j as join, z as basename, y as resolve, s as slash, k as getType, O as getAllProperties } from './chunk-mock-date.9160e13b.mjs';
 import { existsSync, readdirSync } from 'fs';
-import { d as distDir } from './chunk-constants.d4406290.mjs';
+import { n as normalizeRequestId, i as isNodeBuiltin, b as toFilePath } from './chunk-vite-node-utils.9dfd1e3f.mjs';
+import { d as distDir } from './chunk-constants.16825f0c.mjs';
+import { g as getWorkerState } from './chunk-utils-global.fa20c2f6.mjs';
 
 class RefTracker {
   constructor() {
@@ -72,16 +74,18 @@ const _VitestMocker = class {
   }
   async callFunctionMock(dep, mock) {
     var _a;
-    const cacheName = `${dep}__mock`;
-    const cached = (_a = this.moduleCache.get(cacheName)) == null ? void 0 : _a.exports;
+    const cached = (_a = this.moduleCache.get(dep)) == null ? void 0 : _a.exports;
     if (cached)
       return cached;
     const exports = await mock();
-    this.moduleCache.set(cacheName, { exports });
+    this.moduleCache.set(dep, { exports });
     return exports;
   }
-  getDependencyMock(dep) {
-    return this.getMocks()[this.normalizePath(dep)];
+  getMockPath(dep) {
+    return `mock:${dep}`;
+  }
+  getDependencyMock(id) {
+    return this.getMocks()[id];
   }
   normalizePath(path) {
     return normalizeRequestId(path.replace(this.root, ""), this.base).replace(/^\/@fs\//, isWindows ? "" : "/");
@@ -184,7 +188,8 @@ const _VitestMocker = class {
   async importMock(id, importer) {
     const { path, external } = await this.resolvePath(id, importer);
     const fsPath = this.getFsPath(path, external);
-    let mock = this.getDependencyMock(fsPath);
+    const normalizedId = this.normalizePath(fsPath);
+    let mock = this.getDependencyMock(normalizedId);
     if (mock === void 0)
       mock = this.resolveMockPath(fsPath, external);
     if (mock === null) {
@@ -207,23 +212,24 @@ const _VitestMocker = class {
       this.ensureSpy(),
       this.resolveMocks()
     ]);
-    const mock = this.getDependencyMock(dep);
+    const id = this.normalizePath(dep);
+    const mock = this.getDependencyMock(id);
     const callstack = this.request.callstack;
+    const mockPath = this.getMockPath(id);
     if (mock === null) {
-      const cacheName = `${dep}__mock`;
-      const cache = this.moduleCache.get(cacheName);
+      const cache = this.moduleCache.get(mockPath);
       if (cache == null ? void 0 : cache.exports)
         return cache.exports;
       const cacheKey = toFilePath(dep, this.root);
       const mod = ((_a = this.moduleCache.get(cacheKey)) == null ? void 0 : _a.exports) || await this.request(dep);
       const exports = this.mockObject(mod);
-      this.moduleCache.set(cacheName, { exports });
+      this.moduleCache.set(mockPath, { exports });
       return exports;
     }
-    if (typeof mock === "function" && !callstack.includes(`mock:${dep}`)) {
-      callstack.push(`mock:${dep}`);
-      const result = await this.callFunctionMock(dep, mock);
-      const indexMock = callstack.indexOf(`mock:${dep}`);
+    if (typeof mock === "function" && !callstack.includes(mockPath)) {
+      callstack.push(mockPath);
+      const result = await this.callFunctionMock(mockPath, mock);
+      const indexMock = callstack.indexOf(mockPath);
       callstack.splice(indexMock, 1);
       return result;
     }

package/dist/{chunk-runtime-rpc.9d1f4c48.mjs → chunk-runtime-rpc.dbf0b31d.mjs}

@@ -1,4 +1,6 @@
-import { a as getWorkerState, w as withSafeTimers } from './chunk-utils-global.0a7416cf.mjs';
+import './chunk-mock-date.9160e13b.mjs';
+import { g as getWorkerState } from './chunk-utils-global.fa20c2f6.mjs';
+import { w as withSafeTimers } from './chunk-utils-timers.b48455ed.mjs';
 
 const rpc = () => {
   const { rpc: rpc2 } = getWorkerState();

package/dist/chunk-utils-global.fa20c2f6.mjs

@@ -0,0 +1,5 @@
+function getWorkerState() {
+  return globalThis.__vitest_worker__;
+}
+
+export { getWorkerState as g };

package/dist/{chunk-utils-source-map.c03f8bc4.mjs → chunk-utils-source-map.8198ebd9.mjs}

@@ -1,4 +1,4 @@
-import { s as slash, l as notNullish, p as picocolors } from './chunk-utils-global.0a7416cf.mjs';
+import { s as slash, f as notNullish, p as picocolors } from './chunk-mock-date.9160e13b.mjs';
 
 var build = {};
 
@@ -7435,4 +7435,4 @@ var matcherUtils = /*#__PURE__*/Object.freeze({
 	diff: diff
 });
 
-export { posToNumber as a, parseStacktrace as b, stripAnsi as c, cliTruncate as d, stringWidth as e, format_1 as f, getOriginalPos as g, ansiStyles as h, sliceAnsi as i, interpretSourcePos as j, lineSplitRE as l, matcherUtils as m, numberToPos as n, plugins_1 as p, stringify as s, unifiedDiff as u };
+export { plugins_1 as a, posToNumber as b, stripAnsi as c, cliTruncate as d, stringWidth as e, format_1 as f, getOriginalPos as g, ansiStyles as h, sliceAnsi as i, interpretSourcePos as j, lineSplitRE as l, matcherUtils as m, numberToPos as n, parseStacktrace as p, stringify as s, unifiedDiff as u };

package/dist/chunk-utils-timers.b48455ed.mjs

@@ -0,0 +1,27 @@
+const {
+  setTimeout: safeSetTimeout,
+  setInterval: safeSetInterval,
+  clearInterval: safeClearInterval,
+  clearTimeout: safeClearTimeout
+} = globalThis;
+function withSafeTimers(fn) {
+  const currentSetTimeout = globalThis.setTimeout;
+  const currentSetInterval = globalThis.setInterval;
+  const currentClearInterval = globalThis.clearInterval;
+  const currentClearTimeout = globalThis.clearTimeout;
+  try {
+    globalThis.setTimeout = safeSetTimeout;
+    globalThis.setInterval = safeSetInterval;
+    globalThis.clearInterval = safeClearInterval;
+    globalThis.clearTimeout = safeClearTimeout;
+    const result = fn();
+    return result;
+  } finally {
+    globalThis.setTimeout = currentSetTimeout;
+    globalThis.setInterval = currentSetInterval;
+    globalThis.clearInterval = currentClearInterval;
+    globalThis.clearTimeout = currentClearTimeout;
+  }
+}
+
+export { safeClearTimeout as a, safeSetInterval as b, safeClearInterval as c, safeSetTimeout as s, withSafeTimers as w };

package/dist/chunk-vite-node-client.a247c2c2.mjs

@@ -0,0 +1,320 @@
+import { createRequire } from 'module';
+import { pathToFileURL, fileURLToPath } from 'url';
+import vm from 'vm';
+import { y as resolve, d as dirname, B as isAbsolute, L as extname } from './chunk-mock-date.9160e13b.mjs';
+import { s as slash, n as normalizeRequestId, b as toFilePath, i as isNodeBuiltin, c as isPrimitive, d as normalizeModuleId, m as mergeSlashes } from './chunk-vite-node-utils.9dfd1e3f.mjs';
+import createDebug from 'debug';
+
+const debugExecute = createDebug("vite-node:client:execute");
+const debugNative = createDebug("vite-node:client:native");
+const DEFAULT_REQUEST_STUBS = {
+  "/@vite/client": {
+    injectQuery: (id) => id,
+    createHotContext() {
+      return {
+        accept: () => {
+        },
+        prune: () => {
+        },
+        dispose: () => {
+        },
+        decline: () => {
+        },
+        invalidate: () => {
+        },
+        on: () => {
+        }
+      };
+    },
+    updateStyle(id, css) {
+      if (typeof document === "undefined")
+        return;
+      const element = document.getElementById(id);
+      if (element)
+        element.remove();
+      const head = document.querySelector("head");
+      const style = document.createElement("style");
+      style.setAttribute("type", "text/css");
+      style.id = id;
+      style.innerHTML = css;
+      head == null ? void 0 : head.appendChild(style);
+    }
+  }
+};
+class ModuleCacheMap extends Map {
+  normalizePath(fsPath) {
+    return normalizeModuleId(fsPath);
+  }
+  set(fsPath, mod) {
+    fsPath = this.normalizePath(fsPath);
+    if (!super.has(fsPath))
+      super.set(fsPath, mod);
+    else
+      Object.assign(super.get(fsPath), mod);
+    return this;
+  }
+  get(fsPath) {
+    fsPath = this.normalizePath(fsPath);
+    return super.get(fsPath);
+  }
+  delete(fsPath) {
+    fsPath = this.normalizePath(fsPath);
+    return super.delete(fsPath);
+  }
+}
+class ViteNodeRunner {
+  constructor(options) {
+    this.options = options;
+    this.root = options.root ?? process.cwd();
+    this.moduleCache = options.moduleCache ?? new ModuleCacheMap();
+    this.debug = options.debug ?? (typeof process !== "undefined" ? !!process.env.VITE_NODE_DEBUG_RUNNER : false);
+  }
+  async executeFile(file) {
+    return await this.cachedRequest(`/@fs/${slash(resolve(file))}`, []);
+  }
+  async executeId(id) {
+    return await this.cachedRequest(id, []);
+  }
+  async cachedRequest(rawId, callstack) {
+    var _a, _b, _c, _d;
+    const id = normalizeRequestId(rawId, this.options.base);
+    const fsPath = toFilePath(id, this.root);
+    if (callstack.includes(fsPath) && ((_a = this.moduleCache.get(fsPath)) == null ? void 0 : _a.exports))
+      return (_b = this.moduleCache.get(fsPath)) == null ? void 0 : _b.exports;
+    if ((_c = this.moduleCache.get(fsPath)) == null ? void 0 : _c.promise)
+      return (_d = this.moduleCache.get(fsPath)) == null ? void 0 : _d.promise;
+    const promise = this.directRequest(id, fsPath, callstack);
+    this.moduleCache.set(fsPath, { promise });
+    return await promise;
+  }
+  async directRequest(id, fsPath, _callstack) {
+    const callstack = [..._callstack, fsPath];
+    const request = async (dep) => {
+      var _a;
+      const fsPath2 = toFilePath(normalizeRequestId(dep, this.options.base), this.root);
+      const getStack = () => {
+        return `stack:
+${[...callstack, fsPath2].reverse().map((p) => `- ${p}`).join("\n")}`;
+      };
+      let debugTimer;
+      if (this.debug)
+        debugTimer = setTimeout(() => console.warn(() => `module ${fsPath2} takes over 2s to load.
+${getStack()}`), 2e3);
+      try {
+        if (callstack.includes(fsPath2)) {
+          const depExports = (_a = this.moduleCache.get(fsPath2)) == null ? void 0 : _a.exports;
+          if (depExports)
+            return depExports;
+          throw new Error(`[vite-node] Failed to resolve circular dependency, ${getStack()}`);
+        }
+        const mod = await this.cachedRequest(dep, callstack);
+        return mod;
+      } finally {
+        if (debugTimer)
+          clearTimeout(debugTimer);
+      }
+    };
+    Object.defineProperty(request, "callstack", { get: () => callstack });
+    const resolveId = async (dep, callstackPosition = 1) => {
+      if (this.options.resolveId && this.shouldResolveId(dep)) {
+        let importer = callstack[callstack.length - callstackPosition];
+        if (importer && importer.startsWith("mock:"))
+          importer = importer.slice(5);
+        const { id: id2 } = await this.options.resolveId(dep, importer) || {};
+        dep = id2 && isAbsolute(id2) ? mergeSlashes(`/@fs/${id2}`) : id2 || dep;
+      }
+      return dep;
+    };
+    id = await resolveId(id, 2);
+    const requestStubs = this.options.requestStubs || DEFAULT_REQUEST_STUBS;
+    if (id in requestStubs)
+      return requestStubs[id];
+    let { code: transformed, externalize } = await this.options.fetchModule(id);
+    if (externalize) {
+      debugNative(externalize);
+      const mod = await this.interopedImport(externalize);
+      this.moduleCache.set(fsPath, { exports: mod });
+      return mod;
+    }
+    if (transformed == null)
+      throw new Error(`[vite-node] Failed to load ${id}`);
+    const url = pathToFileURL(fsPath).href;
+    const meta = { url };
+    const exports = /* @__PURE__ */ Object.create(null);
+    exports[Symbol.toStringTag] = "Module";
+    this.moduleCache.set(fsPath, { code: transformed, exports });
+    const __filename = fileURLToPath(url);
+    const moduleProxy = {
+      set exports(value) {
+        exportAll(exports, value);
+        exports.default = value;
+      },
+      get exports() {
+        return exports;
+      }
+    };
+    let hotContext;
+    if (this.options.createHotContext) {
+      Object.defineProperty(meta, "hot", {
+        enumerable: true,
+        get: () => {
+          var _a, _b;
+          hotContext || (hotContext = (_b = (_a = this.options).createHotContext) == null ? void 0 : _b.call(_a, this, `/@fs/${fsPath}`));
+          return hotContext;
+        }
+      });
+    }
+    const context = this.prepareContext({
+      __vite_ssr_import__: request,
+      __vite_ssr_dynamic_import__: request,
+      __vite_ssr_exports__: exports,
+      __vite_ssr_exportAll__: (obj) => exportAll(exports, obj),
+      __vite_ssr_import_meta__: meta,
+      __vitest_resolve_id__: resolveId,
+      require: createRequire(url),
+      exports,
+      module: moduleProxy,
+      __filename,
+      __dirname: dirname(__filename)
+    });
+    debugExecute(__filename);
+    if (transformed[0] === "#")
+      transformed = transformed.replace(/^\#\!.*/, (s) => " ".repeat(s.length));
+    const fn = vm.runInThisContext(`'use strict';async (${Object.keys(context).join(",")})=>{{${transformed}
+}}`, {
+      filename: fsPath,
+      lineOffset: 0
+    });
+    await fn(...Object.values(context));
+    return exports;
+  }
+  prepareContext(context) {
+    return context;
+  }
+  shouldResolveId(dep) {
+    if (isNodeBuiltin(dep) || dep in (this.options.requestStubs || DEFAULT_REQUEST_STUBS) || dep.startsWith("/@vite"))
+      return false;
+    return !isAbsolute(dep) || !extname(dep);
+  }
+  shouldInterop(path, mod) {
+    if (this.options.interopDefault === false)
+      return false;
+    return !path.endsWith(".mjs") && "default" in mod;
+  }
+  async interopedImport(path) {
+    const mod = await import(path);
+    if (this.shouldInterop(path, mod)) {
+      const tryDefault = this.hasNestedDefault(mod);
+      return new Proxy(mod, {
+        get: proxyMethod("get", tryDefault),
+        set: proxyMethod("set", tryDefault),
+        has: proxyMethod("has", tryDefault),
+        deleteProperty: proxyMethod("deleteProperty", tryDefault)
+      });
+    }
+    return mod;
+  }
+  hasNestedDefault(target) {
+    return "__esModule" in target && target.__esModule && "default" in target.default;
+  }
+}
+function proxyMethod(name, tryDefault) {
+  return function(target, key, ...args) {
+    const result = Reflect[name](target, key, ...args);
+    if (isPrimitive(target.default))
+      return result;
+    if (tryDefault && key === "default" || typeof result === "undefined")
+      return Reflect[name](target.default, key, ...args);
+    return result;
+  };
+}
+function exportAll(exports, sourceModule) {
+  if (exports === sourceModule)
+    return;
+  for (const key in sourceModule) {
+    if (key !== "default") {
+      try {
+        Object.defineProperty(exports, key, {
+          enumerable: true,
+          configurable: true,
+          get() {
+            return sourceModule[key];
+          }
+        });
+      } catch (_err) {
+      }
+    }
+  }
+}
+
+const DEFAULT_TIMEOUT = 6e4;
+function createBirpc(functions, options) {
+  const {
+    post,
+    on,
+    eventNames = [],
+    serialize = (i) => i,
+    deserialize = (i) => i,
+    timeout = DEFAULT_TIMEOUT
+  } = options;
+  const rpcPromiseMap = /* @__PURE__ */ new Map();
+  const rpc = new Proxy({}, {
+    get(_, method) {
+      const sendEvent = (...args) => {
+        post(serialize({ m: method, a: args, t: "q" }));
+      };
+      if (eventNames.includes(method)) {
+        sendEvent.asEvent = sendEvent;
+        return sendEvent;
+      }
+      const sendCall = (...args) => {
+        return new Promise((resolve, reject) => {
+          const id = nanoid();
+          rpcPromiseMap.set(id, { resolve, reject });
+          post(serialize({ m: method, a: args, i: id, t: "q" }));
+          if (timeout >= 0) {
+            setTimeout(() => {
+              reject(new Error(`[birpc] timeout on calling "${method}"`));
+              rpcPromiseMap.delete(id);
+            }, timeout);
+          }
+        });
+      };
+      sendCall.asEvent = sendEvent;
+      return sendCall;
+    }
+  });
+  on(async (data, ...extra) => {
+    const msg = deserialize(data);
+    if (msg.t === "q") {
+      const { m: method, a: args } = msg;
+      let result, error;
+      try {
+        result = await functions[method].apply(rpc, args);
+      } catch (e) {
+        error = e;
+      }
+      if (msg.i)
+        post(serialize({ t: "s", i: msg.i, r: result, e: error }), ...extra);
+    } else {
+      const { i: ack, r: result, e: error } = msg;
+      const promise = rpcPromiseMap.get(ack);
+      if (error)
+        promise?.reject(error);
+      else
+        promise?.resolve(result);
+      rpcPromiseMap.delete(ack);
+    }
+  });
+  return rpc;
+}
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+  let id = "";
+  let i = size;
+  while (i--)
+    id += urlAlphabet[Math.random() * 64 | 0];
+  return id;
+}
+
+export { ModuleCacheMap as M, ViteNodeRunner as V, createBirpc as c };

package/dist/chunk-vite-node-debug.c5887932.mjs

@@ -0,0 +1,76 @@
+import { existsSync, promises } from 'fs';
+import { y as resolve, p as picocolors, j as join } from './chunk-mock-date.9160e13b.mjs';
+import 'path';
+import 'tty';
+import 'local-pkg';
+
+function hashCode(s) {
+  return s.split("").reduce((a, b) => {
+    a = (a << 5) - a + b.charCodeAt(0);
+    return a & a;
+  }, 0);
+}
+class Debugger {
+  constructor(root, options) {
+    this.options = options;
+    this.externalizeMap = /* @__PURE__ */ new Map();
+    if (options.dumpModules)
+      this.dumpDir = resolve(root, options.dumpModules === true ? ".vite-node/dump" : options.dumpModules);
+    if (this.dumpDir) {
+      if (options.loadDumppedModules)
+        console.info(picocolors.exports.gray(`[vite-node] [debug] load modules from ${this.dumpDir}`));
+      else
+        console.info(picocolors.exports.gray(`[vite-node] [debug] dump modules to ${this.dumpDir}`));
+    }
+    this.initPromise = this.clearDump();
+  }
+  async clearDump() {
+    if (!this.dumpDir)
+      return;
+    if (!this.options.loadDumppedModules && existsSync(this.dumpDir))
+      await promises.rm(this.dumpDir, { recursive: true, force: true });
+    await promises.mkdir(this.dumpDir, { recursive: true });
+  }
+  encodeId(id) {
+    return `${id.replace(/[^\w@_-]/g, "_").replace(/_+/g, "_")}-${hashCode(id)}.js`;
+  }
+  async recordExternalize(id, path) {
+    if (!this.dumpDir)
+      return;
+    this.externalizeMap.set(id, path);
+    await this.writeInfo();
+  }
+  async dumpFile(id, result) {
+    if (!result || !this.dumpDir)
+      return;
+    await this.initPromise;
+    const name = this.encodeId(id);
+    return await promises.writeFile(join(this.dumpDir, name), `// ${id.replace(/\0/g, "\\0")}
+${result.code}`, "utf-8");
+  }
+  async loadDump(id) {
+    if (!this.dumpDir)
+      return null;
+    await this.initPromise;
+    const name = this.encodeId(id);
+    const path = join(this.dumpDir, name);
+    if (!existsSync(path))
+      return null;
+    const code = await promises.readFile(path, "utf-8");
+    return {
+      code: code.replace(/^\/\/.*?\n/, ""),
+      map: void 0
+    };
+  }
+  async writeInfo() {
+    if (!this.dumpDir)
+      return;
+    const info = JSON.stringify({
+      time: new Date().toLocaleString(),
+      externalize: Object.fromEntries(this.externalizeMap.entries())
+    }, null, 2);
+    return promises.writeFile(join(this.dumpDir, "info.json"), info, "utf-8");
+  }
+}
+
+export { Debugger };