vite-node 0.22.0 → 0.23.1

package/cli.d.ts

@@ -0,0 +1,8 @@
+interface CliOptions {
+    files?: string[];
+    _?: string[];
+    root?: string;
+    config?: string;
+}
+
+export { CliOptions };

package/client.d.ts

@@ -0,0 +1,37 @@
+import { ViteNodeRunnerOptions, ModuleCache } from './types.js';
+
+declare const DEFAULT_REQUEST_STUBS: {
+    '/@vite/client': {
+        injectQuery: (id: string) => string;
+        createHotContext(): {
+            accept: () => void;
+            prune: () => void;
+        };
+        updateStyle(): void;
+    };
+};
+declare class ViteNodeRunner {
+    options: ViteNodeRunnerOptions;
+    root: string;
+    moduleCache: Map<string, ModuleCache>;
+    constructor(options: ViteNodeRunnerOptions);
+    executeFile(file: string): Promise<any>;
+    executeId(id: string): Promise<any>;
+    cachedRequest(rawId: string, callstack: string[]): Promise<any>;
+    directRequest(id: string, fsPath: string, callstack: string[]): Promise<any>;
+    prepareContext(context: Record<string, any>): Record<string, any>;
+    setCache(id: string, mod: Partial<ModuleCache>): void;
+    shouldResolveId(dep: string): boolean;
+    /**
+     * Define if a module should be interop-ed
+     * This function mostly for the ability to override by subclass
+     */
+    shouldInterop(path: string, mod: any): boolean;
+    /**
+     * Import a module and interop it
+     */
+    interopedImport(path: string): Promise<any>;
+    hasNestedDefault(target: any): any;
+}
+
+export { DEFAULT_REQUEST_STUBS, ViteNodeRunner };

package/dist/chunk-hmr.cjs

