vite-node 0.1.17 → 0.1.21

package/dist/server.cjs

@@ -0,0 +1,174 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var fs = require('fs');
+var mlly = require('mlly');
+var url = require('url');
+var pathe = require('pathe');
+
+const isWindows = process.platform === "win32";
+function slash(str) {
+  return str.replace(/\\/g, "/");
+}
+function toFilePath(id, root) {
+  let absolute = slash(id).startsWith("/@fs/") ? id.slice(4) : id.startsWith(pathe.dirname(root)) && pathe.dirname(root) !== "/" ? id : id.startsWith("/") ? slash(pathe.resolve(root, id.slice(1))) : id;
+  if (absolute.startsWith("//"))
+    absolute = absolute.slice(1);
+  return isWindows && absolute.startsWith("/") ? url.fileURLToPath(url.pathToFileURL(absolute.slice(1)).href) : absolute;
+}
+
+const ESM_EXT_RE = /\.(es|esm|esm-browser|esm-bundler|es6|module)\.js$/;
+const ESM_FOLDER_RE = /\/esm\/(.*\.js)$/;
+const defaultInline = [
+  /\/vitest\/dist\//,
+  /vitest-virtual-\w+\/dist/,
+  /virtual:/,
+  /\.ts$/,
+  ESM_EXT_RE,
+  ESM_FOLDER_RE
+];
+const depsExternal = [
+  /\.cjs.js$/,
+  /\.mjs$/
+];
+function guessCJSversion(id) {
+  if (id.match(ESM_EXT_RE)) {
+    for (const i of [
+      id.replace(ESM_EXT_RE, ".mjs"),
+      id.replace(ESM_EXT_RE, ".umd.js"),
+      id.replace(ESM_EXT_RE, ".cjs.js"),
+      id.replace(ESM_EXT_RE, ".js")
+    ]) {
+      if (fs.existsSync(i))
+        return i;
+    }
+  }
+  if (id.match(ESM_FOLDER_RE)) {
+    for (const i of [
+      id.replace(ESM_FOLDER_RE, "/umd/$1"),
+      id.replace(ESM_FOLDER_RE, "/cjs/$1"),
+      id.replace(ESM_FOLDER_RE, "/$1")
+    ]) {
+      if (fs.existsSync(i))
+        return i;
+    }
+  }
+}
+async function shouldExternalize(id, options, cache = new Map()) {
+  if (!cache.has(id))
+    cache.set(id, _shouldExternalize(id, options));
+  return cache.get(id);
+}
+async function _shouldExternalize(id, options) {
+  if (mlly.isNodeBuiltin(id))
+    return id;
+  id = patchWindowsImportPath(id);
+  if (matchExternalizePattern(id, options == null ? void 0 : options.inline))
+    return false;
+  if (matchExternalizePattern(id, options == null ? void 0 : options.external))
+    return id;
+  const isNodeModule = id.includes("/node_modules/");
+  id = isNodeModule ? guessCJSversion(id) || id : id;
+  if (matchExternalizePattern(id, defaultInline))
+    return false;
+  if (matchExternalizePattern(id, depsExternal))
+    return id;
+  if (isNodeModule && await mlly.isValidNodeImport(id))
+    return id;
+  return false;
+}
+function matchExternalizePattern(id, patterns) {
+  if (!patterns)
+    return false;
+  for (const ex of patterns) {
+    if (typeof ex === "string") {
+      if (id.includes(`/node_modules/${ex}/`))
+        return true;
+    } else {
+      if (ex.test(id))
+        return true;
+    }
+  }
+  return false;
+}
+function patchWindowsImportPath(path) {
+  if (path.match(/^\w:\\/))
+    return `file:///${slash(path)}`;
+  else if (path.match(/^\w:\//))
+    return `file:///${path}`;
+  else
+    return path;
+}
+
+let SOURCEMAPPING_URL = "sourceMa";
+SOURCEMAPPING_URL += "ppingURL";
+class ViteNodeServer {
+  constructor(server, options = {}) {
+    this.server = server;
+    this.options = options;
+    this.promiseMap = new Map();
+  }
+  shouldExternalize(id) {
+    return shouldExternalize(id, this.options.deps);
+  }
+  async fetchModule(id) {
+    const externalize = await this.shouldExternalize(toFilePath(id, this.server.config.root));
+    if (externalize)
+      return { externalize };
+    const r = await this.transformRequest(id);
+    return { code: r == null ? void 0 : r.code };
+  }
+  async resolveId(id, importer) {
+    return this.server.pluginContainer.resolveId(id, importer, { ssr: true });
+  }
+  async transformRequest(id) {
+    if (!this.promiseMap.has(id)) {
+      this.promiseMap.set(id, this._transformRequest(id).finally(() => {
+        this.promiseMap.delete(id);
+      }));
+    }
+    return this.promiseMap.get(id);
+  }
+  getTransformMode(id) {
+    var _a, _b, _c, _d;
+    const withoutQuery = id.split("?")[0];
+    if ((_b = (_a = this.options.transformMode) == null ? void 0 : _a.web) == null ? void 0 : _b.some((r) => withoutQuery.match(r)))
+      return "web";
+    if ((_d = (_c = this.options.transformMode) == null ? void 0 : _c.ssr) == null ? void 0 : _d.some((r) => withoutQuery.match(r)))
+      return "ssr";
+    if (withoutQuery.match(/\.([cm]?[jt]sx?|json)$/))
+      return "ssr";
+    return "web";
+  }
+  async _transformRequest(id) {
+    let result = null;
+    const mode = this.getTransformMode(id);
+    if (mode === "web") {
+      result = await this.server.transformRequest(id);
+      if (result)
+        result = await this.server.ssrTransform(result.code, result.map, id);
+    } else {
+      result = await this.server.transformRequest(id, { ssr: true });
+    }
+    if (this.options.sourcemap !== false && result && !id.includes("node_modules"))
+      withInlineSourcemap(result);
+    return result;
+  }
+}
+async function withInlineSourcemap(result) {
+  const { code, map } = result;
+  if (code.includes(`${SOURCEMAPPING_URL}=`))
+    return result;
+  if (map)
+    result.code = `${code}
+
+//# ${SOURCEMAPPING_URL}=data:application/json;charset=utf-8;base64,${Buffer.from(JSON.stringify(map), "utf-8").toString("base64")}
+`;
+  return result;
+}
+
+exports.ViteNodeServer = ViteNodeServer;
+exports.guessCJSversion = guessCJSversion;
+exports.shouldExternalize = shouldExternalize;
+exports.withInlineSourcemap = withInlineSourcemap;

package/dist/server.js

@@ -1,8 +1,18 @@
 import { existsSync } from 'fs';
 import { isNodeBuiltin, isValidNodeImport } from 'mlly';
-import { slash, toFilePath } from './utils.js';
-import 'url';
-import 'pathe';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { dirname, resolve } from 'pathe';
+
+const isWindows = process.platform === "win32";
+function slash(str) {
+  return str.replace(/\\/g, "/");
+}
+function toFilePath(id, root) {
+  let absolute = slash(id).startsWith("/@fs/") ? id.slice(4) : id.startsWith(dirname(root)) && dirname(root) !== "/" ? id : id.startsWith("/") ? slash(resolve(root, id.slice(1))) : id;
+  if (absolute.startsWith("//"))
+    absolute = absolute.slice(1);
+  return isWindows && absolute.startsWith("/") ? fileURLToPath(pathToFileURL(absolute.slice(1)).href) : absolute;
+}
 
 const ESM_EXT_RE = /\.(es|esm|esm-browser|esm-bundler|es6|module)\.js$/;
 const ESM_FOLDER_RE = /\/esm\/(.*\.js)$/;
@@ -41,18 +51,18 @@ function guessCJSversion(id) {
     }
   }
 }
