vite 6.0.0-alpha.17 → 6.0.0-alpha.19

package/dist/node/index.js

@@ -1,6 +1,6 @@
 export { parseAst, parseAstAsync } from 'rollup/parseAst';
-import { i as isInNodeModules, a as arraify } from './chunks/dep-DVlS5vGL.js';
-export { B as BuildEnvironment, D as DevEnvironment, S as ServerHMRConnector, b as build, h as buildErrorMessage, e as createBuilder, w as createFilter, A as createLogger, j as createNodeDevEnvironment, c as createServer, m as createServerModuleRunner, x as createWeakData, d as defineConfig, k as fetchModule, f as formatPostcssSourceMap, F as isFileLoadingAllowed, E as isFileServingAllowed, l as loadConfigFromFile, G as loadEnv, v as mergeAlias, u as mergeConfig, n as moduleRunnerTransform, q as normalizePath, o as optimizeDeps, g 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-DVlS5vGL.js';
+import { i as isInNodeModules, a as arraify } from './chunks/dep-BWEMV5Th.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-BWEMV5Th.js';
 export { VERSION as version } from './constants.js';
 export { version as esbuildVersion } from 'esbuild';
 import 'node:fs';
@@ -13,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';
@@ -33,7 +35,6 @@ import 'module';
 import 'node:assert';
 import 'node:v8';
 import 'node:worker_threads';
-import 'node:events';
 import 'crypto';
 import 'querystring';
 import 'node:buffer';
@@ -42,161 +43,142 @@ import 'zlib';
 import 'buffer';
 import 'https';
 import 'tls';
+import 'assert';
 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.rollupOptions.output.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.rollupOptions.output.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.rollupOptions.output.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;
+            }
+          }
+        }
+      } else {
+        return {
+          build: {
+            rollupOptions: {
+              output: {
+                manualChunks: createSplitVendorChunk({}, config)
+              }
             }
-        },
-        buildStart() {
-            caches.forEach((cache) => cache.reset());
-        },
-    };
+          }
+        };
+      }
+    },
+    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
+        });
+      }
+    });
+  }
 }
 
 export { RemoteEnvironmentTransport, isCSSRequest, splitVendorChunk, splitVendorChunkPlugin };

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

@@ -122,6 +122,7 @@ declare class ModuleRunner {
     private readonly envProxy;
     private readonly transport;
     private readonly resetSourceMapSupport?;
+    private readonly root;
     private destroyed;
     constructor(options: ModuleRunnerOptions, evaluator: ModuleEvaluator, debug?: ModuleRunnerDebugger | undefined);
     /**
@@ -143,6 +144,8 @@ declare class ModuleRunner {
     isDestroyed(): boolean;
     private normalizeEntryUrl;
     private processImport;
+    private isCircularModule;
+    private isCircularImport;
     private cachedRequest;
     private cachedModule;
     protected directRequest(id: string, mod: ModuleCache, _callstack: string[]): Promise<any>;
@@ -217,14 +220,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 +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.
@@ -332,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 };