vite 6.0.0-beta.1 → 6.0.0-beta.10

package/dist/node/index.js

@@ -1,25 +1,21 @@
 export { parseAst, parseAstAsync } from 'rollup/parseAst';
-import { i as isInNodeModules, a as arraify } from './chunks/dep-BZ_CwQkz.js';
-export { B as BuildEnvironment, D as DevEnvironment, b as build, j as buildErrorMessage, e as createBuilder, x as createFilter, f as createIdResolver, A as createLogger, k as createNodeDevEnvironment, c as createServer, n as createServerHotChannel, d as defineConfig, m as fetchModule, g as formatPostcssSourceMap, F as isFileLoadingAllowed, E as isFileServingAllowed, l as loadConfigFromFile, G as loadEnv, w as mergeAlias, v as mergeConfig, q as moduleRunnerTransform, u as normalizePath, o as optimizeDeps, h as preprocessCSS, p as preview, r as resolveConfig, H as resolveEnvPrefix, y as rollupVersion, C as searchForWorkspaceRoot, z as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-BZ_CwQkz.js';
-import { existsSync, readFileSync } from 'node:fs';
-import { ModuleRunner, ESModulesEvaluator } from 'vite/module-runner';
-export { VERSION as version } from './constants.js';
+import { i as isInNodeModules, a as arraify } from './chunks/dep-DiRA7B7B.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-DiRA7B7B.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';
 import 'node:path';
 import 'node:url';
 import 'node:util';
 import 'node:perf_hooks';
 import 'node:module';
-import 'tty';
 import 'path';
 import 'fs';
-import 'node:events';
-import 'node:stream';
-import 'node:string_decoder';
 import 'node:child_process';
 import 'node:http';
 import 'node:https';
+import 'tty';
 import 'util';
 import 'net';
 import 'events';
@@ -31,19 +27,22 @@ import 'child_process';
 import 'node:os';
 import 'node:crypto';
 import 'node:dns';
+import 'vite/module-runner';
 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 'crypto';
-import 'node:buffer';
-import 'node:readline';
 import 'zlib';
 import 'buffer';
 import 'https';
 import 'tls';
 import 'assert';
-import 'querystring';
+import 'node:querystring';
 import 'node:zlib';
 
 const CSS_LANGS_RE = (
@@ -150,143 +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
-        });
-      }
-    });
-  }
-}
-
-class ServerHMRBroadcasterClient {
-  constructor(hotChannel) {
-    this.hotChannel = hotChannel;
-  }
-  send(...args) {
-    let payload;
-    if (typeof args[0] === "string") {
-      payload = {
-        type: "custom",
-        event: args[0],
-        data: args[1]
-      };
-    } else {
-      payload = args[0];
-    }
-    if (payload.type !== "custom") {
-      throw new Error(
-        "Cannot send non-custom events from the client to the server."
-      );
-    }
-    this.hotChannel.send(payload);
-  }
-}
-class ServerHMRConnector {
-  constructor(hotChannel) {
-    this.hotChannel = hotChannel;
-    this.hmrClient = new ServerHMRBroadcasterClient(hotChannel);
-    hotChannel.api.outsideEmitter.on("send", (payload) => {
-      this.handlers.forEach((listener) => listener(payload));
-    });
-    this.hotChannel = hotChannel;
-  }
-  handlers = [];
-  hmrClient;
-  connected = false;
-  isReady() {
-    return this.connected;
-  }
-  send(message) {
-    const payload = JSON.parse(message);
-    this.hotChannel.api.innerEmitter.emit(
-      payload.event,
-      payload.data,
-      this.hmrClient
-    );
-  }
-  onUpdate(handler) {
-    this.handlers.push(handler);
-    handler({ type: "connected" });
-    this.connected = true;
-  }
-}
-
-function createHMROptions(environment, options) {
-  if (environment.config.server.hmr === false || options.hmr === false) {
-    return false;
-  }
-  if (options.hmr?.connection) {
-    return {
-      connection: options.hmr.connection,
-      logger: options.hmr.logger
-    };
-  }
-  if (!("api" in environment.hot)) return false;
-  const connection = new ServerHMRConnector(environment.hot);
-  return {
-    connection,
-    logger: options.hmr?.logger
-  };
-}
-const prepareStackTrace = {
-  retrieveFile(id) {
-    if (existsSync(id)) {
-      return readFileSync(id, "utf-8");
-    }
-  }
-};
-function resolveSourceMapOptions(options) {
-  if (options.sourcemapInterceptor != null) {
-    if (options.sourcemapInterceptor === "prepareStackTrace") {
-      return prepareStackTrace;
-    }
-    if (typeof options.sourcemapInterceptor === "object") {
-      return { ...prepareStackTrace, ...options.sourcemapInterceptor };
-    }
-    return options.sourcemapInterceptor;
-  }
-  if (typeof process !== "undefined" && "setSourceMapsEnabled" in process) {
-    return "node";
-  }
-  return prepareStackTrace;
-}
-function createServerModuleRunner(environment, options = {}) {
-  const hmr = createHMROptions(environment, options);
-  return new ModuleRunner(
-    {
-      ...options,
-      root: environment.config.root,
-      transport: {
-        fetchModule: (id, importer, options2) => environment.fetchModule(id, importer, options2)
-      },
-      hmr,
-      sourcemapInterceptor: resolveSourceMapOptions(options)
-    },
-    options.evaluator || new ESModulesEvaluator()
-  );
-}
-
-export { RemoteEnvironmentTransport, ServerHMRConnector, createServerModuleRunner, isCSSRequest, splitVendorChunk, splitVendorChunkPlugin };
+export { isCSSRequest, splitVendorChunk, splitVendorChunkPlugin };

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