@@ -98,17 +98,19 @@ async function fetchUpdate(runner, { path, acceptedPath }) {
   const qualifiedCallbacks = mod.callbacks.filter(({ deps }) => {
     return deps.some((dep) => modulesToUpdate.has(dep));
   });
-  await Promise.all(Array.from(modulesToUpdate).map(async (dep) => {
-    const disposer = maps.disposeMap.get(dep);
-    if (disposer)
-      await disposer(maps.dataMap.get(dep));
-    try {
-      const newMod = await reload(runner, [dep]);
-      moduleMap.set(dep, newMod);
-    } catch (e) {
-      warnFailedFetch(e, dep);
-    }
-  }));
+  await Promise.all(
+    Array.from(modulesToUpdate).map(async (dep) => {
+      const disposer = maps.disposeMap.get(dep);
+      if (disposer)
+        await disposer(maps.dataMap.get(dep));
+      try {
+        const newMod = await reload(runner, [dep]);
+        moduleMap.set(dep, newMod);
+      } catch (e) {
+        warnFailedFetch(e, dep);
+      }
+    })
+  );
   return () => {
     for (const { deps, fn } of qualifiedCallbacks)
       fn(deps.map((dep) => moduleMap.get(dep)));
@@ -119,7 +121,9 @@ async function fetchUpdate(runner, { path, acceptedPath }) {
 function warnFailedFetch(err, path) {
   if (!err.message.match("fetch"))
     console.error(err);
-  console.error(`[hmr] Failed to reload ${path}. This could be due to syntax errors or importing non-existent modules. (see errors above)`);
+  console.error(
+    `[hmr] Failed to reload ${path}. This could be due to syntax errors or importing non-existent modules. (see errors above)`
+  );
 }
 async function handleMessage(runner, emitter, files, payload) {
   const maps = getCache(runner);

package/dist/chunk-hmr.mjs

@@ -92,17 +92,19 @@ async function fetchUpdate(runner, { path, acceptedPath }) {
   const qualifiedCallbacks = mod.callbacks.filter(({ deps }) => {
     return deps.some((dep) => modulesToUpdate.has(dep));
   });
-  await Promise.all(Array.from(modulesToUpdate).map(async (dep) => {
-    const disposer = maps.disposeMap.get(dep);
-    if (disposer)
-      await disposer(maps.dataMap.get(dep));
-    try {
-      const newMod = await reload(runner, [dep]);
-      moduleMap.set(dep, newMod);
-    } catch (e) {
-      warnFailedFetch(e, dep);
-    }
-  }));
+  await Promise.all(
+    Array.from(modulesToUpdate).map(async (dep) => {
+      const disposer = maps.disposeMap.get(dep);
+      if (disposer)
+        await disposer(maps.dataMap.get(dep));
+      try {
+        const newMod = await reload(runner, [dep]);
+        moduleMap.set(dep, newMod);
+      } catch (e) {
+        warnFailedFetch(e, dep);
+      }
+    })
+  );
   return () => {
     for (const { deps, fn } of qualifiedCallbacks)
       fn(deps.map((dep) => moduleMap.get(dep)));
@@ -113,7 +115,9 @@ async function fetchUpdate(runner, { path, acceptedPath }) {
 function warnFailedFetch(err, path) {
   if (!err.message.match("fetch"))
     console.error(err);
-  console.error(`[hmr] Failed to reload ${path}. This could be due to syntax errors or importing non-existent modules. (see errors above)`);
+  console.error(
+    `[hmr] Failed to reload ${path}. This could be due to syntax errors or importing non-existent modules. (see errors above)`
+  );
 }
 async function handleMessage(runner, emitter, files, payload) {
   const maps = getCache(runner);

package/dist/cli.cjs

@@ -8,6 +8,7 @@ var client = require('./client.cjs');
 var utils = require('./utils.cjs');
 var hmr = require('./chunk-hmr.cjs');
 require('tty');
+require('perf_hooks');
 require('pathe');
 require('debug');
 require('fs');
@@ -629,7 +630,7 @@ class CAC extends events.EventEmitter {
 
 const cac = (name = "") => new CAC(name);
 
-var version = "0.22.0";
+var version = "0.23.1";
 
 const cli = cac("vite-node");
 cli.version(version).option("-r, --root <path>", "Use specified root directory").option("-c, --config <path>", "Use specified config file").option("-w, --watch", 'Restart on file changes, similar to "nodemon"').option("--options <options>", "Use specified Vite server options").help();

package/dist/cli.d.ts

@@ -1,4 +1,4 @@
-import { e as ViteNodeServerOptions } from './types-24fd0349.js';
+import { e as ViteNodeServerOptions } from './types-dca976ee.js';
 
 interface CliOptions {
     root?: string;

package/dist/cli.mjs

@@ -6,6 +6,7 @@ import { ViteNodeRunner } from './client.mjs';
 import { toArray } from './utils.mjs';
 import { v as viteNodeHmrPlugin, c as createHotContext, h as handleMessage } from './chunk-hmr.mjs';
 import 'tty';
+import 'perf_hooks';
 import 'pathe';
 import 'debug';
 import 'fs';
@@ -627,7 +628,7 @@ class CAC extends EventEmitter {
 
 const cac = (name = "") => new CAC(name);
 
-var version = "0.22.0";
+var version = "0.23.1";
 
 const cli = cac("vite-node");
 cli.version(version).option("-r, --root <path>", "Use specified root directory").option("-c, --config <path>", "Use specified config file").option("-w, --watch", 'Restart on file changes, similar to "nodemon"').option("--options <options>", "Use specified Vite server options").help();

package/dist/client.cjs

@@ -73,7 +73,7 @@ class ModuleCacheMap extends Map {
   normalizePath(fsPath) {
     return utils.normalizeModuleId(fsPath);
   }
-  set(fsPath, mod) {
+  update(fsPath, mod) {
     fsPath = this.normalizePath(fsPath);
     if (!super.has(fsPath))
       super.set(fsPath, mod);
@@ -81,14 +81,48 @@ class ModuleCacheMap extends Map {
       Object.assign(super.get(fsPath), mod);
     return this;
   }
+  set(fsPath, mod) {
+    fsPath = this.normalizePath(fsPath);
+    return super.set(fsPath, mod);
+  }
   get(fsPath) {
     fsPath = this.normalizePath(fsPath);
+    if (!super.has(fsPath))
+      super.set(fsPath, {});
     return super.get(fsPath);
   }
   delete(fsPath) {
     fsPath = this.normalizePath(fsPath);
     return super.delete(fsPath);
   }
+  invalidateDepTree(ids, invalidated = /* @__PURE__ */ new Set()) {
+    for (const _id of ids) {
+      const id = this.normalizePath(_id);
+      if (invalidated.has(id))
+        continue;
+      invalidated.add(id);
+      const mod = super.get(id);
+      if (mod == null ? void 0 : mod.importers)
+        this.invalidateDepTree(mod.importers, invalidated);
+      super.delete(id);
+    }
+    return invalidated;
+  }
+  invalidateSubDepTree(ids, invalidated = /* @__PURE__ */ new Set()) {
+    for (const _id of ids) {
+      const id = this.normalizePath(_id);
+      if (invalidated.has(id))
+        continue;
+      invalidated.add(id);
+      const subIds = Array.from(super.entries()).filter(([, mod]) => {
+        var _a;
+        return (_a = mod.importers) == null ? void 0 : _a.has(id);
+      }).map(([key]) => key);
+      subIds.length && this.invalidateSubDepTree(subIds, invalidated);
+      super.delete(id);
+    }
+    return invalidated;
+  }
 }
 class ViteNodeRunner {
   constructor(options) {
@@ -104,39 +138,44 @@ class ViteNodeRunner {
     return await this.cachedRequest(id, []);
   }
   async cachedRequest(rawId, callstack) {
-    var _a, _b, _c, _d;
     const id = utils.normalizeRequestId(rawId, this.options.base);
     const fsPath = utils.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 mod = this.moduleCache.get(fsPath);
+    const importee = callstack[callstack.length - 1];
+    if (!mod.importers)
+      mod.importers = /* @__PURE__ */ new Set();
+    if (importee)
+      mod.importers.add(importee);
+    if (callstack.includes(fsPath) && mod.exports)
+      return mod.exports;
+    if (mod.promise)
+      return mod.promise;
     const promise = this.directRequest(id, fsPath, callstack);
-    this.moduleCache.set(fsPath, { promise });
+    Object.assign(mod, { promise });
     return await promise;
   }
   async directRequest(id, fsPath, _callstack) {
     const callstack = [..._callstack, fsPath];
+    const mod = this.moduleCache.get(fsPath);
     const request = async (dep) => {
       var _a;
-      const fsPath2 = utils.toFilePath(utils.normalizeRequestId(dep, this.options.base), this.root);
+      const depFsPath = utils.toFilePath(utils.normalizeRequestId(dep, this.options.base), this.root);
       const getStack = () => {
         return `stack:
-${[...callstack, fsPath2].reverse().map((p) => `- ${p}`).join("\n")}`;
+${[...callstack, depFsPath].reverse().map((p) => `- ${p}`).join("\n")}`;
       };
       let debugTimer;
       if (this.debug)
-        debugTimer = setTimeout(() => console.warn(() => `module ${fsPath2} takes over 2s to load.
+        debugTimer = setTimeout(() => console.warn(() => `module ${depFsPath} 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 (callstack.includes(depFsPath)) {
+          const depExports = (_a = this.moduleCache.get(depFsPath)) == 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;
+        return await this.cachedRequest(dep, callstack);
       } finally {
         if (debugTimer)
           clearTimeout(debugTimer);
@@ -160,9 +199,9 @@ ${getStack()}`), 2e3);
     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;
+      const exports2 = await this.interopedImport(externalize);
+      mod.exports = exports2;
+      return exports2;
     }
     if (transformed == null)
       throw new Error(`[vite-node] Failed to load ${id}`);
@@ -174,15 +213,34 @@ ${getStack()}`), 2e3);
       enumerable: false,
       configurable: false
     });
-    this.moduleCache.set(fsPath, { code: transformed, exports });
+    const cjsExports = new Proxy(exports, {
+      get(_, p, receiver) {
+        return Reflect.get(exports, p, receiver);
+      },
+      set(_, p, value) {
+        if (p !== "default") {
+          if (!Reflect.has(exports, "default"))
+            exports.default = {};
+          if (exports.default === null || typeof exports.default !== "object") {
+            defineExport(exports, p, () => void 0);
+            return true;
+          }
+          exports.default[p] = value;
+          defineExport(exports, p, () => value);
+          return true;
+        }
+        return Reflect.set(exports, p, value);
+      }
+    });
+    Object.assign(mod, { code: transformed, exports });
     const __filename = url.fileURLToPath(url$1);
     const moduleProxy = {
       set exports(value) {
-        exportAll(exports, value);
-        exports.default = value;
+        exportAll(cjsExports, value);
+        cjsExports.default = value;
       },
       get exports() {
-        return exports;
+        return cjsExports;
       }
     };
     let hotContext;
@@ -204,7 +262,7 @@ ${getStack()}`), 2e3);
       __vite_ssr_import_meta__: meta,
       __vitest_resolve_id__: resolveId,
       require: module$1.createRequire(url$1),
-      exports,
+      exports: cjsExports,
       module: moduleProxy,
       __filename,
       __dirname: pathe.dirname(__filename)
@@ -260,19 +318,22 @@ function proxyMethod(name, tryDefault) {
     return result;
   };
 }
+function defineExport(exports, key, value) {
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    configurable: true,
+    get: value
+  });
+}
 function exportAll(exports, sourceModule) {
   if (exports === sourceModule)
     return;
+  if (typeof sourceModule !== "object" || Array.isArray(sourceModule) || !sourceModule)
+    return;
   for (const key in sourceModule) {
     if (key !== "default") {
       try {
-        Object.defineProperty(exports, key, {
-          enumerable: true,
-          configurable: true,
-          get() {
-            return sourceModule[key];
-          }
-        });
+        defineExport(exports, key, () => sourceModule[key]);
       } catch (_err) {
       }
     }

package/dist/client.d.ts

@@ -1 +1 @@
-export { j as DEFAULT_REQUEST_STUBS, M as ModuleCacheMap, h as ViteNodeRunner } from './types-24fd0349.js';
+export { j as DEFAULT_REQUEST_STUBS, M as ModuleCacheMap, h as ViteNodeRunner } from './types-dca976ee.js';

package/dist/client.mjs

@@ -46,7 +46,7 @@ class ModuleCacheMap extends Map {
   normalizePath(fsPath) {
     return normalizeModuleId(fsPath);
   }
-  set(fsPath, mod) {
+  update(fsPath, mod) {
     fsPath = this.normalizePath(fsPath);
     if (!super.has(fsPath))
       super.set(fsPath, mod);
@@ -54,14 +54,48 @@ class ModuleCacheMap extends Map {
       Object.assign(super.get(fsPath), mod);
     return this;
   }
+  set(fsPath, mod) {
+    fsPath = this.normalizePath(fsPath);
+    return super.set(fsPath, mod);
+  }
   get(fsPath) {
     fsPath = this.normalizePath(fsPath);
+    if (!super.has(fsPath))
+      super.set(fsPath, {});
     return super.get(fsPath);
   }
   delete(fsPath) {
     fsPath = this.normalizePath(fsPath);
     return super.delete(fsPath);
   }
+  invalidateDepTree(ids, invalidated = /* @__PURE__ */ new Set()) {
+    for (const _id of ids) {
+      const id = this.normalizePath(_id);
+      if (invalidated.has(id))
+        continue;
+      invalidated.add(id);
+      const mod = super.get(id);
+      if (mod == null ? void 0 : mod.importers)
+        this.invalidateDepTree(mod.importers, invalidated);
+      super.delete(id);
+    }
+    return invalidated;
+  }
+  invalidateSubDepTree(ids, invalidated = /* @__PURE__ */ new Set()) {
+    for (const _id of ids) {
+      const id = this.normalizePath(_id);
+      if (invalidated.has(id))
+        continue;
+      invalidated.add(id);
+      const subIds = Array.from(super.entries()).filter(([, mod]) => {
+        var _a;
+        return (_a = mod.importers) == null ? void 0 : _a.has(id);
+      }).map(([key]) => key);
+      subIds.length && this.invalidateSubDepTree(subIds, invalidated);
+      super.delete(id);
+    }
+    return invalidated;
+  }
 }
 class ViteNodeRunner {
   constructor(options) {
@@ -77,39 +111,44 @@ class ViteNodeRunner {
     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 mod = this.moduleCache.get(fsPath);
+    const importee = callstack[callstack.length - 1];
+    if (!mod.importers)
+      mod.importers = /* @__PURE__ */ new Set();
+    if (importee)
+      mod.importers.add(importee);
+    if (callstack.includes(fsPath) && mod.exports)
+      return mod.exports;
+    if (mod.promise)
+      return mod.promise;
     const promise = this.directRequest(id, fsPath, callstack);
-    this.moduleCache.set(fsPath, { promise });
+    Object.assign(mod, { promise });
     return await promise;
   }
   async directRequest(id, fsPath, _callstack) {
     const callstack = [..._callstack, fsPath];
+    const mod = this.moduleCache.get(fsPath);
     const request = async (dep) => {
       var _a;
-      const fsPath2 = toFilePath(normalizeRequestId(dep, this.options.base), this.root);
+      const depFsPath = toFilePath(normalizeRequestId(dep, this.options.base), this.root);
       const getStack = () => {
         return `stack:
-${[...callstack, fsPath2].reverse().map((p) => `- ${p}`).join("\n")}`;
+${[...callstack, depFsPath].reverse().map((p) => `- ${p}`).join("\n")}`;
       };
       let debugTimer;
       if (this.debug)
-        debugTimer = setTimeout(() => console.warn(() => `module ${fsPath2} takes over 2s to load.
+        debugTimer = setTimeout(() => console.warn(() => `module ${depFsPath} 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 (callstack.includes(depFsPath)) {
+          const depExports = (_a = this.moduleCache.get(depFsPath)) == 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;
+        return await this.cachedRequest(dep, callstack);
       } finally {
         if (debugTimer)
           clearTimeout(debugTimer);
@@ -133,9 +172,9 @@ ${getStack()}`), 2e3);
     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;
+      const exports2 = await this.interopedImport(externalize);
+      mod.exports = exports2;
+      return exports2;
     }
     if (transformed == null)
       throw new Error(`[vite-node] Failed to load ${id}`);
@@ -147,15 +186,34 @@ ${getStack()}`), 2e3);
       enumerable: false,
       configurable: false
     });
-    this.moduleCache.set(fsPath, { code: transformed, exports });
+    const cjsExports = new Proxy(exports, {
+      get(_, p, receiver) {
+        return Reflect.get(exports, p, receiver);
+      },
+      set(_, p, value) {
+        if (p !== "default") {
+          if (!Reflect.has(exports, "default"))
+            exports.default = {};
+          if (exports.default === null || typeof exports.default !== "object") {
+            defineExport(exports, p, () => void 0);
+            return true;
+          }
+          exports.default[p] = value;
+          defineExport(exports, p, () => value);
+          return true;
+        }
+        return Reflect.set(exports, p, value);
+      }
+    });
+    Object.assign(mod, { code: transformed, exports });
     const __filename = fileURLToPath(url);
     const moduleProxy = {
       set exports(value) {
-        exportAll(exports, value);
-        exports.default = value;
+        exportAll(cjsExports, value);
+        cjsExports.default = value;
       },
       get exports() {
-        return exports;
+        return cjsExports;
       }
     };
     let hotContext;
@@ -177,7 +235,7 @@ ${getStack()}`), 2e3);
       __vite_ssr_import_meta__: meta,
       __vitest_resolve_id__: resolveId,
       require: createRequire(url),
-      exports,
+      exports: cjsExports,
       module: moduleProxy,
       __filename,
       __dirname: dirname(__filename)
@@ -233,19 +291,22 @@ function proxyMethod(name, tryDefault) {
     return result;
   };
 }
+function defineExport(exports, key, value) {
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    configurable: true,
+    get: value
+  });
+}
 function exportAll(exports, sourceModule) {
   if (exports === sourceModule)
     return;
+  if (typeof sourceModule !== "object" || Array.isArray(sourceModule) || !sourceModule)
+    return;
   for (const key in sourceModule) {
     if (key !== "default") {
       try {
-        Object.defineProperty(exports, key, {
-          enumerable: true,
-          configurable: true,
-          get() {
-            return sourceModule[key];
-          }
-        });
+        defineExport(exports, key, () => sourceModule[key]);
       } catch (_err) {
       }
     }

package/dist/hmr.d.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'events';
 import { HMRPayload, Plugin } from 'vite';
-import { U as UpdatePayload, P as PrunePayload, g as FullReloadPayload, E as ErrorPayload, h as ViteNodeRunner, i as HMRPayload$1, H as HotContext } from './types-24fd0349.js';
+import { U as UpdatePayload, P as PrunePayload, g as FullReloadPayload, E as ErrorPayload, h as ViteNodeRunner, i as HMRPayload$1, H as HotContext } from './types-dca976ee.js';
 
 declare type EventType = string | symbol;
 declare type Handler<T = unknown> = (event: T) => void;

package/dist/index.d.ts

@@ -1 +1 @@
-export { A as Arrayable, C as CreateHotContextFunction, f as DebuggerOptions, D as DepsHandlingOptions, a as FetchFunction, F as FetchResult, H as HotContext, c as ModuleCache, M as ModuleCacheMap, N as Nullable, R as RawSourceMap, b as ResolveIdFunction, S as StartOfSourceMap, d as ViteNodeResolveId, V as ViteNodeRunnerOptions, e as ViteNodeServerOptions } from './types-24fd0349.js';
+export { A as Arrayable, C as CreateHotContextFunction, f as DebuggerOptions, D as DepsHandlingOptions, a as FetchFunction, F as FetchResult, H as HotContext, c as ModuleCache, M as ModuleCacheMap, N as Nullable, R as RawSourceMap, b as ResolveIdFunction, S as StartOfSourceMap, d as ViteNodeResolveId, V as ViteNodeRunnerOptions, e as ViteNodeServerOptions } from './types-dca976ee.js';

package/dist/server.cjs

@@ -2,6 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var perf_hooks = require('perf_hooks');
 var pathe = require('pathe');
 var createDebug = require('debug');
 var fs = require('fs');
@@ -141,19 +142,25 @@ class ViteNodeServer {
   }
   async fetchModule(id) {
     if (!this.fetchPromiseMap.has(id)) {
-      this.fetchPromiseMap.set(id, this._fetchModule(id).then((r) => {
-        return this.options.sourcemap !== true ? { ...r, map: void 0 } : r;
-      }).finally(() => {
-        this.fetchPromiseMap.delete(id);
-      }));
+      this.fetchPromiseMap.set(
+        id,
+        this._fetchModule(id).then((r) => {
+          return this.options.sourcemap !== true ? { ...r, map: void 0 } : r;
+        }).finally(() => {
+          this.fetchPromiseMap.delete(id);
+        })
+      );
     }
     return this.fetchPromiseMap.get(id);
   }
   async transformRequest(id) {
     if (!this.transformPromiseMap.has(id)) {
-      this.transformPromiseMap.set(id, this._transformRequest(id).finally(() => {
-        this.transformPromiseMap.delete(id);
-      }));
+      this.transformPromiseMap.set(
+        id,
+        this._transformRequest(id).finally(() => {
+          this.transformPromiseMap.delete(id);
+        })
+      );
     }
     return this.transformPromiseMap.get(id);
   }
@@ -178,14 +185,18 @@ class ViteNodeServer {
     if (timestamp && cache && cache.timestamp >= timestamp)
       return cache.result;
     const externalize = await this.shouldExternalize(filePath);
+    let duration;
     if (externalize) {
       result = { externalize };
       (_a = this.debugger) == null ? void 0 : _a.recordExternalize(id, externalize);
     } else {
+      const start = perf_hooks.performance.now();
       const r = await this._transformRequest(id);
+      duration = perf_hooks.performance.now() - start;
       result = { code: r == null ? void 0 : r.code, map: r == null ? void 0 : r.map };
     }
     this.fetchCache.set(filePath, {
+      duration,
       timestamp,
       result
     });

package/dist/server.d.ts

@@ -1,5 +1,5 @@
 import { TransformResult, ViteDevServer } from 'vite';
-import { f as DebuggerOptions, D as DepsHandlingOptions, e as ViteNodeServerOptions, F as FetchResult, d as ViteNodeResolveId } from './types-24fd0349.js';
+import { f as DebuggerOptions, D as DepsHandlingOptions, e as ViteNodeServerOptions, F as FetchResult, d as ViteNodeResolveId } from './types-dca976ee.js';
 
 declare class Debugger {
     options: DebuggerOptions;
@@ -24,6 +24,7 @@ declare class ViteNodeServer {
     private fetchPromiseMap;
     private transformPromiseMap;
     fetchCache: Map<string, {
+        duration?: number | undefined;
         timestamp: number;
         result: FetchResult;
     }>;

package/dist/server.mjs

@@ -1,3 +1,4 @@
+import { performance } from 'perf_hooks';
 import { resolve } from 'pathe';
 import createDebug from 'debug';
 import { existsSync } from 'fs';
@@ -133,19 +134,25 @@ class ViteNodeServer {
   }
   async fetchModule(id) {
     if (!this.fetchPromiseMap.has(id)) {
-      this.fetchPromiseMap.set(id, this._fetchModule(id).then((r) => {
-        return this.options.sourcemap !== true ? { ...r, map: void 0 } : r;
-      }).finally(() => {
-        this.fetchPromiseMap.delete(id);
-      }));
+      this.fetchPromiseMap.set(
+        id,
+        this._fetchModule(id).then((r) => {
+          return this.options.sourcemap !== true ? { ...r, map: void 0 } : r;
+        }).finally(() => {
+          this.fetchPromiseMap.delete(id);
+        })
+      );
     }
     return this.fetchPromiseMap.get(id);
   }
   async transformRequest(id) {
     if (!this.transformPromiseMap.has(id)) {
-      this.transformPromiseMap.set(id, this._transformRequest(id).finally(() => {
-        this.transformPromiseMap.delete(id);
-      }));
+      this.transformPromiseMap.set(
+        id,
+        this._transformRequest(id).finally(() => {
+          this.transformPromiseMap.delete(id);
+        })
+      );
     }
     return this.transformPromiseMap.get(id);
   }
@@ -170,14 +177,18 @@ class ViteNodeServer {
     if (timestamp && cache && cache.timestamp >= timestamp)
       return cache.result;
     const externalize = await this.shouldExternalize(filePath);
+    let duration;
     if (externalize) {
       result = { externalize };
       (_a = this.debugger) == null ? void 0 : _a.recordExternalize(id, externalize);
     } else {
+      const start = performance.now();
       const r = await this._transformRequest(id);
+      duration = performance.now() - start;
       result = { code: r == null ? void 0 : r.code, map: r == null ? void 0 : r.map };
     }
     this.fetchCache.set(filePath, {
+      duration,
       timestamp,
       result
     });

package/dist/{types-24fd0349.d.ts → types-dca976ee.d.ts}

@@ -114,9 +114,21 @@ declare const DEFAULT_REQUEST_STUBS: {
 };
 declare class ModuleCacheMap extends Map<string, ModuleCache> {
     normalizePath(fsPath: string): string;
-    set(fsPath: string, mod: Partial<ModuleCache>): this;
-    get(fsPath: string): ModuleCache | undefined;
+    /**
+     * Assign partial data to the map
+     */
+    update(fsPath: string, mod: Partial<ModuleCache>): this;
+    set(fsPath: string, mod: ModuleCache): this;
+    get(fsPath: string): ModuleCache;
     delete(fsPath: string): boolean;
+    /**
+     * Invalidate modules that dependent on the given modules, up to the main entry
+     */
+    invalidateDepTree(ids: string[] | Set<string>, invalidated?: Set<string>): Set<string>;
+    /**
+     * Invalidate dependency modules of the given modules, down to the bottom-level dependencies
+     */
+    invalidateSubDepTree(ids: string[] | Set<string>, invalidated?: Set<string>): Set<string>;
 }
 declare class ViteNodeRunner {
     options: ViteNodeRunnerOptions;
@@ -183,6 +195,10 @@ interface ModuleCache {
     promise?: Promise<any>;
     exports?: any;
     code?: string;
+    /**
+     * Module ids that imports this module
+     */
+    importers?: Set<string>;
 }
 interface ViteNodeRunnerOptions {
     root: string;

package/dist/types.d.ts

@@ -1 +1 @@
-export { A as Arrayable, C as CreateHotContextFunction, f as DebuggerOptions, D as DepsHandlingOptions, a as FetchFunction, F as FetchResult, H as HotContext, c as ModuleCache, M as ModuleCacheMap, N as Nullable, R as RawSourceMap, b as ResolveIdFunction, S as StartOfSourceMap, d as ViteNodeResolveId, V as ViteNodeRunnerOptions, e as ViteNodeServerOptions } from './types-24fd0349.js';
+export { A as Arrayable, C as CreateHotContextFunction, f as DebuggerOptions, D as DepsHandlingOptions, a as FetchFunction, F as FetchResult, H as HotContext, c as ModuleCache, M as ModuleCacheMap, N as Nullable, R as RawSourceMap, b as ResolveIdFunction, S as StartOfSourceMap, d as ViteNodeResolveId, V as ViteNodeRunnerOptions, e as ViteNodeServerOptions } from './types-dca976ee.js';

package/dist/utils.cjs

@@ -4,6 +4,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var url = require('url');
 var pathe = require('pathe');
+var mlly = require('mlly');
 
 const isWindows = process.platform === "win32";
 function slash(str) {
@@ -23,6 +24,23 @@ function normalizeModuleId(id) {
 function isPrimitive(v) {
   return v !== Object(v);
 }
+function pathFromRoot(root, filename) {
+  if (mlly.isNodeBuiltin(filename))
+    return filename;
+  filename = filename.replace(/^\/@fs\//, isWindows ? "" : "/");
+  if (!filename.startsWith(root))
+    return filename;
+  const relativePath = pathe.relative(root, filename);
+  if (!relativePath.startsWith("/") && !relativePath.startsWith("."))
+    return `/${relativePath}`;
+  let index = 0;
+  for (const char of relativePath) {
+    if (char !== "." && char !== "/")
+      return relativePath.slice(index - 1);
+    index++;
+  }
+  return relativePath;
+}
 function toFilePath(id, root) {
   let absolute = id.startsWith("/@fs/") ? id.slice(4) : id.startsWith(root) ? id : id.startsWith("/") ? pathe.resolve(root, id.slice(1)) : id;
   if (absolute.startsWith("//"))
@@ -55,6 +73,7 @@ exports.isWindows = isWindows;
 exports.mergeSlashes = mergeSlashes;
 exports.normalizeModuleId = normalizeModuleId;
 exports.normalizeRequestId = normalizeRequestId;
+exports.pathFromRoot = pathFromRoot;
 exports.slash = slash;
 exports.toArray = toArray;
 exports.toFilePath = toFilePath;

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
 import { TransformResult } from 'vite';
-import { N as Nullable, A as Arrayable } from './types-24fd0349.js';
+import { N as Nullable, A as Arrayable } from './types-dca976ee.js';
 
 declare const isWindows: boolean;
 declare function slash(str: string): string;
@@ -7,6 +7,7 @@ declare function mergeSlashes(str: string): string;
 declare function normalizeRequestId(id: string, base?: string): string;
 declare function normalizeModuleId(id: string): string;
 declare function isPrimitive(v: any): boolean;
+declare function pathFromRoot(root: string, filename: string): string;
 declare function toFilePath(id: string, root: string): string;
 declare function withInlineSourcemap(result: TransformResult): Promise<TransformResult>;
 /**
@@ -16,4 +17,4 @@ declare function withInlineSourcemap(result: TransformResult): Promise<Transform
  */
 declare function toArray<T>(array?: Nullable<Arrayable<T>>): Array<T>;
 
-export { isPrimitive, isWindows, mergeSlashes, normalizeModuleId, normalizeRequestId, slash, toArray, toFilePath, withInlineSourcemap };
+export { isPrimitive, isWindows, mergeSlashes, normalizeModuleId, normalizeRequestId, pathFromRoot, slash, toArray, toFilePath, withInlineSourcemap };

package/dist/utils.mjs

@@ -1,5 +1,6 @@
 import { fileURLToPath, pathToFileURL } from 'url';
-import { resolve } from 'pathe';
+import { relative, resolve } from 'pathe';
+import { isNodeBuiltin } from 'mlly';
 
 const isWindows = process.platform === "win32";
 function slash(str) {
@@ -19,6 +20,23 @@ function normalizeModuleId(id) {
 function isPrimitive(v) {
   return v !== Object(v);
 }
+function pathFromRoot(root, filename) {
+  if (isNodeBuiltin(filename))
+    return filename;
+  filename = filename.replace(/^\/@fs\//, isWindows ? "" : "/");
+  if (!filename.startsWith(root))
+    return filename;
+  const relativePath = relative(root, filename);
+  if (!relativePath.startsWith("/") && !relativePath.startsWith("."))
+    return `/${relativePath}`;
+  let index = 0;
+  for (const char of relativePath) {
+    if (char !== "." && char !== "/")
+      return relativePath.slice(index - 1);
+    index++;
+  }
+  return relativePath;
+}
 function toFilePath(id, root) {
   let absolute = id.startsWith("/@fs/") ? id.slice(4) : id.startsWith(root) ? id : id.startsWith("/") ? resolve(root, id.slice(1)) : id;
   if (absolute.startsWith("//"))
@@ -46,4 +64,4 @@ function toArray(array) {
   return [array];
 }
 
-export { isPrimitive, isWindows, mergeSlashes, normalizeModuleId, normalizeRequestId, slash, toArray, toFilePath, withInlineSourcemap };
+export { isPrimitive, isWindows, mergeSlashes, normalizeModuleId, normalizeRequestId, pathFromRoot, slash, toArray, toFilePath, withInlineSourcemap };

package/index.d.ts

@@ -0,0 +1 @@
+export { DepsHandlingOptions, FetchFunction, FetchResult, ModuleCache, RawSourceMap, ResolveIdFunction, StartOfSourceMap, ViteNodeResolveId, ViteNodeRunnerOptions, ViteNodeServerOptions } from './types.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-node",
-  "version": "0.22.0",
+  "version": "0.23.1",
   "description": "Vite as Node.js runtime",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -65,15 +65,15 @@
   },
   "dependencies": {
     "debug": "^4.3.4",
-    "mlly": "^0.5.12",
+    "mlly": "^0.5.14",
     "pathe": "^0.2.0",
     "vite": "^2.9.12 || ^3.0.0-0"
   },
   "devDependencies": {
     "@types/debug": "^4.1.7",
-    "cac": "^6.7.12",
+    "cac": "^6.7.14",
     "picocolors": "^1.0.0",
-    "rollup": "^2.77.3"
+    "rollup": "^2.78.1"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",

package/server.d.ts

@@ -0,0 +1,26 @@
+import { ViteDevServer, TransformResult } from 'vite';
+import { DepsHandlingOptions, ViteNodeServerOptions, FetchResult, ViteNodeResolveId } from './types.js';
+
+declare function guessCJSversion(id: string): string | undefined;
+declare function shouldExternalize(id: string, options?: DepsHandlingOptions, cache?: Map<string, Promise<string | false>>): Promise<string | false>;
+
+declare class ViteNodeServer {
+    server: ViteDevServer;
+    options: ViteNodeServerOptions;
+    private fetchPromiseMap;
+    private transformPromiseMap;
+    fetchCache: Map<string, {
+        timestamp: number;
+        result: FetchResult;
+    }>;
+    constructor(server: ViteDevServer, options?: ViteNodeServerOptions);
+    shouldExternalize(id: string): Promise<string | false>;
+    resolveId(id: string, importer?: string): Promise<ViteNodeResolveId | null>;
+    fetchModule(id: string): Promise<FetchResult>;
+    transformRequest(id: string): Promise<TransformResult | null | undefined>;
+    getTransformMode(id: string): "web" | "ssr";
+    private _fetchModule;
+    private _transformRequest;
+}
+
+export { ViteNodeServer, guessCJSversion, shouldExternalize };

package/types.d.ts

@@ -0,0 +1,68 @@
+interface DepsHandlingOptions {
+    external?: (string | RegExp)[];
+    inline?: (string | RegExp)[];
+    /**
+     * Try to guess the CJS version of a package when it's invalid ESM
+     * @default true
+     */
+    fallbackCJS?: boolean;
+}
+interface StartOfSourceMap {
+    file?: string;
+    sourceRoot?: string;
+}
+interface RawSourceMap extends StartOfSourceMap {
+    version: string;
+    sources: string[];
+    names: string[];
+    sourcesContent?: string[];
+    mappings: string;
+}
+interface FetchResult {
+    code?: string;
+    externalize?: string;
+    map?: RawSourceMap;
+}
+declare type FetchFunction = (id: string) => Promise<FetchResult>;
+declare type ResolveIdFunction = (id: string, importer?: string) => Promise<ViteNodeResolveId | null>;
+interface ModuleCache {
+    promise?: Promise<any>;
+    exports?: any;
+    code?: string;
+}
+interface ViteNodeRunnerOptions {
+    fetchModule: FetchFunction;
+    resolveId: ResolveIdFunction;
+    root: string;
+    base?: string;
+    moduleCache?: Map<string, ModuleCache>;
+    interopDefault?: boolean;
+    requestStubs?: Record<string, any>;
+}
+interface ViteNodeResolveId {
+    external?: boolean | 'absolute' | 'relative';
+    id: string;
+    meta?: Record<string, any> | null;
+    moduleSideEffects?: boolean | 'no-treeshake' | null;
+    syntheticNamedExports?: boolean | string | null;
+}
+interface ViteNodeServerOptions {
+    /**
+     * Inject inline sourcemap to modules
+     * @default 'inline'
+     */
+    sourcemap?: 'inline' | boolean;
+    /**
+     * Deps handling
+     */
+    deps?: DepsHandlingOptions;
+    /**
+     * Transform method for modules
+     */
+    transformMode?: {
+        ssr?: RegExp[];
+        web?: RegExp[];
+    };
+}
+
+export { DepsHandlingOptions, FetchFunction, FetchResult, ModuleCache, RawSourceMap, ResolveIdFunction, StartOfSourceMap, ViteNodeResolveId, ViteNodeRunnerOptions, ViteNodeServerOptions };

package/utils.d.ts

@@ -0,0 +1,10 @@
+import { TransformResult } from 'vite';
+
+declare const isWindows: boolean;
+declare function slash(str: string): string;
+declare function normalizeId(id: string, base?: string): string;
+declare function isPrimitive(v: any): boolean;
+declare function toFilePath(id: string, root: string): string;
+declare function withInlineSourcemap(result: TransformResult): Promise<TransformResult>;
+
+export { isPrimitive, isWindows, normalizeId, slash, toFilePath, withInlineSourcemap };