vite 6.0.0-alpha.8 → 6.0.0-beta.0

package/dist/node/index.js

@@ -1,26 +1,28 @@
 export { parseAst, parseAstAsync } from 'rollup/parseAst';
-import { i as isInNodeModules, a as arraify } from './chunks/dep-8PNdpITG.js';
-export { B as BuildEnvironment, D as DevEnvironment, S as ServerHMRConnector, b as build, h as buildErrorMessage, e as createBuilder, u as createFilter, j as createNodeDevEnvironment, c as createServer, m as createServerModuleRunner, d as defineConfig, k as fetchModule, f as formatPostcssSourceMap, y as isFileServingAllowed, l as loadConfigFromFile, z as loadEnv, q as mergeAlias, o as mergeConfig, n as normalizePath, g as preprocessCSS, p as preview, r as resolveConfig, A as resolveEnvPrefix, v as rollupVersion, x as searchForWorkspaceRoot, w as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-8PNdpITG.js';
+import { i as isInNodeModules, a as arraify } from './chunks/dep-Bv1xMYNy.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-Bv1xMYNy.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';
-export { c as createLogger } from './chunks/dep-C7zR1Rh8.js';
-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 'events';
-import 'assert';
+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';
 import 'url';
 import 'http';
 import 'stream';
@@ -29,175 +31,262 @@ 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 'node:worker_threads';
-import 'node:events';
 import 'crypto';
-import 'querystring';
 import 'node:buffer';
 import 'node:readline';
 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 });
-        }
+  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),
-                            },
-                        },
-                    },
+  }
+  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());
-        },
-    };
+          }
+        }
+      } else {
+        return {
+          build: {
+            rollupOptions: {
+              output: {
+                manualChunks: createSplitVendorChunk({}, config)
+              }
+            }
+          }
+        };
+      }
+    },
+    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,
-                });
-            }
+  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, isCSSRequest, splitVendorChunk, splitVendorChunkPlugin };
+export { RemoteEnvironmentTransport, ServerHMRConnector, createServerModuleRunner, 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 {
@@ -94,7 +94,7 @@ interface DefineImportMetadata {
      */
     importedNames?: string[];
 }
-interface SSRImportBaseMetadata extends DefineImportMetadata {
+interface SSRImportMetadata extends DefineImportMetadata {
     isDynamicImport?: boolean;
 }
 
@@ -122,6 +122,8 @@ declare class ModuleRunner {
     private readonly envProxy;
     private readonly transport;
     private readonly resetSourceMapSupport?;
+    private readonly root;
+    private readonly moduleInfoCache;
     private destroyed;
     constructor(options: ModuleRunnerOptions, evaluator: ModuleEvaluator, debug?: ModuleRunnerDebugger | undefined);
     /**
@@ -141,10 +143,12 @@ declare class ModuleRunner {
      * Returns `true` if the runtime has been destroyed by calling `destroy()` method.
      */
     isDestroyed(): boolean;
-    private normalizeEntryUrl;
     private processImport;
+    private isCircularModule;
+    private isCircularImport;
     private cachedRequest;
     private cachedModule;
+    private getModuleInformation;
     protected directRequest(id: string, mod: ModuleCache, _callstack: string[]): Promise<any>;
 }
 
@@ -182,7 +186,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 +221,20 @@ interface ModuleCache {
     evaluated?: boolean;
     map?: DecodedMap;
     meta?: ResolvedResult;
-    timestamp?: number;
     /**
      * 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 +257,25 @@ 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;
+    /**
+     * Module ID in the server module graph.
+     */
+    serverId: string;
+    /**
+     * Invalidate module on the client side.
+     */
+    invalidate: boolean;
 }
 type ResolvedResult = (ExternalFetchResult | ViteFetchResult) & {
-    id: string;
+    url: 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.
@@ -332,4 +351,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 SSRImportMetadata, ssrDynamicImportKey, ssrExportAllKey, ssrImportKey, ssrImportMetaKey, ssrModuleExportsKey };