@@ -1,7 +1,90 @@
 import { ModuleNamespace, ViteHotContext } from '../../types/hot.js';
-import { Update, HotPayload } from '../../types/hmrPayload.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): 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: string): void;
-}
-declare class HMRMessenger {
-    private connection;
-    constructor(connection: HMRConnection);
-    private queue;
-    send(message: string): 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;
@@ -111,20 +178,14 @@ declare class ModuleRunner {
     options: ModuleRunnerOptions;
     evaluator: ModuleEvaluator;
     private debug?;
-    /**
-     * Holds the cache of modules
-     * Keys of the map are ids
-     */
-    moduleCache: ModuleCacheMap;
+    evaluatedModules: EvaluatedModules;
     hmrClient?: HMRClient;
-    private readonly urlToIdMap;
-    private readonly fileToIdMap;
     private readonly envProxy;
     private readonly transport;
     private readonly resetSourceMapSupport?;
     private readonly root;
-    private readonly moduleInfoCache;
-    private destroyed;
+    private readonly concurrentModuleNodePromises;
+    private closed;
     constructor(options: ModuleRunnerOptions, evaluator: ModuleEvaluator, debug?: ModuleRunnerDebugger | undefined);
     /**
      * URL to execute. Accepts file path, server path or id relative to the root.
@@ -138,18 +199,18 @@ declare class ModuleRunner {
      * Clears all caches, removes all HMR listeners, and resets source map support.
      * This method doesn't stop the HMR connection.
      */
-    destroy(): Promise<void>;
+    close(): Promise<void>;
     /**
-     * Returns `true` if the runtime has been destroyed by calling `destroy()` method.
+     * Returns `true` if the runtime has been closed by calling `close()` method.
      */
-    isDestroyed(): boolean;
+    isClosed(): boolean;
     private processImport;
     private isCircularModule;
     private isCircularImport;
     private cachedRequest;
     private cachedModule;
     private getModuleInformation;
-    protected directRequest(id: string, mod: ModuleCache, _callstack: string[]): Promise<any>;
+    protected directRequest(url: string, mod: EvaluatedModuleNode, _callstack: string[]): Promise<any>;
 }
 
 interface RetrieveFileHandler {
@@ -166,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;
@@ -202,85 +241,29 @@ interface ModuleRunnerContext {
     [ssrImportMetaKey]: ModuleRunnerImportMeta;
 }
 interface ModuleEvaluator {
+    /**
+     * Number of prefixed lines in the transformed code.
+     */
+    startOffset?: number;
     /**
      * Run code that was transformed by Vite.
      * @param context Function context
      * @param code Transformed code
-     * @param id ID that was used to fetch the module
+     * @param module The module node
      */
-    runInlinedModule(context: ModuleRunnerContext, code: string, id: string): Promise<any>;
+    runInlinedModule(context: ModuleRunnerContext, code: string, module: Readonly<EvaluatedModuleNode>): Promise<any>;
     /**
      * Run externalized module.
      * @param file File URL to the external module
      */
     runExternalModule(file: string): Promise<any>;
 }
-interface ModuleCache {
-    promise?: Promise<any>;
-    exports?: any;
-    evaluated?: boolean;
-    map?: DecodedMap;
-    meta?: ResolvedResult;
-    /**
-     * Module ids that imports this module
-     */
-    importers?: Set<string>;
-    imports?: Set<string>;
-}
-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.
-     */
-    serverId: 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;
-}
 interface ModuleRunnerHmr {
-    /**
-     * Configure how HMR communicates between the client and the server.
-     */
-    connection: ModuleRunnerHMRConnection;
     /**
      * Configure HMR logger.
      */
@@ -294,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.
@@ -304,11 +287,11 @@ interface ModuleRunnerOptions {
     /**
      * Disable HMR or configure HMR options.
      */
-    hmr?: false | ModuleRunnerHmr;
+    hmr?: boolean | ModuleRunnerHmr;
     /**
      * Custom module cache. If not provided, creates a separate module cache for each ModuleRunner instance.
      */
-    moduleCache?: ModuleCacheMap;
+    evaluatedModules?: EvaluatedModules;
 }
 interface ImportMetaEnv {
     [key: string]: any;
@@ -319,36 +302,66 @@ interface ImportMetaEnv {
     SSR: boolean;
 }
 
-declare class ModuleCacheMap extends Map<string, ModuleCache> {
-    private root;
-    constructor(root: string, entries?: [string, ModuleCache][]);
-    normalize(fsPath: string): string;
+declare class EvaluatedModuleNode {
+    id: string;
+    url: string;
+    importers: Set<string>;
+    imports: Set<string>;
+    evaluated: boolean;
+    meta: ResolvedResult | undefined;
+    promise: Promise<any> | undefined;
+    exports: any | undefined;
+    file: string;
+    map: DecodedMap | undefined;
+    constructor(id: string, url: string);
+}
+declare class EvaluatedModules {
+    readonly idToModuleMap: Map<string, EvaluatedModuleNode>;
+    readonly fileToModulesMap: Map<string, Set<EvaluatedModuleNode>>;
+    readonly urlToIdModuleMap: Map<string, EvaluatedModuleNode>;
+    /**
+     * Returns the module node by the resolved module ID. Usually, module ID is
+     * the file system path with query and/or hash. It can also be a virtual module.
+     *
+     * Module runner graph will have 1 to 1 mapping with the server module graph.
+     * @param id Resolved module ID
+     */
+    getModuleById(id: string): EvaluatedModuleNode | undefined;
     /**
-     * Assign partial data to the map
+     * Returns all modules related to the file system path. Different modules
+     * might have different query parameters or hash, so it's possible to have
+     * multiple modules for the same file.
+     * @param file The file system path of the module
      */
-    update(fsPath: string, mod: ModuleCache): this;
-    setByModuleId(modulePath: string, mod: ModuleCache): this;
-    set(fsPath: string, mod: ModuleCache): this;
-    getByModuleId(modulePath: string): ModuleCache;
-    get(fsPath: string): ModuleCache;
-    deleteByModuleId(modulePath: string): boolean;
-    delete(fsPath: string): boolean;
-    invalidateUrl(id: string): void;
-    invalidateModule(module: ModuleCache): void;
+    getModulesByFile(file: string): Set<EvaluatedModuleNode> | undefined;
     /**
-     * Invalidate modules that dependent on the given modules, up to the main entry
+     * Returns the module node by the URL that was used in the import statement.
+     * Unlike module graph on the server, the URL is not resolved and is used as is.
+     * @param url Server URL that was used in the import statement
      */
-    invalidateDepTree(ids: string[] | Set<string>, invalidated?: Set<string>): Set<string>;
+    getModuleByUrl(url: string): EvaluatedModuleNode | undefined;
     /**
-     * Invalidate dependency modules of the given modules, down to the bottom-level dependencies
+     * Ensure that module is in the graph. If the module is already in the graph,
+     * it will return the existing module node. Otherwise, it will create a new
+     * module node and add it to the graph.
+     * @param id Resolved module ID
+     * @param url URL that was used in the import statement
      */
-    invalidateSubDepTree(ids: string[] | Set<string>, invalidated?: Set<string>): Set<string>;
-    getSourceMap(moduleId: string): null | DecodedMap;
+    ensureModule(id: string, url: string): EvaluatedModuleNode;
+    invalidateModule(node: EvaluatedModuleNode): void;
+    /**
+     * Extracts the inlined source map from the module code and returns the decoded
+     * source map. If the source map is not inlined, it will return null.
+     * @param id Resolved module ID
+     */
+    getModuleSourceMapById(id: string): DecodedMap | null;
+    clear(): void;
 }
 
 declare class ESModulesEvaluator implements ModuleEvaluator {
+    startOffset: number;
     runInlinedModule(context: ModuleRunnerContext, code: string): Promise<any>;
     runExternalModule(filepath: string): Promise<any>;
 }
 
-export { ESModulesEvaluator, type FetchFunction, type FetchFunctionOptions, type FetchResult, type HMRConnection, type HMRLogger, type ModuleCache, ModuleCacheMap, 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 ModuleEvaluator, ModuleRunner, type ModuleRunnerContext, type ModuleRunnerHmr, type ModuleRunnerImportMeta, type ModuleRunnerOptions, type ModuleRunnerTransport, type ModuleRunnerTransportHandlers, type ResolvedResult, type SSRImportMetadata, createWebSocketModuleRunnerTransport, ssrDynamicImportKey, ssrExportAllKey, ssrImportKey, ssrImportMetaKey, ssrModuleExportsKey };