vite 5.2.8 → 6.0.0-alpha.0

package/dist/node/index.js

@@ -1,10 +1,10 @@
 export { parseAst, parseAstAsync } from 'rollup/parseAst';
-import { i as isInNodeModules, a as arraify } from './chunks/dep-whKeNLxG.js';
-export { b as build, g as buildErrorMessage, k as createFilter, v as createLogger, c as createServer, d as defineConfig, h as fetchModule, f as formatPostcssSourceMap, x as isFileServingAllowed, l as loadConfigFromFile, y as loadEnv, j as mergeAlias, m as mergeConfig, n as normalizePath, o as optimizeDeps, e as preprocessCSS, p as preview, r as resolveConfig, z as resolveEnvPrefix, q as rollupVersion, w as searchForWorkspaceRoot, u as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-whKeNLxG.js';
+import { i as isInNodeModules, a as arraify } from './chunks/dep-hQh5_mg-.js';
+export { B as BuildEnvironment, D as DevEnvironment, b as build, h as buildErrorMessage, u as createFilter, x as createLogger, j as createNodeDevEnvironment, c as createServer, e as createViteBuilder, d as defineConfig, k as fetchModule, f as formatPostcssSourceMap, z as isFileServingAllowed, l as loadConfigFromFile, A as loadEnv, q as mergeAlias, m as mergeConfig, n as normalizePath, o as optimizeDeps, g as preprocessCSS, p as preview, r as resolveConfig, C as resolveEnvPrefix, v as rollupVersion, y as searchForWorkspaceRoot, w as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-hQh5_mg-.js';
+import { existsSync, readFileSync } from 'node:fs';
+import { ModuleRunner, ESModulesEvaluator } from 'vite/module-runner';
 export { VERSION as version } from './constants.js';
 export { version as esbuildVersion } from 'esbuild';
-import { existsSync, readFileSync } from 'node:fs';
-import { ViteRuntime, ESModulesRunner } from 'vite/runtime';
 import 'node:fs/promises';
 import 'node:path';
 import 'node:url';
@@ -29,19 +29,19 @@ import 'child_process';
 import 'node:os';
 import 'node:crypto';
 import 'node:dns';
-import 'crypto';
-import 'module';
 import 'node:assert';
 import 'node:v8';
+import 'module';
 import 'node:worker_threads';
-import 'node:buffer';
 import 'node:events';
-import 'querystring';
+import 'crypto';
+import 'node:buffer';
 import 'node:readline';
 import 'zlib';
 import 'buffer';
 import 'https';
 import 'tls';
+import 'querystring';
 import 'node:zlib';
 
 // This file will be built for both ESM and CJS. Avoid relying on other modules as possible.
@@ -165,6 +165,40 @@ function splitVendorChunkPlugin() {
     };
 }
 
+class RemoteEnvironmentTransport {
+    options;
+    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 {
     hmrChannel;
     constructor(hmrChannel) {
@@ -226,6 +260,12 @@ function createHMROptions(server, options) {
     if (server.config.server.hmr === false || options.hmr === false) {
         return false;
     }
+    if (options.hmr?.connection) {
+        return {
+            connection: options.hmr.connection,
+            logger: options.hmr.logger,
+        };
+    }
     const connection = new ServerHMRConnector(server);
     return {
         connection,
@@ -258,15 +298,17 @@ function resolveSourceMapOptions(options) {
  * Create an instance of the Vite SSR runtime that support HMR.
  * @experimental
  */
-async function createViteRuntime(server, options = {}) {
-    const hmr = createHMROptions(server, options);
-    return new ViteRuntime({
+function createServerModuleRunner(environment, options = {}) {
+    const hmr = createHMROptions(environment.server, options);
+    return new ModuleRunner({
         ...options,
-        root: server.config.root,
-        fetchModule: server.ssrFetchModule,
+        root: environment.config.root,
+        transport: {
+            fetchModule: (id, importer) => environment.fetchModule(id, importer),
+        },
         hmr,
         sourcemapInterceptor: resolveSourceMapOptions(options),
-    }, options.runner || new ESModulesRunner());
+    }, options.runner || new ESModulesEvaluator());
 }
 
-export { ServerHMRConnector, createViteRuntime, isCSSRequest, splitVendorChunk, splitVendorChunkPlugin };
+export { RemoteEnvironmentTransport, ServerHMRConnector, createServerModuleRunner, isCSSRequest, splitVendorChunk, splitVendorChunkPlugin };

package/dist/node/{types.d-aGj9QkWt.d.ts → module-runner.d.ts}

@@ -2,6 +2,30 @@ import { ModuleNamespace, ViteHotContext } from '../../types/hot.js';
 import { Update, HMRPayload } from '../../types/hmrPayload.js';
 import { InferCustomEventPayload } from '../../types/customEvent.js';
 
+interface SourceMapLike {
+    version: number;
+    mappings?: string;
+    names?: string[];
+    sources?: string[];
+    sourcesContent?: string[];
+}
+declare class DecodedMap {
+    map: SourceMapLike;
+    _encoded: string;
+    _decoded: undefined | number[][][];
+    _decodedMemo: Stats;
+    url: string;
+    version: number;
+    names: string[];
+    resolvedSources: string[];
+    constructor(map: SourceMapLike, from: string);
+}
+interface Stats {
+    lastKey: number;
+    lastNeedle: number;
+    lastIndex: number;
+}
+
 type CustomListenersMap = Map<string, ((data: any) => void)[]>;
 interface HotModule {
     id: string;
@@ -74,66 +98,57 @@ interface SSRImportBaseMetadata extends DefineImportMetadata {
     isDynamicImport?: boolean;
 }
 
-interface SourceMapLike {
-    version: number;
-    mappings?: string;
-    names?: string[];
-    sources?: string[];
-    sourcesContent?: string[];
-}
-declare class DecodedMap {
-    map: SourceMapLike;
-    _encoded: string;
-    _decoded: undefined | number[][][];
-    _decodedMemo: Stats;
-    url: string;
-    version: number;
-    names: string[];
-    resolvedSources: string[];
-    constructor(map: SourceMapLike, from: string);
-}
-interface Stats {
-    lastKey: number;
-    lastNeedle: number;
-    lastIndex: number;
-}
+declare const ssrModuleExportsKey = "__vite_ssr_exports__";
+declare const ssrImportKey = "__vite_ssr_import__";
+declare const ssrDynamicImportKey = "__vite_ssr_dynamic_import__";
+declare const ssrExportAllKey = "__vite_ssr_exportAll__";
+declare const ssrImportMetaKey = "__vite_ssr_import_meta__";
 
-declare class ModuleCacheMap extends Map<string, ModuleCache> {
-    private root;
-    constructor(root: string, entries?: [string, ModuleCache][]);
-    normalize(fsPath: string): string;
+interface ModuleRunnerDebugger {
+    (formatter: unknown, ...args: unknown[]): void;
+}
+declare class ModuleRunner {
+    options: ModuleRunnerOptions;
+    evaluator: ModuleEvaluator;
+    private debug?;
     /**
-     * Assign partial data to the map
+     * Holds the cache of modules
+     * Keys of the map are ids
      */
-    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;
-    invalidate(id: string): void;
-    isImported({ importedId, importedBy, }: {
-        importedId: string;
-        importedBy: string;
-    }, seen?: Set<string>): boolean;
+    moduleCache: ModuleCacheMap;
+    hmrClient?: HMRClient;
+    private idToUrlMap;
+    private fileToIdMap;
+    private envProxy;
+    private transport;
+    private _destroyed;
+    private _resetSourceMapSupport?;
+    constructor(options: ModuleRunnerOptions, evaluator: ModuleEvaluator, debug?: ModuleRunnerDebugger | undefined);
     /**
-     * Invalidate modules that dependent on the given modules, up to the main entry
+     * URL to execute. Accepts file path, server path or id relative to the root.
      */
-    invalidateDepTree(ids: string[] | Set<string>, invalidated?: Set<string>): Set<string>;
+    import<T = any>(url: string): Promise<T>;
     /**
-     * Invalidate dependency modules of the given modules, down to the bottom-level dependencies
+     * Clear all caches including HMR listeners.
      */
-    invalidateSubDepTree(ids: string[] | Set<string>, invalidated?: Set<string>): Set<string>;
-    getSourceMap(moduleId: string): null | DecodedMap;
+    clearCache(): void;
+    /**
+     * Clears all caches, removes all HMR listeners, and resets source map support.
+     * This method doesn't stop the HMR connection.
+     */
+    destroy(): Promise<void>;
+    /**
+     * Returns `true` if the runtime has been destroyed by calling `destroy()` method.
+     */
+    isDestroyed(): boolean;
+    private invalidateFiles;
+    private normalizeEntryUrl;
+    private processImport;
+    private cachedRequest;
+    private cachedModule;
+    protected directRequest(id: string, fetchResult: ResolvedResult, _callstack: string[]): Promise<any>;
 }
 
-declare const ssrModuleExportsKey = "__vite_ssr_exports__";
-declare const ssrImportKey = "__vite_ssr_import__";
-declare const ssrDynamicImportKey = "__vite_ssr_dynamic_import__";
-declare const ssrExportAllKey = "__vite_ssr_exportAll__";
-declare const ssrImportMetaKey = "__vite_ssr_import_meta__";
-
 interface RetrieveFileHandler {
     (path: string): string | null | undefined | false;
 }
@@ -148,37 +163,49 @@ interface InterceptorOptions {
     retrieveSourceMap?: RetrieveSourceMapHandler;
 }
 
-interface SSRImportMetadata extends SSRImportBaseMetadata {
-    entrypoint?: boolean;
+interface RunnerTransport {
+    fetchModule: FetchFunction;
 }
-interface HMRRuntimeConnection extends HMRConnection {
+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: HMRPayload) => void): void;
 }
-interface ViteRuntimeImportMeta extends ImportMeta {
+interface ModuleRunnerImportMeta extends ImportMeta {
     url: string;
     env: ImportMetaEnv;
     hot?: ViteHotContext;
     [key: string]: any;
 }
-interface ViteRuntimeModuleContext {
+interface ModuleRunnerContext {
     [ssrModuleExportsKey]: Record<string, any>;
     [ssrImportKey]: (id: string, metadata?: DefineImportMetadata) => Promise<any>;
     [ssrDynamicImportKey]: (id: string, options?: ImportCallOptions) => Promise<any>;
     [ssrExportAllKey]: (obj: any) => void;
-    [ssrImportMetaKey]: ViteRuntimeImportMeta;
+    [ssrImportMetaKey]: ModuleRunnerImportMeta;
 }
-interface ViteModuleRunner {
+interface ModuleEvaluator {
     /**
      * 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
      */
-    runViteModule(context: ViteRuntimeModuleContext, code: string, id: string): Promise<any>;
+    runInlinedModule(context: ModuleRunnerContext, code: string, id: string): Promise<any>;
     /**
      * Run externalized module.
      * @param file File URL to the external module
@@ -202,7 +229,7 @@ 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 runtime
+     * instead of being transformed by vite and loaded with vite runner
      */
     externalize: string;
     /**
@@ -213,7 +240,7 @@ interface ExternalFetchResult {
 }
 interface ViteFetchResult {
     /**
-     * Code that will be evaluated by vite runtime
+     * Code that will be evaluated by vite runner
      * by default this will be wrapped in an async function
      */
     code: string;
@@ -230,21 +257,25 @@ type ResolvedResult = (ExternalFetchResult | ViteFetchResult) & {
  * @experimental
  */
 type FetchFunction = (id: string, importer?: string) => Promise<FetchResult>;
-interface ViteRuntimeOptions {
+interface ModuleRunnerHmr {
     /**
-     * Root of the project
+     * Configure how HMR communicates between the client and the server.
      */
-    root: string;
+    connection: ModuleRunnerHMRConnection;
     /**
-     * A method to get the information about the module.
-     * For SSR, Vite exposes `server.ssrFetchModule` function that you can use here.
-     * For other runtime use cases, Vite also exposes `fetchModule` from its main entry point.
+     * Configure HMR logger.
      */
-    fetchModule: FetchFunction;
+    logger?: false | HMRLogger;
+}
+interface ModuleRunnerOptions {
+    /**
+     * Root of the project
+     */
+    root: string;
     /**
-     * Custom environment variables available on `import.meta.env`. This doesn't modify the actual `process.env`.
+     * A set of methods to communicate with the server.
      */
-    environmentVariables?: Record<string, any>;
+    transport: RunnerTransport;
     /**
      * 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.
@@ -254,18 +285,9 @@ interface ViteRuntimeOptions {
     /**
      * Disable HMR or configure HMR options.
      */
-    hmr?: false | {
-        /**
-         * Configure how HMR communicates between the client and the server.
-         */
-        connection: HMRRuntimeConnection;
-        /**
-         * Configure HMR logger.
-         */
-        logger?: false | HMRLogger;
-    };
+    hmr?: false | ModuleRunnerHmr;
     /**
-     * Custom module cache. If not provided, creates a separate module cache for each ViteRuntime instance.
+     * Custom module cache. If not provided, creates a separate module cache for each ModuleRunner instance.
      */
     moduleCache?: ModuleCacheMap;
 }
@@ -278,4 +300,35 @@ interface ImportMetaEnv {
     SSR: boolean;
 }
 
-export { type FetchResult as F, type HMRLogger as H, ModuleCacheMap as M, type ResolvedResult as R, type SSRImportMetadata as S, type ViteRuntimeOptions as V, type FetchFunction as a, type ViteModuleRunner as b, HMRClient as c, type ViteRuntimeModuleContext as d, type HMRConnection as e, type ModuleCache as f, type HMRRuntimeConnection as g, type ViteRuntimeImportMeta as h, ssrExportAllKey as i, ssrImportKey as j, ssrImportMetaKey as k, ssrModuleExportsKey as l, ssrDynamicImportKey as s };
+declare class ModuleCacheMap extends Map<string, ModuleCache> {
+    private root;
+    constructor(root: string, entries?: [string, ModuleCache][]);
+    normalize(fsPath: string): string;
+    /**
+     * Assign partial data to the map
+     */
+    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;
+    invalidate(id: string): void;
+    /**
+     * Invalidate modules that dependent on the given modules, up to the main entry
+     */
+    invalidateDepTree(ids: string[] | Set<string>, invalidated?: Set<string>): Set<string>;
+    /**
+     * Invalidate dependency modules of the given modules, down to the bottom-level dependencies
+     */
+    invalidateSubDepTree(ids: string[] | Set<string>, invalidated?: Set<string>): Set<string>;
+    getSourceMap(moduleId: string): null | DecodedMap;
+}
+
+declare class ESModulesEvaluator implements ModuleEvaluator {
+    runInlinedModule(context: ModuleRunnerContext, code: string): Promise<any>;
+    runExternalModule(filepath: string): Promise<any>;
+}
+
+export { ESModulesEvaluator, type FetchFunction, 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 SSRImportBaseMetadata as SSRImportMetadata, ssrDynamicImportKey, ssrExportAllKey, ssrImportKey, ssrImportMetaKey, ssrModuleExportsKey };