vite 6.0.0-beta.8 → 6.0.0

package/dist/node/index.js

@@ -1,7 +1,7 @@
 export { parseAst, parseAstAsync } from 'rollup/parseAst';
-import { i as isInNodeModules, a as arraify } from './chunks/dep-Ddvoc4zx.js';
-export { B as BuildEnvironment, D as DevEnvironment, S as ServerHMRConnector, b as build, j as buildErrorMessage, e as createBuilder, z as createFilter, f as createIdResolver, E as createLogger, k as createRunnableDevEnvironment, c as createServer, u as createServerHotChannel, q as createServerModuleRunner, d as defineConfig, n as fetchModule, g as formatPostcssSourceMap, H as isFileLoadingAllowed, G as isFileServingAllowed, m as isRunnableDevEnvironment, l as loadConfigFromFile, I as loadEnv, y as mergeAlias, x as mergeConfig, v as moduleRunnerTransform, w as normalizePath, o as optimizeDeps, h as preprocessCSS, p as preview, r as resolveConfig, J as resolveEnvPrefix, A as rollupVersion, F as searchForWorkspaceRoot, C as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-Ddvoc4zx.js';
-export { VERSION as version } from './constants.js';
+import { i as isInNodeModules, a as arraify } from './chunks/dep-C6qYk3zB.js';
+export { B as BuildEnvironment, D as DevEnvironment, f as build, m as buildErrorMessage, g as createBuilder, C as createFilter, h as createIdResolver, G as createLogger, n as createRunnableDevEnvironment, c as createServer, w as createServerHotChannel, v as createServerModuleRunner, d as defineConfig, u as fetchModule, j as formatPostcssSourceMap, J as isFileLoadingAllowed, I as isFileServingAllowed, q as isRunnableDevEnvironment, l as loadConfigFromFile, K as loadEnv, A as mergeAlias, z as mergeConfig, x as moduleRunnerTransform, y as normalizePath, o as optimizeDeps, p as perEnvironmentPlugin, b as perEnvironmentState, k as preprocessCSS, e as preview, r as resolveConfig, L as resolveEnvPrefix, E as rollupVersion, H as searchForWorkspaceRoot, F as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-C6qYk3zB.js';
+export { DEFAULT_CLIENT_CONDITIONS as defaultClientConditions, DEFAULT_CLIENT_MAIN_FIELDS as defaultClientMainFields, DEFAULT_SERVER_CONDITIONS as defaultServerConditions, DEFAULT_SERVER_MAIN_FIELDS as defaultServerMainFields, VERSION as version } from './constants.js';
 export { version as esbuildVersion } from 'esbuild';
 import 'node:fs';
 import 'node:fs/promises';
@@ -21,7 +21,6 @@ import 'net';
 import 'events';
 import 'url';
 import 'http';
-import 'fs/promises';
 import 'stream';
 import 'os';
 import 'child_process';
@@ -33,17 +32,17 @@ import 'module';
 import 'node:readline';
 import 'node:process';
 import 'node:buffer';
+import 'node:events';
 import 'crypto';
 import 'node:assert';
 import 'node:v8';
 import 'node:worker_threads';
-import 'node:events';
 import 'zlib';
 import 'buffer';
 import 'https';
 import 'tls';
 import 'assert';
-import 'querystring';
+import 'node:querystring';
 import 'node:zlib';
 
 const CSS_LANGS_RE = (
@@ -150,35 +149,4 @@ function splitVendorChunkPlugin() {
   };
 }
 
-class RemoteEnvironmentTransport {
-  constructor(options) {
-    this.options = options;
-  }
-  register(environment) {
-    this.options.onMessage(async (data) => {
-      if (typeof data !== "object" || !data || !data.__v) return;
-      const method = data.m;
-      const parameters = data.a;
-      try {
-        const result = await environment[method](...parameters);
-        this.options.send({
-          __v: true,
-          r: result,
-          i: data.i
-        });
-      } catch (error) {
-        this.options.send({
-          __v: true,
-          e: {
-            name: error.name,
-            message: error.message,
-            stack: error.stack
-          },
-          i: data.i
-        });
-      }
-    });
-  }
-}
-
-export { RemoteEnvironmentTransport, isCSSRequest, splitVendorChunk, splitVendorChunkPlugin };
+export { isCSSRequest, splitVendorChunk, splitVendorChunkPlugin };

package/dist/node/module-runner.d.ts

@@ -2,6 +2,89 @@ import { ModuleNamespace, ViteHotContext } from '../../types/hot.js';
 import { HotPayload, Update } from '../../types/hmrPayload.js';
 import { InferCustomEventPayload } from '../../types/customEvent.js';
 
+interface FetchFunctionOptions {
+    cached?: boolean;
+    startOffset?: number;
+}
+type FetchResult = CachedFetchResult | ExternalFetchResult | ViteFetchResult;
+interface CachedFetchResult {
+    /**
+     * If module cached in the runner, we can just confirm
+     * it wasn't invalidated on the server side.
+     */
+    cache: true;
+}
+interface ExternalFetchResult {
+    /**
+     * The path to the externalized module starting with file://,
+     * by default this will be imported via a dynamic "import"
+     * instead of being transformed by vite and loaded with vite runner
+     */
+    externalize: string;
+    /**
+     * Type of the module. Will be used to determine if import statement is correct.
+     * For example, if Vite needs to throw an error if variable is not actually exported
+     */
+    type: 'module' | 'commonjs' | 'builtin' | 'network';
+}
+interface ViteFetchResult {
+    /**
+     * Code that will be evaluated by vite runner
+     * by default this will be wrapped in an async function
+     */
+    code: string;
+    /**
+     * File path of the module on disk.
+     * This will be resolved as import.meta.url/filename
+     * Will be equal to `null` for virtual modules
+     */
+    file: string | null;
+    /**
+     * Module ID in the server module graph.
+     */
+    id: string;
+    /**
+     * Module URL used in the import.
+     */
+    url: string;
+    /**
+     * Invalidate module on the client side.
+     */
+    invalidate: boolean;
+}
+type InvokeMethods = {
+    fetchModule: (id: string, importer?: string, options?: FetchFunctionOptions) => Promise<FetchResult>;
+};
+
+type ModuleRunnerTransportHandlers = {
+    onMessage: (data: HotPayload) => void;
+    onDisconnection: () => void;
+};
+/**
+ * "send and connect" or "invoke" must be implemented
+ */
+interface ModuleRunnerTransport {
+    connect?(handlers: ModuleRunnerTransportHandlers): Promise<void> | void;
+    disconnect?(): Promise<void> | void;
+    send?(data: HotPayload): Promise<void> | void;
+    invoke?(data: HotPayload): Promise<{
+        r: any;
+    } | {
+        e: any;
+    }>;
+    timeout?: number;
+}
+interface NormalizedModuleRunnerTransport {
+    connect?(onMessage?: (data: HotPayload) => void): Promise<void> | void;
+    disconnect?(): Promise<void> | void;
+    send(data: HotPayload): Promise<void>;
+    invoke<T extends keyof InvokeMethods>(name: T, data: Parameters<InvokeMethods[T]>): Promise<ReturnType<Awaited<InvokeMethods[T]>>>;
+}
+declare const createWebSocketModuleRunnerTransport: (options: {
+    createConnection: () => WebSocket;
+    pingInterval?: number;
+}) => Required<Pick<ModuleRunnerTransport, "connect" | "disconnect" | "send">>;
+
 interface SourceMapLike {
     version: number;
     mappings?: string;
@@ -39,25 +122,9 @@ interface HMRLogger {
     error(msg: string | Error): void;
     debug(...msg: unknown[]): void;
 }
-interface HMRConnection {
-    /**
-     * Checked before sending messages to the client.
-     */
-    isReady(): boolean;
-    /**
-     * Send message to the client.
-     */
-    send(messages: HotPayload): void;
-}
-declare class HMRMessenger {
-    private connection;
-    constructor(connection: HMRConnection);
-    private queue;
-    send(payload: HotPayload): void;
-    flush(): void;
-}
 declare class HMRClient {
     logger: HMRLogger;
+    private transport;
     private importUpdatedModule;
     hotModulesMap: Map<string, HotModule>;
     disposeMap: Map<string, (data: any) => void | Promise<void>>;
@@ -65,9 +132,9 @@ declare class HMRClient {
     dataMap: Map<string, any>;
     customListenersMap: CustomListenersMap;
     ctxToListenersMap: Map<string, CustomListenersMap>;
-    messenger: HMRMessenger;
-    constructor(logger: HMRLogger, connection: HMRConnection, importUpdatedModule: (update: Update) => Promise<ModuleNamespace>);
+    constructor(logger: HMRLogger, transport: NormalizedModuleRunnerTransport, importUpdatedModule: (update: Update) => Promise<ModuleNamespace>);
     notifyListeners<T extends string>(event: T, data: InferCustomEventPayload<T>): Promise<void>;
+    send(payload: HotPayload): void;
     clear(): void;
     prunePaths(paths: string[]): Promise<void>;
     protected warnFailedUpdate(err: Error, path: string | string[]): void;
@@ -119,7 +186,7 @@ declare class ModuleRunner {
     private readonly root;
     private readonly concurrentModuleNodePromises;
     private closed;
-    constructor(options: ModuleRunnerOptions, evaluator: ModuleEvaluator, debug?: ModuleRunnerDebugger | undefined);
+    constructor(options: ModuleRunnerOptions, evaluator?: ModuleEvaluator, debug?: ModuleRunnerDebugger | undefined);
     /**
      * URL to execute. Accepts file path, server path or id relative to the root.
      */
@@ -160,28 +227,6 @@ interface InterceptorOptions {
     retrieveSourceMap?: RetrieveSourceMapHandler;
 }
 
-interface RunnerTransport {
-    fetchModule: FetchFunction;
-}
-declare class RemoteRunnerTransport implements RunnerTransport {
-    private readonly options;
-    private rpcPromises;
-    constructor(options: {
-        send: (data: any) => void;
-        onMessage: (handler: (data: any) => void) => void;
-        timeout?: number;
-    });
-    private resolve;
-    fetchModule(id: string, importer?: string): Promise<FetchResult>;
-}
-
-interface ModuleRunnerHMRConnection extends HMRConnection {
-    /**
-     * Configure how HMR is handled when this connection triggers an update.
-     * This method expects that connection will start listening for HMR updates and call this callback when it's received.
-     */
-    onUpdate(callback: (payload: HotPayload) => void): void;
-}
 interface ModuleRunnerImportMeta extends ImportMeta {
     url: string;
     env: ImportMetaEnv;
@@ -213,66 +258,12 @@ interface ModuleEvaluator {
      */
     runExternalModule(file: string): Promise<any>;
 }
-type FetchResult = CachedFetchResult | ExternalFetchResult | ViteFetchResult;
-interface CachedFetchResult {
-    /**
-     * If module cached in the runner, we can just confirm
-     * it wasn't invalidated on the server side.
-     */
-    cache: true;
-}
-interface ExternalFetchResult {
-    /**
-     * The path to the externalized module starting with file://,
-     * by default this will be imported via a dynamic "import"
-     * instead of being transformed by vite and loaded with vite runner
-     */
-    externalize: string;
-    /**
-     * Type of the module. Will be used to determine if import statement is correct.
-     * For example, if Vite needs to throw an error if variable is not actually exported
-     */
-    type: 'module' | 'commonjs' | 'builtin' | 'network';
-}
-interface ViteFetchResult {
-    /**
-     * Code that will be evaluated by vite runner
-     * by default this will be wrapped in an async function
-     */
-    code: string;
-    /**
-     * File path of the module on disk.
-     * This will be resolved as import.meta.url/filename
-     * Will be equal to `null` for virtual modules
-     */
-    file: string | null;
-    /**
-     * Module ID in the server module graph.
-     */
-    id: string;
-    /**
-     * Module URL used in the import.
-     */
-    url: string;
-    /**
-     * Invalidate module on the client side.
-     */
-    invalidate: boolean;
-}
 type ResolvedResult = (ExternalFetchResult | ViteFetchResult) & {
     url: string;
     id: string;
 };
 type FetchFunction = (id: string, importer?: string, options?: FetchFunctionOptions) => Promise<FetchResult>;
-interface FetchFunctionOptions {
-    cached?: boolean;
-    startOffset?: number;
-}
 interface ModuleRunnerHmr {
-    /**
-     * Configure how HMR communicates between the client and the server.
-     */
-    connection: ModuleRunnerHMRConnection;
     /**
      * Configure HMR logger.
      */
@@ -286,7 +277,7 @@ interface ModuleRunnerOptions {
     /**
      * A set of methods to communicate with the server.
      */
-    transport: RunnerTransport;
+    transport: ModuleRunnerTransport;
     /**
      * Configure how source maps are resolved. Prefers `node` if `process.setSourceMapsEnabled` is available.
      * Otherwise it will use `prepareStackTrace` by default which overrides `Error.prepareStackTrace` method.
@@ -295,8 +286,10 @@ interface ModuleRunnerOptions {
     sourcemapInterceptor?: false | 'node' | 'prepareStackTrace' | InterceptorOptions;
     /**
      * Disable HMR or configure HMR options.
+     *
+     * @default true
      */
-    hmr?: false | ModuleRunnerHmr;
+    hmr?: boolean | ModuleRunnerHmr;
     /**
      * Custom module cache. If not provided, creates a separate module cache for each ModuleRunner instance.
      */
@@ -373,4 +366,4 @@ declare class ESModulesEvaluator implements ModuleEvaluator {
     runExternalModule(filepath: string): Promise<any>;
 }
 
-export { ESModulesEvaluator, EvaluatedModuleNode, EvaluatedModules, type FetchFunction, type FetchFunctionOptions, type FetchResult, type HMRConnection, type HMRLogger, type ModuleEvaluator, ModuleRunner, type ModuleRunnerContext, type ModuleRunnerHMRConnection, type ModuleRunnerHmr, type ModuleRunnerImportMeta, type ModuleRunnerOptions, RemoteRunnerTransport, type ResolvedResult, type RunnerTransport, type SSRImportMetadata, ssrDynamicImportKey, ssrExportAllKey, ssrImportKey, ssrImportMetaKey, ssrModuleExportsKey };
+export { ESModulesEvaluator, EvaluatedModuleNode, EvaluatedModules, type FetchFunction, type FetchFunctionOptions, type FetchResult, type HMRLogger, type InterceptorOptions, type ModuleEvaluator, ModuleRunner, type ModuleRunnerContext, type ModuleRunnerHmr, type ModuleRunnerImportMeta, type ModuleRunnerOptions, type ModuleRunnerTransport, type ModuleRunnerTransportHandlers, type ResolvedResult, type SSRImportMetadata, createWebSocketModuleRunnerTransport, ssrDynamicImportKey, ssrExportAllKey, ssrImportKey, ssrImportMetaKey, ssrModuleExportsKey };