vite-node 0.1.11 → 0.1.17

package/LICENSE

@@ -1,6 +1,7 @@
 MIT License
 
-Copyright (c) 2021 Anthony Fu <https://github.com/antfu>
+Copyright (c) 2021-Present Anthony Fu <https://github.com/antfu>
+Copyright (c) 2021-Present Matias Capeletto <https://github.com/patak-dev>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -2,12 +2,20 @@
 
 [![NPM version](https://img.shields.io/npm/v/vite-node?color=a1b858&label=)](https://www.npmjs.com/package/vite-node)
 
-Vite as Node runtime.
+Vite as Node runtime. The engine powers [Vitest](https://github.com/vitest-dev/vitest).
 
-> **EXPERIMENTAL**
+## Features
+
+- Out-of-box ESM & TypeScript support (possible for more with plugins)
+- Top-level await
+- Vite plugins, resolve, aliasing
+- Respect `vite.config.ts`
+- Shims for `__dirname` and `__filename` in ESM
+- Access to native node modules like `fs`, `path`, etc.
 
+## CLI Usage
 
-## Usage
+Run JS/TS file on Node.js using Vite's resolvers and transformers.
 
 ```bash
 npx vite-node index.ts
@@ -19,29 +27,41 @@ Options:
 npx vite-node -h
 ```
 
-## Features
+## Programmatic Usage
 
-- Out-of-box ESM & TypeScript support (possible for more with plugins)
-- Top-level await
-- Vite plugins, resolve, aliasing
-- Respect `vite.config.ts`
-- Shims for `__dirname` and `__filename` in ESM
-- Access to native node modules like `fs`, `path`, etc.
-- Watch mode (like `nodemon`)
+In Vite Node, the server and runner (client) are separated, so you can integrate them in different contexts (workers, cross-process, or remote) if needed. The demo below shows a simple example of having the server and running in the same context
 
-## When NOT to Use
+```ts
+import { createServer } from 'vite'
+import { ViteNodeServer } from 'vite-node/server'
+import { ViteNodeRunner } from 'vite-node/client'
 
-- Production, yet - in very early stage, check it later
-- Most of the time, when other tools can do that job
-  - We need to start a Vite server upon each execution, which inevitably introduces some overhead. Only use it when you want the same behavior as Vite or the powerful plugins system (for example, testing components with a Vite-specific setup).
+// create vite server
+const server = await createServer()
+// this is need to initialize the plugins
+await server.pluginContainer.buildStart({})
 
-## Why?
+// create vite-node server
+const node = new ViteNodeServer(server)
 
-It runs Vite's id resolving, module transforming, and most importantly, the powerful plugins system!
+// create vite-node runner
+const runner = new ViteNodeRunner({
+  root: server.config.root,
+  base: server.config.base,
+  // when having the server and runner in a different context,
+  // you will need to handle the communication between them
+  // and pass to this function
+  fetchModule(id) {
+    return node.fetchModule(id)
+  },
+})
 
-## How?
+// execute the file
+await runner.executeFile('./example.ts')
 
-It fires up a Vite dev server, transforms the requests, and runs them in Node.
+// close the vite server
+await server.close()
+```
 
 ## Credits
 

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,33 @@
+declare type FetchFunction = (id: string) => Promise<{
+    code?: string;
+    externalize?: string;
+}>;
+interface ModuleCache {
+    promise?: Promise<any>;
+    exports?: any;
+    code?: string;
+}
+interface ViteNodeRunnerOptions {
+    fetchModule: FetchFunction;
+    root: string;
+    base?: string;
+    moduleCache?: Map<string, ModuleCache>;
+    interpretDefault?: boolean;
+    requestStubs?: Record<string, any>;
+}
+
+declare class ViteNodeRunner {
+    options: ViteNodeRunnerOptions;
+    root: string;
+    externalCache: Map<string, string | Promise<false | 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;
+}
+
+export { ViteNodeRunner };

package/dist/cli.js

@@ -0,0 +1,78 @@
+import minimist from 'minimist';
+import { red, dim } from 'kolorist';
+import { createServer } from 'vite';
+import { ViteNodeServer } from './server.js';
+import { ViteNodeRunner } from './client.js';
+import 'fs';
+import 'mlly';
+import './utils.js';
+import 'url';
+import 'pathe';
+import 'module';
+import 'vm';
+
+const argv = minimist(process.argv.slice(2), {
+  "alias": {
+    r: "root",
+    c: "config",
+    h: "help",
+    w: "watch",
+    s: "silent"
+  },
+  "--": true,
+  "string": ["root", "config"],
+  "boolean": ["help", "watch", "silent"],
+  unknown(name) {
+    if (name[0] === "-") {
+      console.error(red(`Unknown argument: ${name}`));
+      help();
+      process.exit(1);
+    }
+    return true;
+  }
+});
+if (argv.help) {
+  help();
+  process.exit(0);
+}
+if (!argv._.length) {
+  console.error(red("No files specified."));
+  help();
+  process.exit(1);
+}
+process.argv = [...process.argv.slice(0, 2), ...argv["--"] || []];
+run(argv);
+function help() {
+  console.log(`
+Usage:
+  $ vite-node [options] [files]
+
+Options:
+  -r, --root <path>      ${dim("[string]")} use specified root directory
+  -c, --config <file>    ${dim("[string]")} use specified config file
+  -w, --watch           ${dim("[boolean]")} restart on file changes, similar to "nodemon"
+  -s, --silent          ${dim("[boolean]")} do not emit errors and logs
+  --vue                 ${dim("[boolean]")} support for importing Vue component
+`);
+}
+async function run(options = {}) {
+  const files = options.files || options._ || [];
+  const server = await createServer({
+    logLevel: "error",
+    clearScreen: false,
+    configFile: options.config,
+    root: options.root
+  });
+  await server.pluginContainer.buildStart({});
+  const node = new ViteNodeServer(server);
+  const runner = new ViteNodeRunner({
+    root: server.config.root,
+    base: server.config.base,
+    fetchModule(id) {
+      return node.fetchModule(id);
+    }
+  });
+  for (const file of files)
+    await runner.executeFile(file);
+  await server.close();
+}

package/dist/client.js

@@ -0,0 +1,141 @@
+import { builtinModules, createRequire } from 'module';
+import { pathToFileURL, fileURLToPath } from 'url';
+import vm from 'vm';
+import { resolve, dirname } from 'pathe';
+import { slash, normalizeId, toFilePath, isPrimitive } from './utils.js';
+
+class ViteNodeRunner {
+  constructor(options) {
+    this.options = options;
+    this.root = options.root || process.cwd();
+    this.moduleCache = options.moduleCache || new Map();
+    this.externalCache = new Map();
+    builtinModules.forEach((m) => this.externalCache.set(m, m));
+  }
+  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;
+    const id = normalizeId(rawId, this.options.base);
+    const fsPath = toFilePath(id, this.root);
+    if ((_a = this.moduleCache.get(fsPath)) == null ? void 0 : _a.promise)
+      return (_b = this.moduleCache.get(fsPath)) == null ? void 0 : _b.promise;
+    const promise = this.directRequest(id, fsPath, callstack);
+    this.setCache(fsPath, { promise });
+    return await promise;
+  }
+  async directRequest(id, fsPath, callstack) {
+    callstack = [...callstack, id];
+    const request = async (dep) => {
+      var _a;
+      if (callstack.includes(dep)) {
+        const cacheKey = toFilePath(dep, this.root);
+        if (!((_a = this.moduleCache.get(cacheKey)) == null ? void 0 : _a.exports))
+          throw new Error(`Circular dependency detected
+Stack:
+${[...callstack, dep].reverse().map((p) => `- ${p}`).join("\n")}`);
+        return this.moduleCache.get(cacheKey).exports;
+      }
+      return this.cachedRequest(dep, callstack);
+    };
+    if (this.options.requestStubs && id in this.options.requestStubs)
+      return this.options.requestStubs[id];
+    const { code: transformed, externalize } = await this.options.fetchModule(id);
+    if (externalize) {
+      const mod = await interpretedImport(externalize, this.options.interpretDefault ?? true);
+      this.setCache(fsPath, { exports: mod });
+      return mod;
+    }
+    if (transformed == null)
+      throw new Error(`failed to load ${id}`);
+    const url = pathToFileURL(fsPath).href;
+    const exports = {};
+    this.setCache(fsPath, { code: transformed, exports });
+    const __filename = fileURLToPath(url);
+    const moduleProxy = {
+      set exports(value) {
+        exportAll(exports, value);
+        exports.default = value;
+      },
+      get exports() {
+        return exports.default;
+      }
+    };
+    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__: { url },
+      require: createRequire(url),
+      exports,
+      module: moduleProxy,
+      __filename,
+      __dirname: dirname(__filename)
+    });
+    const fn = vm.runInThisContext(`async (${Object.keys(context).join(",")})=>{{${transformed}
+}}`, {
+      filename: fsPath,
+      lineOffset: 0
+    });
+    await fn(...Object.values(context));
+    return exports;
+  }
+  prepareContext(context) {
+    return context;
+  }
+  setCache(id, mod) {
+    if (!this.moduleCache.has(id))
+      this.moduleCache.set(id, mod);
+    else
+      Object.assign(this.moduleCache.get(id), mod);
+  }
+}
+function 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;
+  };
+}
+async function interpretedImport(path, interpretDefault) {
+  const mod = await import(path);
+  if (interpretDefault && "default" in mod) {
+    const tryDefault = hasNestedDefault(mod);
+    return new Proxy(mod, {
+      get: proxyMethod("get", tryDefault),
+      set: proxyMethod("set", tryDefault),
+      has: proxyMethod("has", tryDefault),
+      deleteProperty: proxyMethod("deleteProperty", tryDefault)
+    });
+  }
+  return mod;
+}
+function exportAll(exports, sourceModule) {
+  for (const key in sourceModule) {
+    if (key !== "default") {
+      try {
+        Object.defineProperty(exports, key, {
+          enumerable: true,
+          configurable: true,
+          get() {
+            return sourceModule[key];
+          }
+        });
+      } catch (_err) {
+      }
+    }
+  }
+}
+
+export { ViteNodeRunner };

