vite-node 0.13.0 → 0.13.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/cli.cjs

@@ -625,9 +625,9 @@ class CAC extends events.EventEmitter {
   }
 }
 
-const cac = (name = "") => new CAC(name);
+const cac = (name) => new CAC(name);
 
-var version = "0.13.0";
+var version = "0.13.1";
 
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;

package/dist/cli.js

@@ -623,9 +623,9 @@ class CAC extends EventEmitter {
   }
 }
 
-const cac = (name = "") => new CAC(name);
+const cac = (name) => new CAC(name);
 
-var version = "0.13.0";
+var version = "0.13.1";
 
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;

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,7 +1,7 @@
 {
   "name": "vite-node",
   "type": "module",
-  "version": "0.13.0",
+  "version": "0.13.1",
   "description": "Vite as Node.js runtime",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -18,23 +18,23 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
     },
     "./client": {
       "types": "./dist/client.d.ts",
-      "import": "./dist/client.js",
-      "require": "./dist/client.cjs"
+      "require": "./dist/client.cjs",
+      "import": "./dist/client.js"
     },
     "./server": {
       "types": "./dist/server.d.ts",
-      "import": "./dist/server.js",
-      "require": "./dist/server.cjs"
+      "require": "./dist/server.cjs",
+      "import": "./dist/server.js"
     },
     "./utils": {
       "types": "./dist/utils.d.ts",
-      "import": "./dist/utils.js",
-      "require": "./dist/utils.cjs"
+      "require": "./dist/utils.cjs",
+      "import": "./dist/utils.js"
     }
   },
   "main": "./dist/index.js",
@@ -69,7 +69,7 @@
   "devDependencies": {
     "@types/debug": "^4.1.7",
     "cac": "^6.7.12",
-    "rollup": "^2.74.1"
+    "rollup": "^2.75.3"
   },
   "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 };