-async function shouldExternalize(id, config, cache = new Map()) {
+async function shouldExternalize(id, options, cache = new Map()) {
   if (!cache.has(id))
-    cache.set(id, _shouldExternalize(id, config));
+    cache.set(id, _shouldExternalize(id, options));
   return cache.get(id);
 }
-async function _shouldExternalize(id, config) {
+async function _shouldExternalize(id, options) {
   if (isNodeBuiltin(id))
     return id;
   id = patchWindowsImportPath(id);
-  if (matchExternalizePattern(id, config == null ? void 0 : config.inline))
+  if (matchExternalizePattern(id, options == null ? void 0 : options.inline))
     return false;
-  if (matchExternalizePattern(id, config == null ? void 0 : config.external))
+  if (matchExternalizePattern(id, options == null ? void 0 : options.external))
     return id;
   const isNodeModule = id.includes("/node_modules/");
   id = isNodeModule ? guessCJSversion(id) || id : id;
@@ -105,6 +115,9 @@ class ViteNodeServer {
     const r = await this.transformRequest(id);
     return { code: r == null ? void 0 : r.code };
   }
+  async resolveId(id, importer) {
+    return this.server.pluginContainer.resolveId(id, importer, { ssr: true });
+  }
   async transformRequest(id) {
     if (!this.promiseMap.has(id)) {
       this.promiseMap.set(id, this._transformRequest(id).finally(() => {
@@ -134,7 +147,7 @@ class ViteNodeServer {
     } else {
       result = await this.server.transformRequest(id, { ssr: true });
     }
-    if (result && !id.includes("node_modules"))
+    if (this.options.sourcemap !== false && result && !id.includes("node_modules"))
       withInlineSourcemap(result);
     return result;
   }

package/dist/utils.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var url = require('url');
+var pathe = require('pathe');
+
+const isWindows = process.platform === "win32";
+function slash(str) {
+  return str.replace(/\\/g, "/");
+}
+function normalizeId(id, base) {
+  if (base && id.startsWith(base))
+    id = `/${id.slice(base.length)}`;
+  return id.replace(/^\/@id\/__x00__/, "\0").replace(/^\/@id\//, "").replace(/^__vite-browser-external:/, "").replace(/^node:/, "").replace(/[?&]v=\w+/, "?").replace(/\?$/, "");
+}
+function isPrimitive(v) {
+  return v !== Object(v);
+}
+function toFilePath(id, root) {
+  let absolute = slash(id).startsWith("/@fs/") ? id.slice(4) : id.startsWith(pathe.dirname(root)) && pathe.dirname(root) !== "/" ? id : id.startsWith("/") ? slash(pathe.resolve(root, id.slice(1))) : id;
+  if (absolute.startsWith("//"))
+    absolute = absolute.slice(1);
+  return isWindows && absolute.startsWith("/") ? url.fileURLToPath(url.pathToFileURL(absolute.slice(1)).href) : absolute;
+}
+
+exports.isPrimitive = isPrimitive;
+exports.isWindows = isWindows;
+exports.normalizeId = normalizeId;
+exports.slash = slash;
+exports.toFilePath = toFilePath;

package/dist/utils.js

@@ -14,7 +14,7 @@ function isPrimitive(v) {
   return v !== Object(v);
 }
 function toFilePath(id, root) {
-  let absolute = slash(id).startsWith("/@fs/") ? id.slice(4) : id.startsWith(dirname(root)) ? id : id.startsWith("/") ? slash(resolve(root, id.slice(1))) : id;
+  let absolute = slash(id).startsWith("/@fs/") ? id.slice(4) : id.startsWith(dirname(root)) && dirname(root) !== "/" ? id : id.startsWith("/") ? slash(resolve(root, id.slice(1))) : id;
   if (absolute.startsWith("//"))
     absolute = absolute.slice(1);
   return isWindows && absolute.startsWith("/") ? fileURLToPath(pathToFileURL(absolute.slice(1)).href) : absolute;

package/index.d.ts

@@ -1,12 +1,17 @@
-interface ExternalizeOptions {
+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;
 }
 declare type FetchFunction = (id: string) => Promise<{
     code?: string;
     externalize?: string;
 }>;
+declare type ResolveIdFunction = (id: string, importer?: string) => Promise<ViteNodeResolveId | null>;
 interface ModuleCache {
     promise?: Promise<any>;
     exports?: any;
@@ -14,18 +19,37 @@ interface ModuleCache {
 }
 interface ViteNodeRunnerOptions {
     fetchModule: FetchFunction;
+    resolveId: ResolveIdFunction;
     root: string;
     base?: string;
     moduleCache?: Map<string, ModuleCache>;
-    interpretDefault?: boolean;
+    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 {
-    deps?: ExternalizeOptions;
+    /**
+     * Inject inline sourcemap to modules
+     * @default true
+     */
+    sourcemap?: boolean;
+    /**
+     * Deps handling
+     */
+    deps?: DepsHandlingOptions;
+    /**
+     * Tranform method for modules
+     */
     transformMode?: {
         ssr?: RegExp[];
         web?: RegExp[];
     };
 }
 
-export { ExternalizeOptions, FetchFunction, ModuleCache, ViteNodeRunnerOptions, ViteNodeServerOptions };
+export { DepsHandlingOptions, FetchFunction, ModuleCache, ResolveIdFunction, ViteNodeResolveId, ViteNodeRunnerOptions, ViteNodeServerOptions };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-node",
-  "version": "0.1.17",
+  "version": "0.1.21",
   "description": "Vite as Node.js runtime",
   "homepage": "https://github.com/vitest-dev/vitest#readme",
   "bugs": {
@@ -18,18 +18,22 @@
   "exports": {
     ".": {
       "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
       "types": "./index.d.ts"
     },
     "./client": {
       "import": "./dist/client.js",
+      "require": "./dist/client.cjs",
       "types": "./client.d.ts"
     },
     "./server": {
       "import": "./dist/server.js",
+      "require": "./dist/server.cjs",
       "types": "./server.d.ts"
     },
     "./utils": {
       "import": "./dist/utils.js",
+      "require": "./dist/utils.cjs",
       "types": "./utils.d.ts"
     }
   },

package/server.d.ts

@@ -1,12 +1,34 @@
 import { ViteDevServer, TransformResult } from 'vite';
 
-interface ExternalizeOptions {
+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 ViteNodeResolveId {
+    external?: boolean | 'absolute' | 'relative';
+    id: string;
+    meta?: Record<string, any> | null;
+    moduleSideEffects?: boolean | 'no-treeshake' | null;
+    syntheticNamedExports?: boolean | string | null;
+}
 interface ViteNodeServerOptions {
-    deps?: ExternalizeOptions;
+    /**
+     * Inject inline sourcemap to modules
+     * @default true
+     */
+    sourcemap?: boolean;
+    /**
+     * Deps handling
+     */
+    deps?: DepsHandlingOptions;
+    /**
+     * Tranform method for modules
+     */
     transformMode?: {
         ssr?: RegExp[];
         web?: RegExp[];
@@ -14,7 +36,7 @@ interface ViteNodeServerOptions {
 }
 
 declare function guessCJSversion(id: string): string | undefined;
-declare function shouldExternalize(id: string, config?: ExternalizeOptions, cache?: Map<string, Promise<string | false>>): Promise<string | false>;
+declare function shouldExternalize(id: string, options?: DepsHandlingOptions, cache?: Map<string, Promise<string | false>>): Promise<string | false>;
 
 declare class ViteNodeServer {
     server: ViteDevServer;
@@ -29,6 +51,7 @@ declare class ViteNodeServer {
         code: string | undefined;
         externalize?: undefined;
     }>;
+    resolveId(id: string, importer?: string): Promise<ViteNodeResolveId | null>;
     transformRequest(id: string): Promise<TransformResult | null | undefined>;
     private getTransformMode;
     private _transformRequest;