package/dist/index.js

@@ -0,0 +1 @@
+

package/dist/server.js

@@ -0,0 +1,154 @@
+import { existsSync } from 'fs';
+import { isNodeBuiltin, isValidNodeImport } from 'mlly';
+import { slash, toFilePath } from './utils.js';
+import 'url';
+import 'pathe';
+
+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 (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 (existsSync(i))
+        return i;
+    }
+  }
+}
+async function shouldExternalize(id, config, cache = new Map()) {
+  if (!cache.has(id))
+    cache.set(id, _shouldExternalize(id, config));
+  return cache.get(id);
+}
+async function _shouldExternalize(id, config) {
+  if (isNodeBuiltin(id))
+    return id;
+  id = patchWindowsImportPath(id);
+  if (matchExternalizePattern(id, config == null ? void 0 : config.inline))
+    return false;
+  if (matchExternalizePattern(id, config == null ? void 0 : config.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 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 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 (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;
+}
+
+export { ViteNodeServer, guessCJSversion, shouldExternalize, withInlineSourcemap };

package/dist/utils.js

@@ -0,0 +1,23 @@
+import { fileURLToPath, pathToFileURL } from 'url';
+import { dirname, resolve } from '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(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;
+}
+
+export { isPrimitive, isWindows, normalizeId, slash, toFilePath };

package/index.d.ts

@@ -0,0 +1,31 @@
+interface ExternalizeOptions {
+    external?: (string | RegExp)[];
+    inline?: (string | RegExp)[];
+    fallbackCJS?: boolean;
+}
+declare type FetchFunction = (id: string) => Promise<{
+    code?: string;
+    externalize?: string;
+}>;
+interface ModuleCache {
+    promise?: Promise<any>;
+    exports?: any;
+    code?: string;
+}
+interface ViteNodeRunnerOptions {
+    fetchModule: FetchFunction;
+    root: string;
+    base?: string;
+    moduleCache?: Map<string, ModuleCache>;
+    interpretDefault?: boolean;
+    requestStubs?: Record<string, any>;
+}
+interface ViteNodeServerOptions {
+    deps?: ExternalizeOptions;
+    transformMode?: {
+        ssr?: RegExp[];
+        web?: RegExp[];
+    };
+}
+
+export { ExternalizeOptions, FetchFunction, ModuleCache, ViteNodeRunnerOptions, ViteNodeServerOptions };

package/package.json

@@ -1,67 +1,67 @@
 {
   "name": "vite-node",
-  "version": "0.1.11",
-  "description": "Vite as Node runtime",
-  "keywords": [
-    "vite"
-  ],
-  "homepage": "https://github.com/antfu/vite-node#readme",
+  "version": "0.1.17",
+  "description": "Vite as Node.js runtime",
+  "homepage": "https://github.com/vitest-dev/vitest#readme",
   "bugs": {
-    "url": "https://github.com/antfu/vite-node/issues"
+    "url": "https://github.com/vitest-dev/vitest/issues"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/antfu/vite-node.git"
+    "url": "git+https://github.com/vitest-dev/vitest.git",
+    "directory": "packages/vite-node"
   },
   "funding": "https://github.com/sponsors/antfu",
   "license": "MIT",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
-  "sideEffects": false,
   "type": "module",
   "exports": {
     ".": {
-      "import": "./index.mjs",
+      "import": "./dist/index.js",
       "types": "./index.d.ts"
     },
-    "./cli": {
-      "import": "./cli.mjs"
+    "./client": {
+      "import": "./dist/client.js",
+      "types": "./client.d.ts"
+    },
+    "./server": {
+      "import": "./dist/server.js",
+      "types": "./server.d.ts"
+    },
+    "./utils": {
+      "import": "./dist/utils.js",
+      "types": "./utils.d.ts"
     }
   },
-  "main": "./index.mjs",
-  "module": "./index.mjs",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
   "types": "./index.d.ts",
   "bin": {
     "vite-node": "./vite-node.mjs"
   },
   "files": [
+    "dist",
+    "*.d.ts",
     "*.mjs"
   ],
   "dependencies": {
-    "debug": "^4.3.3",
-    "kolorist": "^1.5.0",
+    "kolorist": "^1.5.1",
     "minimist": "^1.2.5",
-    "vite": "^2.6.5"
+    "mlly": "^0.3.17",
+    "pathe": "^0.2.0",
+    "vite": "^2.7.12"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^0.11.1",
-    "@antfu/ni": "^0.11.0",
-    "@types/debug": "^4.1.7",
-    "@types/node": "^16.11.11",
-    "@vitejs/plugin-vue": "^1.10.1",
-    "bumpp": "^7.1.1",
-    "eslint": "^8.3.0",
-    "esno": "^0.12.1",
-    "typescript": "^4.5.2",
-    "uvu": "^0.5.2",
-    "vue": "^3.2.23"
+    "@types/minimist": "^1.2.2",
+    "rollup": "^2.63.0"
   },
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=14.14.0"
   },
   "scripts": {
-    "lint": "eslint \"**/*.{ts,mjs}\"",
-    "release": "bumpp --commit --push --tag && pnpm publish",
-    "start": "DEBUG=vite-node:* node cli.mjs",
-    "test": "node cli.mjs -c test/vite.config.ts --vue test/index.test.mjs"
-  }
+    "build": "rimraf dist && rollup -c",
+    "dev": "rollup -c --watch --watch.include=src/**",
+    "typecheck": "tsc --noEmit"
+  },
+  "readme": "# vite-node\n\n[![NPM version](https://img.shields.io/npm/v/vite-node?color=a1b858&label=)](https://www.npmjs.com/package/vite-node)\n\nVite as Node runtime. The engine powers [Vitest](https://github.com/vitest-dev/vitest).\n\n## Features\n\n- Out-of-box ESM & TypeScript support (possible for more with plugins)\n- Top-level await\n- Vite plugins, resolve, aliasing\n- Respect `vite.config.ts`\n- Shims for `__dirname` and `__filename` in ESM\n- Access to native node modules like `fs`, `path`, etc.\n\n## CLI Usage\n\nRun JS/TS file on Node.js using Vite's resolvers and transformers.\n\n```bash\nnpx vite-node index.ts\n```\n\nOptions:\n\n```bash\nnpx vite-node -h\n```\n\n## Programmatic Usage\n\nIn Vite Node, the server and runner (client) are separated, so you can integrate them in different contexts (workers, cross-process, or remote) if needed. The demo below shows a simple example of having the server and running in the same context\n\n```ts\nimport { createServer } from 'vite'\nimport { ViteNodeServer } from 'vite-node/server'\nimport { ViteNodeRunner } from 'vite-node/client'\n\n// create vite server\nconst server = await createServer()\n// this is need to initialize the plugins\nawait server.pluginContainer.buildStart({})\n\n// create vite-node server\nconst node = new ViteNodeServer(server)\n\n// create vite-node runner\nconst runner = new ViteNodeRunner({\n  root: server.config.root,\n  base: server.config.base,\n  // when having the server and runner in a different context,\n  // you will need to handle the communication between them\n  // and pass to this function\n  fetchModule(id) {\n    return node.fetchModule(id)\n  },\n})\n\n// execute the file\nawait runner.executeFile('./example.ts')\n\n// close the vite server\nawait server.close()\n```\n\n## Credits\n\nBased on [@pi0](https://github.com/pi0)'s brilliant idea of having a Vite server as the on-demand transforming service for [Nuxt's Vite SSR](https://github.com/nuxt/vite/pull/201).\n\nThanks [@brillout](https://github.com/brillout) for kindly sharing this package name.\n\n## Sponsors\n\n<p align=\"center\">\n  <a href=\"https://cdn.jsdelivr.net/gh/antfu/static/sponsors.svg\">\n    <img src='https://cdn.jsdelivr.net/gh/antfu/static/sponsors.svg'/>\n  </a>\n</p>\n\n## License\n\n[MIT](./LICENSE) License © 2021 [Anthony Fu](https://github.com/antfu)\n"
 }

package/server.d.ts

@@ -0,0 +1,38 @@
+import { ViteDevServer, TransformResult } from 'vite';
+
+interface ExternalizeOptions {
+    external?: (string | RegExp)[];
+    inline?: (string | RegExp)[];
+    fallbackCJS?: boolean;
+}
+interface ViteNodeServerOptions {
+    deps?: ExternalizeOptions;
+    transformMode?: {
+        ssr?: RegExp[];
+        web?: RegExp[];
+    };
+}
+
+declare function guessCJSversion(id: string): string | undefined;
+declare function shouldExternalize(id: string, config?: ExternalizeOptions, cache?: Map<string, Promise<string | false>>): Promise<string | false>;
+
+declare class ViteNodeServer {
+    server: ViteDevServer;
+    options: ViteNodeServerOptions;
+    promiseMap: Map<string, Promise<TransformResult | null | undefined>>;
+    constructor(server: ViteDevServer, options?: ViteNodeServerOptions);
+    shouldExternalize(id: string): Promise<string | false>;
+    fetchModule(id: string): Promise<{
+        externalize: string;
+        code?: undefined;
+    } | {
+        code: string | undefined;
+        externalize?: undefined;
+    }>;
+    transformRequest(id: string): Promise<TransformResult | null | undefined>;
+    private getTransformMode;
+    private _transformRequest;
+}
+declare function withInlineSourcemap(result: TransformResult): Promise<TransformResult>;
+
+export { ViteNodeServer, guessCJSversion, shouldExternalize, withInlineSourcemap };

package/utils.d.ts

@@ -0,0 +1,7 @@
+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;
+
+export { isPrimitive, isWindows, normalizeId, slash, toFilePath };

package/vite-node.mjs

@@ -1,4 +1,2 @@
 #!/usr/bin/env node
-'use strict'
-
-import './cli.mjs'
+import('./dist/cli.js')

package/cli.mjs

@@ -1,54 +0,0 @@
-/* eslint-disable no-console */
-import minimist from 'minimist'
-import { red, dim } from 'kolorist'
-import { run } from './index.mjs'
-
-const argv = minimist(process.argv.slice(2), {
-  'alias': {
-    r: 'root',
-    c: 'config',
-    h: 'help',
-    w: 'watch',
-    s: 'silent',
-  },
-  '--': true,
-  'string': ['root', 'config'],
-  'boolean': ['help', 'vue', 'watch', 'silent'],
-  unknown(name) {
-    if (name[0] === '-') {
-      console.error(red(`Unknown argument: ${name}`))
-      help()
-      process.exit(1)
-    }
-  },
-})
-
-if (argv.help) {
-  help()
-  process.exit(0)
-}
-
-if (!argv._.length) {
-  console.error(red('No files specified.'))
-  help()
-  process.exit(1)
-}
-
-// forward argv
-process.argv = [process.argv.slice(0, 2), ...argv['--']]
-
-run(argv)
-
-function help() {
-  console.log(`
-Usage:
-  $ vite-node [options] [files]
-
-Options:
-  -r, --root <path>      ${dim('[string]')} use specified root directory
-  -c, --config <file>    ${dim('[string]')} use specified config file
-  -w, --watch           ${dim('[boolean]')} restart on file changes, similar to "nodemon"
-  -s, --silent          ${dim('[boolean]')} do not emit errors and logs
-  --vue                 ${dim('[boolean]')} support for importing Vue component
-`)
-}

package/index.mjs

@@ -1,210 +0,0 @@
-/* eslint-disable no-console */
-import { builtinModules, createRequire } from 'module'
-import { pathToFileURL } from 'url'
-import { dirname, resolve, relative } from 'path'
-import vm from 'vm'
-import { createServer, mergeConfig } from 'vite'
-import createDebug from 'debug'
-import { red, dim, yellow, green, inverse, cyan } from 'kolorist'
-
-const debugRequest = createDebug('vite-node:request')
-const debugTransform = createDebug('vite-node:transform')
-
-let executing = false
-
-export async function run(argv) {
-  process.exitCode = 0
-  executing = true
-  let err
-
-  function log(...args) {
-    if (argv.silent)
-      return
-    console.log(...args)
-  }
-
-  const root = argv.root || process.cwd()
-  process.chdir(root)
-
-  const files = argv.files || argv._
-
-  const shouldExternalize = argv.shouldExternalize || (id => id.includes('/node_modules/'))
-
-  const server = await createServer(mergeConfig(argv.defaultConfig || {}, {
-    logLevel: 'error',
-    clearScreen: false,
-    configFile: argv.config,
-    root,
-    resolve: argv.vue
-      ? {
-        alias: {
-          // fix for Vue does not support mjs yet
-          'vue/server-renderer': 'vue/server-renderer',
-          'vue/compiler-sfc': 'vue/compiler-sfc',
-          '@vue/reactivity': '@vue/reactivity/dist/reactivity.cjs.js',
-          '@vue/shared': '@vue/shared/dist/shared.cjs.js',
-          'vue-router': 'vue-router/dist/vue-router.cjs.js',
-          'vue': 'vue/dist/vue.cjs.js',
-        },
-      }
-      : {},
-  }))
-  await server.pluginContainer.buildStart({})
-
-  process.__vite_node__ = {
-    server,
-  }
-
-  async function run() {
-    try {
-      await execute(files, server, shouldExternalize)
-    }
-    catch (e) {
-      console.error(e)
-      err = e
-      if (!argv.watch)
-        process.exit(1)
-    }
-    finally {
-      executing = false
-    }
-  }
-
-  if (argv.watch) {
-    log(inverse(cyan(' vite node ')), cyan('watch mode enabled\n'))
-
-    server.watcher.on('change', (file) => {
-      if (!executing) {
-        log(inverse(yellow(' vite node ')), yellow(`${file} changed, restarting...\n`))
-        run()
-      }
-    })
-  }
-  else {
-    await run()
-  }
-
-  if (argv.watch) {
-    setTimeout(() => {
-      if (err || process.exitCode)
-        log(inverse(red(' vite node ')), red('program exited with error, waiting for file changes...'))
-      else
-        log(inverse(green(' vite node ')), green('program exited, waiting for file changes...'))
-    }, 10)
-  }
-  else {
-    await server.close()
-  }
-}
-
-function normalizeId(id) {
-  // Virtual modules start with `\0`
-  if (id && id.startsWith('/@id/__x00__'))
-    id = `\0${id.slice('/@id/__x00__'.length)}`
-  if (id && id.startsWith('/@id/'))
-    id = id.slice('/@id/'.length)
-  return id
-}
-
-function toFilePath(id, server) {
-  let absolute = id.startsWith('/@fs/')
-    ? id.slice(4)
-    : id.startsWith(dirname(server.config.root))
-      ? id
-      : slash(resolve(server.config.root, id.slice(1)))
-
-  if (absolute.startsWith('//'))
-    absolute = absolute.slice(1)
-  if (!absolute.startsWith('/'))
-    absolute = `/${absolute}`
-
-  return absolute
-}
-
-async function execute(files, server, shouldExternalize) {
-  const __pendingModules__ = new Map()
-
-  const result = []
-  for (const file of files)
-    result.push(await cachedRequest(`/@fs/${slash(resolve(file))}`, []))
-  return result
-
-  async function directRequest(rawId, callstack) {
-    if (builtinModules.includes(rawId))
-      return import(rawId)
-
-    callstack = [...callstack, rawId]
-    const request = async(dep) => {
-      if (callstack.includes(dep)) {
-        throw new Error(`${red('Circular dependency detected')}\nStack:\n${[...callstack, dep].reverse().map((i) => {
-          const path = relative(server.config.root, toFilePath(normalizeId(i), server))
-          return dim(' -> ') + (i === dep ? yellow(path) : path)
-        }).join('\n')}\n`)
-      }
-      return cachedRequest(dep, callstack)
-    }
-
-    const id = normalizeId(rawId)
-    const absolute = toFilePath(id, server)
-
-    debugRequest(absolute)
-
-    if (shouldExternalize(absolute))
-      return import(absolute)
-
-    const result = await server.transformRequest(id, { ssr: true })
-    if (!result)
-      throw new Error(`failed to load ${id}`)
-
-    debugTransform(id, result.code)
-
-    const url = pathToFileURL(absolute)
-    const exports = {}
-
-    const context = {
-      require: createRequire(url),
-      __filename: absolute,
-      __dirname: dirname(absolute),
-      __vite_ssr_import__: request,
-      __vite_ssr_dynamic_import__: request,
-      __vite_ssr_exports__: exports,
-      __vite_ssr_exportAll__: obj => exportAll(exports, obj),
-      __vite_ssr_import_meta__: { url },
-    }
-
-    const fn = vm.runInThisContext(`async (${Object.keys(context).join(',')}) => { ${result.code} }`, {
-      filename: absolute,
-      lineOffset: 0,
-    })
-    await fn(...Object.values(context))
-
-    return exports
-  }
-
-  async function cachedRequest(id, callstack) {
-    if (__pendingModules__[id])
-      return __pendingModules__[id]
-    __pendingModules__[id] = directRequest(id, callstack)
-    return await __pendingModules__[id]
-  }
-
-  function exportAll(exports, sourceModule) {
-    // eslint-disable-next-line no-restricted-syntax
-    for (const key in sourceModule) {
-      if (key !== 'default') {
-        try {
-          Object.defineProperty(exports, key, {
-            enumerable: true,
-            configurable: true,
-            get() { return sourceModule[key] },
-          })
-        }
-        catch (_err) { }
-      }
-    }
-  }
-}
-
-function slash(path) {
-  return path.replace(/\\/g, '/')
-}