vite-node 0.34.3 → 0.34.5

package/README.md

@@ -40,7 +40,7 @@ npx vite-node -h
 
 ### Options via CLI
 
-[All `ViteNodeServer` options](https://github.com/vitest-dev/vitest/blob/main/packages/vite-node/src/types.ts#L70-L89) are supported by the CLI. They may be defined through the dot syntax, as shown below:
+[All `ViteNodeServer` options](https://github.com/vitest-dev/vitest/blob/main/packages/vite-node/src/types.ts#L92-L111) are supported by the CLI. They may be defined through the dot syntax, as shown below:
 
 ```bash
 npx vite-node --options.deps.inline="module-name" --options.deps.external="/module-regexp/" index.ts
@@ -130,7 +130,7 @@ await server.close()
 
 Sometimes you might want to inspect the transformed code to investigate issues. You can set environment variable `VITE_NODE_DEBUG_DUMP=true` to let vite-node write the transformed result of each module under `.vite-node/dump`.
 
-If you want to debug by modifying the dumped code, you can change the value of `VITE_NODE_DEBUG_DUMP` to `load` and search for the dumpped files and use them for executing.
+If you want to debug by modifying the dumped code, you can change the value of `VITE_NODE_DEBUG_DUMP` to `load` and search for the dumped files and use them for executing.
 
 ```bash
 VITE_NODE_DEBUG_DUMP=load vite-node example.ts
@@ -151,7 +151,7 @@ const server = new ViteNodeServer(viteServer, {
 
 ### Debug Execution
 
-If the process get stuck, it might because there is a unresolvable circular dependencies, you can set `VITE_NODE_DEBUG_RUNNER=true` to vite-node warn about it.
+If the process gets stuck, it might be because there are unresolvable circular dependencies. You can set `VITE_NODE_DEBUG_RUNNER=true` for vite-node to warn about this.
 
 ```bash
 VITE_NODE_DEBUG_RUNNER=true vite-node example.ts

package/dist/cli.cjs

@@ -7,27 +7,22 @@ var server = require('./server.cjs');
 var client = require('./client.cjs');
 var utils = require('./utils.cjs');
 var sourceMap = require('./source-map.cjs');
-var hmr = require('./chunk-hmr.cjs');
+var hmr = require('./hmr.cjs');
 require('perf_hooks');
 require('fs');
 require('pathe');
 require('debug');
 require('mlly');
 require('./constants.cjs');
-require('node:url');
 require('module');
 require('path');
+require('node:url');
 require('node:vm');
 require('node:events');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var cac__default = /*#__PURE__*/_interopDefaultLegacy(cac);
-var c__default = /*#__PURE__*/_interopDefaultLegacy(c);
-
-var version = "0.34.3";
+var version = "0.34.5";
 
-const cli = cac__default["default"]("vite-node");
+const cli = cac("vite-node");
 cli.option("-r, --root <path>", "Use specified root directory").option("-c, --config <path>", "Use specified config file").option("-m, --mode <mode>", "Set env mode").option("-w, --watch", 'Restart on file changes, similar to "nodemon"').option("--script", "Use vite-node as a script runner").option("--options <options>", "Use specified Vite server options").option("-v, --version", "Output the version number").option("-h, --help", "Display help for command");
 cli.command("[...files]").allowUnknownOptions().action(run);
 cli.parse(process.argv, { run: false });
@@ -58,7 +53,7 @@ async function run(files, options = {}) {
     process.exit(0);
   }
   if (!files.length) {
-    console.error(c__default["default"].red("No files specified."));
+    console.error(c.red("No files specified."));
     cli.version(version).outputHelp();
     process.exit(1);
   }
@@ -103,7 +98,7 @@ async function run(files, options = {}) {
   });
   if (options.watch) {
     process.on("uncaughtException", (err) => {
-      console.error(c__default["default"].red("[vite-node] Failed to execute file: \n"), err);
+      console.error(c.red("[vite-node] Failed to execute file: \n"), err);
     });
   }
 }

package/dist/cli.d.ts

@@ -1,5 +1,5 @@
-import { f as ViteNodeServerOptions } from './types-2dc895bd.js';
-import './types.d-7442d07f.js';
+import { V as ViteNodeServerOptions } from './index-6fb787b2.js';
+import './trace-mapping.d-e677e8f4.js';
 
 interface CliOptions {
     root?: string;

package/dist/cli.mjs

@@ -5,20 +5,20 @@ import { ViteNodeServer } from './server.mjs';
 import { ViteNodeRunner } from './client.mjs';
 import { toArray } from './utils.mjs';
 import { installSourcemapsSupport } from './source-map.mjs';
-import { v as viteNodeHmrPlugin, c as createHotContext, h as handleMessage } from './chunk-hmr.mjs';
+import { viteNodeHmrPlugin, createHotContext, handleMessage } from './hmr.mjs';
 import 'node:perf_hooks';
 import 'node:fs';
 import 'pathe';
 import 'debug';
 import 'mlly';
 import './constants.mjs';
-import 'node:url';
 import 'node:module';
 import 'node:path';
+import 'node:url';
 import 'node:vm';
 import 'node:events';
 
-var version = "0.34.3";
+var version = "0.34.5";
 
 const cli = cac("vite-node");
 cli.option("-r, --root <path>", "Use specified root directory").option("-c, --config <path>", "Use specified config file").option("-m, --mode <mode>", "Set env mode").option("-w, --watch", 'Restart on file changes, similar to "nodemon"').option("--script", "Use vite-node as a script runner").option("--options <options>", "Use specified Vite server options").option("-v, --version", "Output the version number").option("-h, --help", "Display help for command");

package/dist/client.cjs

@@ -1,7 +1,5 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var module$1 = require('module');
 var path = require('path');
 var node_url = require('node:url');
@@ -12,32 +10,9 @@ var utils = require('./utils.cjs');
 var sourceMap = require('./source-map.cjs');
 require('fs');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
-
-var vm__default = /*#__PURE__*/_interopDefaultLegacy(vm);
-var createDebug__default = /*#__PURE__*/_interopDefaultLegacy(createDebug);
-
 const { setTimeout, clearTimeout } = globalThis;
-const debugExecute = createDebug__default["default"]("vite-node:client:execute");
-const debugNative = createDebug__default["default"]("vite-node:client:native");
+const debugExecute = createDebug("vite-node:client:execute");
+const debugNative = createDebug("vite-node:client:native");
 const clientStub = {
   injectQuery: (id) => id,
   createHotContext: () => {
@@ -365,7 +340,7 @@ ${getStack()}`), 2e3);
       lineOffset: 0,
       columnOffset: -codeDefinition.length
     };
-    const fn = vm__default["default"].runInThisContext(code, options);
+    const fn = vm.runInThisContext(code, options);
     await fn(...Object.values(context));
   }
   prepareContext(context) {
@@ -381,7 +356,7 @@ ${getStack()}`), 2e3);
     return !path.endsWith(".mjs") && "default" in mod;
   }
   importExternalModule(path) {
-    return (function (t) { return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(t)); }); })(path);
+    return import(path);
   }
   /**
    * Import a module and interop it

package/dist/client.d.ts

@@ -1,2 +1,2 @@
-import './types.d-7442d07f.js';
-export { k as DEFAULT_REQUEST_STUBS, M as ModuleCacheMap, i as ViteNodeRunner } from './types-2dc895bd.js';
+import './trace-mapping.d-e677e8f4.js';
+export { e as DEFAULT_REQUEST_STUBS, M as ModuleCacheMap, a as ViteNodeRunner } from './index-6fb787b2.js';

package/dist/constants.cjs

@@ -1,7 +1,5 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 const KNOWN_ASSET_TYPES = [
   // images
   "apng",

package/dist/hmr.cjs

@@ -1,23 +1,249 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var hmr = require('./chunk-hmr.cjs');
-require('node:events');
-require('picocolors');
-require('debug');
-require('./utils.cjs');
+var node_events = require('node:events');
+var c = require('picocolors');
+var createDebug = require('debug');
+var utils = require('./utils.cjs');
 require('node:url');
 require('module');
 require('fs');
 require('pathe');
 
+function createHmrEmitter() {
+  const emitter = new node_events.EventEmitter();
+  return emitter;
+}
+function viteNodeHmrPlugin() {
+  const emitter = createHmrEmitter();
+  return {
+    name: "vite-node:hmr",
+    config() {
+      if (process.platform === "darwin" && process.env.VITE_TEST_WATCHER_DEBUG) {
+        return {
+          server: {
+            watch: {
+              useFsEvents: false,
+              usePolling: false
+            }
+          }
+        };
+      }
+    },
+    configureServer(server) {
+      const _send = server.ws.send;
+      server.emitter = emitter;
+      server.ws.send = function(payload) {
+        _send(payload);
+        emitter.emit("message", payload);
+      };
+      if (process.env.VITE_TEST_WATCHER_DEBUG) {
+        server.watcher.on("ready", () => {
+          console.log("[debug] watcher is ready");
+        });
+      }
+    }
+  };
+}
 
+const debugHmr = createDebug("vite-node:hmr");
+const cache = /* @__PURE__ */ new WeakMap();
+function getCache(runner) {
+  if (!cache.has(runner)) {
+    cache.set(runner, {
+      hotModulesMap: /* @__PURE__ */ new Map(),
+      dataMap: /* @__PURE__ */ new Map(),
+      disposeMap: /* @__PURE__ */ new Map(),
+      pruneMap: /* @__PURE__ */ new Map(),
+      customListenersMap: /* @__PURE__ */ new Map(),
+      ctxToListenersMap: /* @__PURE__ */ new Map(),
+      messageBuffer: [],
+      isFirstUpdate: false,
+      pending: false,
+      queued: []
+    });
+  }
+  return cache.get(runner);
+}
+function sendMessageBuffer(runner, emitter) {
+  const maps = getCache(runner);
+  maps.messageBuffer.forEach((msg) => emitter.emit("custom", msg));
+  maps.messageBuffer.length = 0;
+}
+async function reload(runner, files) {
+  Array.from(runner.moduleCache.keys()).forEach((fsPath) => {
+    if (!fsPath.includes("node_modules"))
+      runner.moduleCache.delete(fsPath);
+  });
+  return Promise.all(files.map((file) => runner.executeId(file)));
+}
+async function notifyListeners(runner, event, data) {
+  const maps = getCache(runner);
+  const cbs = maps.customListenersMap.get(event);
+  if (cbs)
+    await Promise.all(cbs.map((cb) => cb(data)));
+}
+async function queueUpdate(runner, p) {
+  const maps = getCache(runner);
+  maps.queued.push(p);
+  if (!maps.pending) {
+    maps.pending = true;
+    await Promise.resolve();
+    maps.pending = false;
+    const loading = [...maps.queued];
+    maps.queued = [];
+    (await Promise.all(loading)).forEach((fn) => fn && fn());
+  }
+}
+async function fetchUpdate(runner, { path, acceptedPath }) {
+  path = utils.normalizeRequestId(path);
+  acceptedPath = utils.normalizeRequestId(acceptedPath);
+  const maps = getCache(runner);
+  const mod = maps.hotModulesMap.get(path);
+  if (!mod) {
+    return;
+  }
+  const isSelfUpdate = path === acceptedPath;
+  let fetchedModule;
+  const qualifiedCallbacks = mod.callbacks.filter(
+    ({ deps }) => deps.includes(acceptedPath)
+  );
+  if (isSelfUpdate || qualifiedCallbacks.length > 0) {
+    const disposer = maps.disposeMap.get(acceptedPath);
+    if (disposer)
+      await disposer(maps.dataMap.get(acceptedPath));
+    try {
+      [fetchedModule] = await reload(runner, [acceptedPath]);
+    } catch (e) {
+      warnFailedFetch(e, acceptedPath);
+    }
+  }
+  return () => {
+    for (const { deps, fn } of qualifiedCallbacks)
+      fn(deps.map((dep) => dep === acceptedPath ? fetchedModule : void 0));
+    const loggedPath = isSelfUpdate ? path : `${acceptedPath} via ${path}`;
+    console.log(`${c.cyan("[vite-node]")} hot updated: ${loggedPath}`);
+  };
+}
+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)`
+  );
+}
+async function handleMessage(runner, emitter, files, payload) {
+  const maps = getCache(runner);
+  switch (payload.type) {
+    case "connected":
+      sendMessageBuffer(runner, emitter);
+      break;
+    case "update":
+      await notifyListeners(runner, "vite:beforeUpdate", payload);
+      await Promise.all(payload.updates.map((update) => {
+        if (update.type === "js-update")
+          return queueUpdate(runner, fetchUpdate(runner, update));
+        console.error(`${c.cyan("[vite-node]")} no support css hmr.}`);
+        return null;
+      }));
+      await notifyListeners(runner, "vite:afterUpdate", payload);
+      break;
+    case "full-reload":
+      await notifyListeners(runner, "vite:beforeFullReload", payload);
+      maps.customListenersMap.delete("vite:beforeFullReload");
+      await reload(runner, files);
+      break;
+    case "custom":
+      await notifyListeners(runner, payload.event, payload.data);
+      break;
+    case "prune":
+      await notifyListeners(runner, "vite:beforePrune", payload);
+      payload.paths.forEach((path) => {
+        const fn = maps.pruneMap.get(path);
+        if (fn)
+          fn(maps.dataMap.get(path));
+      });
+      break;
+    case "error": {
+      await notifyListeners(runner, "vite:error", payload);
+      const err = payload.err;
+      console.error(`${c.cyan("[vite-node]")} Internal Server Error
+${err.message}
+${err.stack}`);
+      break;
+    }
+  }
+}
+function createHotContext(runner, emitter, files, ownerPath) {
+  debugHmr("createHotContext", ownerPath);
+  const maps = getCache(runner);
+  if (!maps.dataMap.has(ownerPath))
+    maps.dataMap.set(ownerPath, {});
+  const mod = maps.hotModulesMap.get(ownerPath);
+  if (mod)
+    mod.callbacks = [];
+  const newListeners = /* @__PURE__ */ new Map();
+  maps.ctxToListenersMap.set(ownerPath, newListeners);
+  function acceptDeps(deps, callback = () => {
+  }) {
+    const mod2 = maps.hotModulesMap.get(ownerPath) || {
+      id: ownerPath,
+      callbacks: []
+    };
+    mod2.callbacks.push({
+      deps,
+      fn: callback
+    });
+    maps.hotModulesMap.set(ownerPath, mod2);
+  }
+  const hot = {
+    get data() {
+      return maps.dataMap.get(ownerPath);
+    },
+    acceptExports(_, callback) {
+      acceptDeps([ownerPath], callback && (([mod2]) => callback(mod2)));
+    },
+    accept(deps, callback) {
+      if (typeof deps === "function" || !deps) {
+        acceptDeps([ownerPath], ([mod2]) => deps && deps(mod2));
+      } else if (typeof deps === "string") {
+        acceptDeps([deps], ([mod2]) => callback && callback(mod2));
+      } else if (Array.isArray(deps)) {
+        acceptDeps(deps, callback);
+      } else {
+        throw new TypeError("invalid hot.accept() usage.");
+      }
+    },
+    dispose(cb) {
+      maps.disposeMap.set(ownerPath, cb);
+    },
+    prune(cb) {
+      maps.pruneMap.set(ownerPath, cb);
+    },
+    invalidate() {
+      notifyListeners(runner, "vite:invalidate", { path: ownerPath, message: void 0 });
+      return reload(runner, files);
+    },
+    on(event, cb) {
+      const addToMap = (map) => {
+        const existing = map.get(event) || [];
+        existing.push(cb);
+        map.set(event, existing);
+      };
+      addToMap(maps.customListenersMap);
+      addToMap(newListeners);
+    },
+    send(event, data) {
+      maps.messageBuffer.push(JSON.stringify({ type: "custom", event, data }));
+      sendMessageBuffer(runner, emitter);
+    }
+  };
+  return hot;
+}
 
