vite-node 0.23.4 → 0.24.0

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/cli.cjs

@@ -630,7 +630,7 @@ class CAC extends events.EventEmitter {
 
 const cac = (name = "") => new CAC(name);
 
-var version = "0.23.4";
+var version = "0.24.0";
 
 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-9a69ad8d.js';
+import { e as ViteNodeServerOptions } from './types-11eb03da.js';
 
 interface CliOptions {
     root?: string;

package/dist/cli.mjs

@@ -628,7 +628,7 @@ class CAC extends EventEmitter {
 
 const cac = (name = "") => new CAC(name);
 
-var version = "0.23.4";
+var version = "0.24.0";
 
 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.d.ts

@@ -1 +1 @@
-export { j as DEFAULT_REQUEST_STUBS, M as ModuleCacheMap, h as ViteNodeRunner } from './types-9a69ad8d.js';
+export { j as DEFAULT_REQUEST_STUBS, M as ModuleCacheMap, h as ViteNodeRunner } from './types-11eb03da.js';

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-9a69ad8d.js';
+import { g as CustomEventMap, h as ViteNodeRunner, i as HMRPayload$1, H as HotContext } from './types-11eb03da.js';
 
 declare type EventType = string | symbol;
 declare type Handler<T = unknown> = (event: T) => void;
@@ -21,12 +21,6 @@ declare module 'vite' {
 declare function createHmrEmitter(): HMREmitter;
 declare function viteNodeHmrPlugin(): Plugin;
 
-interface CustomEventMap {
-    'vite:beforeUpdate': UpdatePayload;
-    'vite:beforePrune': PrunePayload;
-    'vite:beforeFullReload': FullReloadPayload;
-    'vite:error': ErrorPayload;
-}
 declare type InferCustomEventPayload<T extends string> = T extends keyof CustomEventMap ? CustomEventMap[T] : any;
 interface HotModule {
     id: string;
@@ -54,4 +48,4 @@ declare function reload(runner: ViteNodeRunner, files: string[]): Promise<any[]>
 declare function handleMessage(runner: ViteNodeRunner, emitter: HMREmitter, files: string[], payload: HMRPayload$1): Promise<void>;
 declare function createHotContext(runner: ViteNodeRunner, emitter: HMREmitter, files: string[], ownerPath: string): HotContext;
 
-export { CustomEventMap, Emitter, EventType, HMREmitter, Handler, HotCallback, HotModule, InferCustomEventPayload, createHmrEmitter, createHotContext, getCache, handleMessage, reload, sendMessageBuffer, viteNodeHmrPlugin };
+export { Emitter, EventType, HMREmitter, Handler, HotCallback, HotModule, InferCustomEventPayload, createHmrEmitter, createHotContext, getCache, handleMessage, reload, sendMessageBuffer, viteNodeHmrPlugin };

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-9a69ad8d.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-11eb03da.js';

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-9a69ad8d.js';
+import { f as DebuggerOptions, D as DepsHandlingOptions, e as ViteNodeServerOptions, F as FetchResult, d as ViteNodeResolveId } from './types-11eb03da.js';
 
 declare class Debugger {
     options: DebuggerOptions;

package/dist/{types-9a69ad8d.d.ts → types-11eb03da.d.ts}

@@ -254,4 +254,4 @@ interface DebuggerOptions {
     loadDumppedModules?: boolean;
 }
 
-export { Arrayable as A, CreateHotContextFunction as C, DepsHandlingOptions as D, ErrorPayload as E, FetchResult as F, HotContext as H, ModuleCacheMap as M, Nullable as N, PrunePayload as P, RawSourceMap as R, StartOfSourceMap as S, UpdatePayload as U, ViteNodeRunnerOptions as V, FetchFunction as a, ResolveIdFunction as b, ModuleCache as c, ViteNodeResolveId as d, ViteNodeServerOptions as e, DebuggerOptions as f, FullReloadPayload as g, ViteNodeRunner as h, HMRPayload as i, DEFAULT_REQUEST_STUBS as j };
+export { Arrayable as A, CreateHotContextFunction as C, DepsHandlingOptions as D, FetchResult as F, HotContext as H, ModuleCacheMap as M, Nullable as N, RawSourceMap as R, StartOfSourceMap as S, ViteNodeRunnerOptions as V, FetchFunction as a, ResolveIdFunction as b, ModuleCache as c, ViteNodeResolveId as d, ViteNodeServerOptions as e, DebuggerOptions as f, CustomEventMap as g, ViteNodeRunner as h, HMRPayload as i, DEFAULT_REQUEST_STUBS as j };

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-9a69ad8d.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-11eb03da.js';

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
 import { TransformResult } from 'vite';
-import { N as Nullable, A as Arrayable } from './types-9a69ad8d.js';
+import { N as Nullable, A as Arrayable } from './types-11eb03da.js';
 
 declare const isWindows: boolean;
 declare function slash(str: string): string;

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.23.4",
+  "version": "0.24.0",
   "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.14",
+    "mlly": "^0.5.16",
     "pathe": "^0.2.0",
-    "vite": "^2.9.12 || ^3.0.0-0"
+    "vite": "^3.0.0"
   },
   "devDependencies": {
     "@types/debug": "^4.1.7",
     "cac": "^6.7.14",
     "picocolors": "^1.0.0",
-    "rollup": "^2.79.0"
+    "rollup": "^2.79.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 };