vite 6.0.0-alpha.2 → 6.0.0-alpha.21

package/dist/node/index.js

@@ -1,10 +1,9 @@
 export { parseAst, parseAstAsync } from 'rollup/parseAst';
-import { i as isInNodeModules, a as arraify } from './chunks/dep-E4cF1RpV.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-E4cF1RpV.js';
-import { existsSync, readFileSync } from 'node:fs';
-import { ModuleRunner, ESModulesEvaluator } from 'vite/module-runner';
+import { i as isInNodeModules, a as arraify } from './chunks/dep-D2vSWyBt.js';
+export { B as BuildEnvironment, D as DevEnvironment, S as ServerHMRConnector, 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 createServerModuleRunner, 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-D2vSWyBt.js';
 export { 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';
@@ -14,13 +13,15 @@ import 'node:module';
 import 'tty';
 import 'path';
 import 'fs';
-import 'events';
-import 'assert';
+import 'node:events';
+import 'node:stream';
+import 'node:string_decoder';
 import 'node:child_process';
 import 'node:http';
 import 'node:https';
 import 'util';
 import 'net';
+import 'events';
 import 'url';
 import 'http';
 import 'stream';
@@ -29,11 +30,11 @@ import 'child_process';
 import 'node:os';
 import 'node:crypto';
 import 'node:dns';
+import 'vite/module-runner';
+import 'module';
 import 'node:assert';
 import 'node:v8';
-import 'module';
 import 'node:worker_threads';
-import 'node:events';
 import 'crypto';
 import 'node:buffer';
 import 'node:readline';
@@ -41,274 +42,143 @@ import 'zlib';
 import 'buffer';
 import 'https';
 import 'tls';
+import 'assert';
 import 'querystring';
 import 'node:zlib';
 
-// This file will be built for both ESM and CJS. Avoid relying on other modules as possible.
-// copy from constants.ts
-const CSS_LANGS_RE = 
-// eslint-disable-next-line regexp/no-unused-capturing-group
-/\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
+const CSS_LANGS_RE = (
+  // eslint-disable-next-line regexp/no-unused-capturing-group
+  /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/
+);
 const isCSSRequest = (request) => CSS_LANGS_RE.test(request);
-// Use splitVendorChunkPlugin() to get the same manualChunks strategy as Vite 2.7
-// We don't recommend using this strategy as a general solution moving forward
-// splitVendorChunk is a simple index/vendor strategy that was used in Vite
-// until v2.8. It is exposed to let people continue to use it in case it was
-// working well for their setups.
-// The cache needs to be reset on buildStart for watch mode to work correctly
-// Don't use this manualChunks strategy for ssr, lib mode, and 'umd' or 'iife'
-/**
- * @deprecated use build.rollupOutput.manualChunks or framework specific configuration
- */
 class SplitVendorChunkCache {
-    cache;
-    constructor() {
-        this.cache = new Map();
-    }
-    reset() {
-        this.cache = new Map();
-    }
+  cache;
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  reset() {
+    this.cache = /* @__PURE__ */ new Map();
+  }
 }
-/**
- * @deprecated use build.rollupOutput.manualChunks or framework specific configuration
- */
 function splitVendorChunk(options = {}) {
-    const cache = options.cache ?? new SplitVendorChunkCache();
-    return (id, { getModuleInfo }) => {
-        if (isInNodeModules(id) &&
-            !isCSSRequest(id) &&
-            staticImportedByEntry(id, getModuleInfo, cache.cache)) {
-            return 'vendor';
-        }
-    };
+  const cache = options.cache ?? new SplitVendorChunkCache();
+  return (id, { getModuleInfo }) => {
+    if (isInNodeModules(id) && !isCSSRequest(id) && staticImportedByEntry(id, getModuleInfo, cache.cache)) {
+      return "vendor";
+    }
+  };
 }
 function staticImportedByEntry(id, getModuleInfo, cache, importStack = []) {
-    if (cache.has(id)) {
-        return cache.get(id);
-    }
-    if (importStack.includes(id)) {
-        // circular deps!
-        cache.set(id, false);
-        return false;
-    }
-    const mod = getModuleInfo(id);
-    if (!mod) {
-        cache.set(id, false);
-        return false;
-    }
-    if (mod.isEntry) {
-        cache.set(id, true);
-        return true;
-    }
-    const someImporterIs = mod.importers.some((importer) => staticImportedByEntry(importer, getModuleInfo, cache, importStack.concat(id)));
-    cache.set(id, someImporterIs);
-    return someImporterIs;
+  if (cache.has(id)) {
+    return cache.get(id);
+  }
+  if (importStack.includes(id)) {
+    cache.set(id, false);
+    return false;
+  }
+  const mod = getModuleInfo(id);
+  if (!mod) {
+    cache.set(id, false);
+    return false;
+  }
+  if (mod.isEntry) {
+    cache.set(id, true);
+    return true;
+  }
+  const someImporterIs = mod.importers.some(
+    (importer) => staticImportedByEntry(
+      importer,
+      getModuleInfo,
+      cache,
+      importStack.concat(id)
+    )
+  );
+  cache.set(id, someImporterIs);
+  return someImporterIs;
 }
-/**
- * @deprecated use build.rollupOutput.manualChunks or framework specific configuration
- */
 function splitVendorChunkPlugin() {
-    const caches = [];
-    function createSplitVendorChunk(output, config) {
-        const cache = new SplitVendorChunkCache();
-        caches.push(cache);
-        const build = config.build ?? {};
-        const format = output?.format;
-        if (!build.ssr && !build.lib && format !== 'umd' && format !== 'iife') {
-            return splitVendorChunk({ cache });
-        }
-    }
-    return {
-        name: 'vite:split-vendor-chunk',
-        config(config) {
-            let outputs = config?.build?.rollupOptions?.output;
-            if (outputs) {
-                outputs = arraify(outputs);
-                for (const output of outputs) {
-                    const viteManualChunks = createSplitVendorChunk(output, config);
-                    if (viteManualChunks) {
-                        if (output.manualChunks) {
-                            if (typeof output.manualChunks === 'function') {
-                                const userManualChunks = output.manualChunks;
-                                output.manualChunks = (id, api) => {
-                                    return userManualChunks(id, api) ?? viteManualChunks(id, api);
-                                };
-                            }
-                            else {
-                                // else, leave the object form of manualChunks untouched, as
-                                // we can't safely replicate rollup handling.
-                                // eslint-disable-next-line no-console
-                                console.warn("(!) the `splitVendorChunk` plugin doesn't have any effect when using the object form of `build.rollupOptions.output.manualChunks`. Consider using the function form instead.");
-                            }
-                        }
-                        else {
-                            output.manualChunks = viteManualChunks;
-                        }
-                    }
-                }
-            }
-            else {
-                return {
-                    build: {
-                        rollupOptions: {
-                            output: {
-                                manualChunks: createSplitVendorChunk({}, config),
-                            },
-                        },
-                    },
+  const caches = [];
+  function createSplitVendorChunk(output, config) {
+    const cache = new SplitVendorChunkCache();
+    caches.push(cache);
+    const build = config.build ?? {};
+    const format = output?.format;
+    if (!build.ssr && !build.lib && format !== "umd" && format !== "iife") {
+      return splitVendorChunk({ cache });
+    }
+  }
+  return {
+    name: "vite:split-vendor-chunk",
+    config(config) {
+      let outputs = config?.build?.rollupOptions?.output;
+      if (outputs) {
+        outputs = arraify(outputs);
+        for (const output of outputs) {
+          const viteManualChunks = createSplitVendorChunk(output, config);
+          if (viteManualChunks) {
+            if (output.manualChunks) {
+              if (typeof output.manualChunks === "function") {
+                const userManualChunks = output.manualChunks;
+                output.manualChunks = (id, api) => {
+                  return userManualChunks(id, api) ?? viteManualChunks(id, api);
                 };
+              } else {
+                console.warn(
+                  "(!) the `splitVendorChunk` plugin doesn't have any effect when using the object form of `build.rollupOptions.output.manualChunks`. Consider using the function form instead."
+                );
+              }
+            } else {
+              output.manualChunks = viteManualChunks;
             }
-        },
-        buildStart() {
-            caches.forEach((cache) => cache.reset());
-        },
-    };
-}
-
-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) {
-        this.hmrChannel = hmrChannel;
-    }
-    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.hmrChannel.send(payload);
-    }
-}
-/**
- * The connector class to establish HMR communication between the server and the Vite runtime.
- * @experimental
- */
-class ServerHMRConnector {
-    handlers = [];
-    hmrChannel;
-    hmrClient;
-    connected = false;
-    constructor(server) {
-        const hmrChannel = server.hot?.channels.find((c) => c.name === 'ssr');
-        if (!hmrChannel) {
-            throw new Error("Your version of Vite doesn't support HMR during SSR. Please, use Vite 5.1 or higher.");
+          }
         }
-        this.hmrClient = new ServerHMRBroadcasterClient(hmrChannel);
-        hmrChannel.api.outsideEmitter.on('send', (payload) => {
-            this.handlers.forEach((listener) => listener(payload));
-        });
-        this.hmrChannel = hmrChannel;
-    }
-    isReady() {
-        return this.connected;
-    }
-    send(message) {
-        const payload = JSON.parse(message);
-        this.hmrChannel.api.innerEmitter.emit(payload.event, payload.data, this.hmrClient);
-    }
-    onUpdate(handler) {
-        this.handlers.push(handler);
-        handler({ type: 'connected' });
-        this.connected = true;
-    }
-}
-
-function createHMROptions(server, options) {
-    if (server.config.server.hmr === false || options.hmr === false) {
-        return false;
-    }
-    if (options.hmr?.connection) {
+      } else {
         return {
-            connection: options.hmr.connection,
-            logger: options.hmr.logger,
+          build: {
+            rollupOptions: {
+              output: {
+                manualChunks: createSplitVendorChunk({}, config)
+              }
+            }
+          }
         };
-    }
-    const connection = new ServerHMRConnector(server);
-    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';
+    buildStart() {
+      caches.forEach((cache) => cache.reset());
     }
-    return prepareStackTrace;
+  };
 }
-/**
- * Create an instance of the Vite SSR runtime that support HMR.
- * @experimental
- */
-function createServerModuleRunner(environment, options = {}) {
-    const hmr = createHMROptions(environment.server, options);
-    return new ModuleRunner({
-        ...options,
-        root: environment.config.root,
-        transport: {
-            fetchModule: (id, importer) => environment.fetchModule(id, importer),
-        },
-        hmr,
-        sourcemapInterceptor: resolveSourceMapOptions(options),
-    }, options.runner || new ESModulesEvaluator());
+
+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, ServerHMRConnector, createServerModuleRunner, isCSSRequest, splitVendorChunk, splitVendorChunkPlugin };
+export { RemoteEnvironmentTransport, isCSSRequest, splitVendorChunk, splitVendorChunkPlugin };

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

@@ -1,5 +1,5 @@
 import { ModuleNamespace, ViteHotContext } from '../../types/hot.js';
-import { Update, HMRPayload } from '../../types/hmrPayload.js';
+import { Update, HotPayload } from '../../types/hmrPayload.js';
 import { InferCustomEventPayload } from '../../types/customEvent.js';
 
 interface SourceMapLike {
@@ -117,12 +117,13 @@ declare class ModuleRunner {
      */
     moduleCache: ModuleCacheMap;
     hmrClient?: HMRClient;
-    private idToUrlMap;
-    private fileToIdMap;
-    private envProxy;
-    private transport;
-    private _destroyed;
-    private _resetSourceMapSupport?;
+    private readonly urlToIdMap;
+    private readonly fileToIdMap;
+    private readonly envProxy;
+    private readonly transport;
+    private readonly resetSourceMapSupport?;
+    private readonly root;
+    private destroyed;
     constructor(options: ModuleRunnerOptions, evaluator: ModuleEvaluator, debug?: ModuleRunnerDebugger | undefined);
     /**
      * URL to execute. Accepts file path, server path or id relative to the root.
@@ -141,12 +142,13 @@ declare class ModuleRunner {
      * Returns `true` if the runtime has been destroyed by calling `destroy()` method.
      */
     isDestroyed(): boolean;
-    private invalidateFiles;
     private normalizeEntryUrl;
     private processImport;
+    private isCircularModule;
+    private isCircularImport;
     private cachedRequest;
     private cachedModule;
-    protected directRequest(id: string, fetchResult: ResolvedResult, _callstack: string[]): Promise<any>;
+    protected directRequest(id: string, mod: ModuleCache, _callstack: string[]): Promise<any>;
 }
 
 interface RetrieveFileHandler {
@@ -183,7 +185,7 @@ 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;
+    onUpdate(callback: (payload: HotPayload) => void): void;
 }
 interface ModuleRunnerImportMeta extends ImportMeta {
     url: string;
@@ -217,14 +219,21 @@ interface ModuleCache {
     exports?: any;
     evaluated?: boolean;
     map?: DecodedMap;
-    meta?: FetchResult;
+    meta?: ResolvedResult;
     /**
      * Module ids that imports this module
      */
     importers?: Set<string>;
     imports?: Set<string>;
 }
-type FetchResult = ExternalFetchResult | ViteFetchResult;
+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://,
@@ -247,16 +256,21 @@ interface ViteFetchResult {
     /**
      * 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;
+    /**
+     * Invalidate module on the client side.
+     */
+    invalidate: boolean;
 }
 type ResolvedResult = (ExternalFetchResult | ViteFetchResult) & {
     id: string;
 };
-/**
- * @experimental
- */
-type FetchFunction = (id: string, importer?: string) => Promise<FetchResult>;
+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.
@@ -314,7 +328,8 @@ declare class ModuleCacheMap extends Map<string, ModuleCache> {
     get(fsPath: string): ModuleCache;
     deleteByModuleId(modulePath: string): boolean;
     delete(fsPath: string): boolean;
-    invalidate(id: string): void;
+    invalidateUrl(id: string): void;
+    invalidateModule(module: ModuleCache): void;
     /**
      * Invalidate modules that dependent on the given modules, up to the main entry
      */
@@ -331,4 +346,4 @@ declare class ESModulesEvaluator implements ModuleEvaluator {
     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 };
+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 SSRImportBaseMetadata as SSRImportMetadata, ssrDynamicImportKey, ssrExportAllKey, ssrImportKey, ssrImportMetaKey, ssrModuleExportsKey };