-exports.createHmrEmitter = hmr.createHmrEmitter;
-exports.createHotContext = hmr.createHotContext;
-exports.getCache = hmr.getCache;
-exports.handleMessage = hmr.handleMessage;
-exports.reload = hmr.reload;
-exports.sendMessageBuffer = hmr.sendMessageBuffer;
-exports.viteNodeHmrPlugin = hmr.viteNodeHmrPlugin;
+exports.createHmrEmitter = createHmrEmitter;
+exports.createHotContext = createHotContext;
+exports.getCache = getCache;
+exports.handleMessage = handleMessage;
+exports.reload = reload;
+exports.sendMessageBuffer = sendMessageBuffer;
+exports.viteNodeHmrPlugin = viteNodeHmrPlugin;

package/dist/hmr.d.ts

@@ -1,7 +1,7 @@
 import { EventEmitter } from 'node:events';
 import { HMRPayload, Plugin } from 'vite';
-import { h as CustomEventMap, i as ViteNodeRunner, j as HMRPayload$1, H as HotContext } from './types-2dc895bd.js';
-import './types.d-7442d07f.js';
+import { C as CustomEventMap, a as ViteNodeRunner, H as HMRPayload$1, b as HotContext } from './index-6fb787b2.js';
+import './trace-mapping.d-e677e8f4.js';
 
 type EventType = string | symbol;
 type Handler<T = unknown> = (event: T) => void;