vite 6.0.0-alpha.2 → 6.0.0-alpha.4

package/dist/node/index.d.ts

@@ -632,6 +632,7 @@ interface Logger {
 interface LogOptions {
     clear?: boolean;
     timestamp?: boolean;
+    environment?: string;
 }
 interface LogErrorOptions extends LogOptions {
     error?: Error | RollupError | null;
@@ -787,6 +788,29 @@ type CLIShortcut<Server = ViteDevServer | PreviewServer> = {
  * https://github.com/preactjs/wmr/blob/main/packages/wmr/src/lib/rollup-plugin-container.js
  */
 
+interface BoundedPluginContainer {
+    options: InputOptions;
+    buildStart(options: InputOptions): Promise<void>;
+    resolveId(id: string, importer: string | undefined, options?: {
+        attributes?: Record<string, string>;
+        custom?: CustomPluginOptions;
+        skip?: Set<Plugin>;
+        isEntry?: boolean;
+    }): Promise<PartialResolvedId | null>;
+    transform(code: string, id: string, options?: {
+        inMap?: SourceDescription['map'];
+    }): Promise<{
+        code: string;
+        map: SourceMap | {
+            mappings: '';
+        } | null;
+    }>;
+    load(id: string, options?: {}): Promise<LoadResult | null>;
+    watchChange(id: string, change: {
+        event: 'create' | 'update' | 'delete';
+    }): Promise<void>;
+    close(): Promise<void>;
+}
 interface PluginContainer {
     options: InputOptions;
     buildStart(options: InputOptions): Promise<void>;
@@ -1353,9 +1377,11 @@ declare namespace WebSocket {
 }
 
 declare class Environment {
+    #private;
     name: string;
     config: ResolvedConfig;
     options: ResolvedEnvironmentOptions;
+    get plugins(): BoundedPlugin[];
     get logger(): Logger;
     constructor(name: string, config: ResolvedConfig, options?: ResolvedEnvironmentOptions);
 }
@@ -1370,8 +1396,14 @@ interface FetchModuleOptions {
  */
 declare function fetchModule(environment: DevEnvironment, url: string, importer?: string, options?: FetchModuleOptions): Promise<FetchResult>;
 
+declare class ScanEnvironment extends Environment {
+    mode: "scan";
+    get pluginContainer(): BoundedPluginContainer;
+    init(): Promise<void>;
+}
+
 type ExportsData = {
-    hasImports: boolean;
+    hasModuleSyntax: boolean;
     exports: readonly string[];
     jsxLoader?: boolean;
 };
@@ -1531,11 +1563,6 @@ interface DepOptimizationMetadata {
      */
     depInfoList: OptimizedDepInfo[];
 }
-/**
- * Scan and optimize dependencies within a project.
- * Used by Vite CLI when running `vite optimize`.
- */
-declare function optimizeDeps(environment: Environment, force?: boolean | undefined, asCommand?: boolean): Promise<DepOptimizationMetadata>;
 
 declare class RemoteEnvironmentTransport {
     private readonly options;
@@ -1548,16 +1575,19 @@ declare class RemoteEnvironmentTransport {
 
 interface DevEnvironmentSetup {
     hot?: false | HMRChannel;
+    watcher?: FSWatcher;
     options?: EnvironmentOptions;
     runner?: FetchModuleOptions & {
         transport?: RemoteEnvironmentTransport;
     };
+    depsOptimizer?: DepsOptimizer;
 }
 declare class DevEnvironment extends Environment {
     mode: "dev";
     moduleGraph: EnvironmentModuleGraph;
-    server: ViteDevServer;
+    watcher?: FSWatcher;
     depsOptimizer?: DepsOptimizer;
+    get pluginContainer(): BoundedPluginContainer;
     /**
      * HMR channel for this environment. If not provided or disabled,
      * it will be a noop channel that does nothing.
@@ -1566,18 +1596,21 @@ declare class DevEnvironment extends Environment {
      * environment.hot.send({ type: 'full-reload' })
      */
     hot: HMRChannel;
-    constructor(server: ViteDevServer, name: string, setup?: {
-        hot?: false | HMRChannel;
-        options?: EnvironmentOptions;
-        runner?: FetchModuleOptions & {
-            transport?: RemoteEnvironmentTransport;
-        };
-        depsOptimizer?: DepsOptimizer;
-    });
+    constructor(name: string, config: ResolvedConfig, setup?: DevEnvironmentSetup);
+    init(): Promise<void>;
     fetchModule(id: string, importer?: string): Promise<FetchResult>;
     transformRequest(url: string): Promise<TransformResult | null>;
     warmupRequest(url: string): Promise<void>;
     close(): Promise<void>;
+    /**
+     * Calling `await environment.waitForRequestsIdle(id)` will wait until all static imports
+     * are processed after the first transformRequest call. If called from a load or transform
+     * plugin hook, the id needs to be passed as a parameter to avoid deadlocks.
+     * Calling this function after the first static imports section of the module graph has been
+     * processed will resolve immediately.
+     * @experimental
+     */
+    waitForRequestsIdle(ignoredId?: string): Promise<void>;
 }
 
 interface TransformResult {
@@ -1585,6 +1618,7 @@ interface TransformResult {
     map: SourceMap | {
         mappings: '';
     } | null;
+    ssr?: boolean;
     etag?: string;
     deps?: string[];
     dynamicDeps?: string[];
@@ -2023,11 +2057,12 @@ interface ViteDevServer {
      *
      * Always sends a message to at least a WebSocket client. Any third party can
      * add a channel to the broadcaster to process messages
-     * @deprecated use `environments.get(id).hot` instead
+     * @deprecated use `environment.hot` instead
      */
     hot: HMRBroadcaster;
     /**
      * Rollup plugin container that can run plugin hooks on a given file
+     * @deprecated use `environment.pluginContainer` instead
      */
     pluginContainer: PluginContainer;
     /**
@@ -2037,7 +2072,7 @@ interface ViteDevServer {
     /**
      * Module graph that tracks the import relationships, url to file mapping
      * and hmr state.
-     * @deprecated use environment module graphs instead
+     * @deprecated use `environment.moduleGraph` instead
      */
     moduleGraph: ModuleGraph;
     /**
@@ -2064,6 +2099,7 @@ interface ViteDevServer {
     transformIndexHtml(url: string, html: string, originalUrl?: string): Promise<string>;
     /**
      * Transform module code into SSR format.
+     * TODO: expose this to any environment?
      */
     ssrTransform(code: string, inMap: SourceMap | {
         mappings: '';
@@ -2124,6 +2160,7 @@ interface ViteDevServer {
      * passed as a parameter to avoid deadlocks. Calling this function after the first
      * static imports section of the module graph has been processed will resolve immediately.
      * @experimental
+     * @deprecated use environment.waitForRequestsIdle()
      */
     waitForRequestsIdle: (ignoredId?: string) => Promise<void>;
 }
@@ -2815,7 +2852,7 @@ interface BuildEnvironmentOptions {
     /**
      * create the Build Environment instance
      */
-    createEnvironment?: (builder: ViteBuilder, name: string) => Promise<BuildEnvironment> | BuildEnvironment;
+    createEnvironment?: (name: string, config: ResolvedConfig) => Promise<BuildEnvironment> | BuildEnvironment;
 }
 interface BuildOptions extends BuildEnvironmentOptions {
     /**
@@ -2892,25 +2929,24 @@ type RenderBuiltAssetUrl = (filename: string, type: {
 } | undefined;
 declare class BuildEnvironment extends Environment {
     mode: "build";
-    builder: ViteBuilder;
-    constructor(builder: ViteBuilder, name: string, setup?: {
+    constructor(name: string, config: ResolvedConfig, setup?: {
         options?: EnvironmentOptions;
     });
 }
 interface ViteBuilder {
     environments: Record<string, BuildEnvironment>;
     config: ResolvedConfig;
-    buildEnvironments(): Promise<void>;
+    buildApp(): Promise<void>;
     build(environment: BuildEnvironment): Promise<RollupOutput | RollupOutput[] | RollupWatcher>;
 }
 interface BuilderOptions {
-    buildEnvironments?: (builder: ViteBuilder, build: (environment: BuildEnvironment) => Promise<void>) => Promise<void>;
+    sharedConfigBuild?: boolean;
+    sharedPlugins?: boolean;
+    entireApp?: boolean;
+    buildApp?: (builder: ViteBuilder) => Promise<void>;
 }
 type ResolvedBuilderOptions = Required<BuilderOptions>;
-interface BuilderInlineConfig extends Omit<InlineConfig, 'plugins'> {
-    plugins?: () => PluginOption[];
-}
-declare function createViteBuilder(builderOptions?: BuilderOptions, defaultBuilderInlineConfig?: BuilderInlineConfig): Promise<ViteBuilder>;
+declare function createBuilder(inlineConfig?: InlineConfig): Promise<ViteBuilder>;
 
 interface ESBuildOptions extends esbuild_TransformOptions {
     include?: string | RegExp | string[] | RegExp[];
@@ -3195,14 +3231,86 @@ type IndexHtmlTransform = IndexHtmlTransformHook | {
  * or a build environment. Plugins can use this.environment.mode === 'dev' to
  * check if they have access to dev specific APIs.
  */
-type PluginEnvironment = DevEnvironment | BuildEnvironment;
+type PluginEnvironment = DevEnvironment | BuildEnvironment | ScanEnvironment;
 interface PluginContext extends rollup.PluginContext {
     environment?: PluginEnvironment;
 }
+interface ResolveIdPluginContext extends rollup.PluginContext {
+    environment?: PluginEnvironment;
+}
 interface TransformPluginContext extends rollup.TransformPluginContext {
     environment?: PluginEnvironment;
 }
-interface Plugin<A = any> extends rollup.Plugin<A> {
+/**
+ * There are two types of plugins in Vite. App plugins and environment plugins.
+ * Environment Plugins are defined by a constructor function that will be called
+ * once per each environment allowing users to have completely different plugins
+ * for each of them. The constructor gets the resolved environment after the server
+ * and builder has already been created simplifying config access and cache
+ * managementfor for environment specific plugins.
+ * Environment Plugins are closer to regular rollup plugins. They can't define
+ * app level hooks (like config, configResolved, configureServer, etc).
+ */
+interface BasePlugin<A = any> extends rollup.Plugin<A> {
+    /**
+     * Perform custom handling of HMR updates.
+     * The handler receives a context containing changed filename, timestamp, a
+     * list of modules affected by the file change, and the dev server instance.
+     *
+     * - The hook can return a filtered list of modules to narrow down the update.
+     *   e.g. for a Vue SFC, we can narrow down the part to update by comparing
+     *   the descriptors.
+     *
+     * - The hook can also return an empty array and then perform custom updates
+     *   by sending a custom hmr payload via server.hot.send().
+     *
+     * - If the hook doesn't return a value, the hmr update will be performed as
+     *   normal.
+     */
+    hotUpdate?: ObjectHook<(this: void, ctx: HotUpdateContext) => Array<EnvironmentModuleNode> | void | Promise<Array<EnvironmentModuleNode> | void>>;
+    /**
+     * extend hooks with ssr flag
+     */
+    resolveId?: ObjectHook<(this: ResolveIdPluginContext, source: string, importer: string | undefined, options: {
+        attributes: Record<string, string>;
+        custom?: CustomPluginOptions;
+        /**
+         * @deprecated use this.environment
+         */
+        ssr?: boolean;
+        isEntry: boolean;
+    }) => Promise<ResolveIdResult> | ResolveIdResult>;
+    load?: ObjectHook<(this: PluginContext, id: string, options?: {
+        /**
+         * @deprecated use this.environment
+         */
+        ssr?: boolean;
+    }) => Promise<LoadResult> | LoadResult>;
+    transform?: ObjectHook<(this: TransformPluginContext, code: string, id: string, options?: {
+        /**
+         * @deprecated use this.environment
+         */
+        ssr?: boolean;
+    }) => Promise<rollup.TransformResult> | rollup.TransformResult>;
+}
+type BoundedPlugin<A = any> = BasePlugin<A>;
+interface Plugin<A = any> extends BasePlugin<A> {
+    /**
+     * Opt-in this plugin into the shared plugins pipeline.
+     * For backward-compatibility, plugins are re-recreated for each environment
+     * during `vite build --app`
+     * We have an opt-in per plugin, and a general `builder.sharedPlugins`
+     * In a future major, we'll flip the default to be shared by default
+     * @experimental
+     */
+    sharedDuringBuild?: boolean;
+    /**
+     * Spawn the plugin into multiple plugins based on the environment.
+     * This hook is called when the config has already been resolved, allowing to
+     * create per environment plugin pipelines or easily inject plugins for a
+     * only specific environments.
+     */
+    create?: (environment: PluginEnvironment) => BoundedPluginOption;
     /**
      * Enforce plugin invocation tier similar to webpack loaders. Hooks ordering
      * is still subject to the `order` property in the hook object.
@@ -3287,51 +3395,15 @@ interface Plugin<A = any> extends rollup.Plugin<A> {
      * with the mixed client and ssr moduleGraph. Use hotUpdate instead
      */
     handleHotUpdate?: ObjectHook<(this: void, ctx: HmrContext) => Array<ModuleNode> | void | Promise<Array<ModuleNode> | void>>;
-    /**
-     * Perform custom handling of HMR updates.
-     * The handler receives a context containing changed filename, timestamp, a
-     * list of modules affected by the file change, and the dev server instance.
-     *
-     * - The hook can return a filtered list of modules to narrow down the update.
-     *   e.g. for a Vue SFC, we can narrow down the part to update by comparing
-     *   the descriptors.
-     *
-     * - The hook can also return an empty array and then perform custom updates
-     *   by sending a custom hmr payload via server.hot.send().
-     *
-     * - If the hook doesn't return a value, the hmr update will be performed as
-     *   normal.
-     */
-    hotUpdate?: ObjectHook<(this: void, ctx: HotUpdateContext) => Array<EnvironmentModuleNode> | void | Promise<Array<EnvironmentModuleNode> | void>>;
-    /**
-     * extend hooks with ssr flag
-     */
-    resolveId?: ObjectHook<(this: PluginContext, source: string, importer: string | undefined, options: {
-        attributes: Record<string, string>;
-        custom?: CustomPluginOptions;
-        /**
-         * @deprecated use this.environment
-         */
-        ssr?: boolean;
-        isEntry: boolean;
-    }) => Promise<ResolveIdResult> | ResolveIdResult>;
-    load?: ObjectHook<(this: PluginContext, id: string, options?: {
-        /**
-         * @deprecated use this.environment
-         */
-        ssr?: boolean;
-    }) => Promise<LoadResult> | LoadResult>;
-    transform?: ObjectHook<(this: TransformPluginContext, code: string, id: string, options?: {
-        /**
-         * @deprecated use this.environment
-         */
-        ssr?: boolean;
-    }) => Promise<rollup.TransformResult> | rollup.TransformResult>;
 }
 type HookHandler<T> = T extends ObjectHook<infer H> ? H : T;
 type PluginWithRequiredHook<K extends keyof Plugin> = Plugin & {
     [P in K]: NonNullable<Plugin[P]>;
 };
+type MaybeBoundedPlugin = BoundedPlugin | false | null | undefined;
+type BoundedPluginOption = MaybeBoundedPlugin | BoundedPluginOption[] | Promise<MaybeBoundedPlugin | BoundedPluginOption[]>;
+type MaybePlugin = Plugin | false | null | undefined;
+type PluginOption = MaybePlugin | PluginOption[] | Promise<MaybePlugin | PluginOption[]>;
 
 interface JsonOptions {
     /**
@@ -3443,17 +3515,14 @@ declare function defineConfig(config: UserConfig): UserConfig;
 declare function defineConfig(config: Promise<UserConfig>): Promise<UserConfig>;
 declare function defineConfig(config: UserConfigFnObject): UserConfigFnObject;
 declare function defineConfig(config: UserConfigExport): UserConfigExport;
-type PluginOption = Plugin | false | null | undefined | PluginOption[] | Promise<Plugin | false | null | undefined | PluginOption[]>;
 interface DevEnvironmentOptions {
     /**
-     * The files to be pre-transformed. Supports glob patterns.
+     * Files tßo be pre-transformed. Supports glob patterns.
      */
-    warmup?: {
-        files: string[];
-    };
+    warmup?: string[];
     /**
      * Pre-transform known direct imports
-     * @default true
+     * defaults to true for the client environment, false for the rest
      */
     preTransformRequests?: boolean;
     /**
@@ -3481,7 +3550,7 @@ interface DevEnvironmentOptions {
     /**
      * create the Dev Environment instance
      */
-    createEnvironment?: (server: ViteDevServer, name: string) => Promise<DevEnvironment> | DevEnvironment;
+    createEnvironment?: (name: string, config: ResolvedConfig) => Promise<DevEnvironment> | DevEnvironment;
     /**
      * For environments that support a full-reload, like the client, we can short-circuit when
      * restarting the server throwing early to stop processing current files. We avoided this for
@@ -3489,9 +3558,15 @@ interface DevEnvironmentOptions {
      * @experimental
      */
     recoverable?: boolean;
+    /**
+     * For environments associated with a module runner.
+     * By default it is true for the client environment and false for non-client environments.
+     * This option can also be used instead of the removed config.experimental.skipSsrTransform.
+     */
+    moduleRunnerTransform?: boolean;
 }
 type ResolvedDevEnvironmentOptions = Required<Omit<DevEnvironmentOptions, 'createEnvironment'>> & {
-    createEnvironment: ((server: ViteDevServer, name: string) => Promise<DevEnvironment> | DevEnvironment) | undefined;
+    createEnvironment: ((name: string, config: ResolvedConfig) => Promise<DevEnvironment> | DevEnvironment) | undefined;
 };
 type EnvironmentResolveOptions = ResolveOptions & {
     alias?: AliasOptions;
@@ -3507,6 +3582,13 @@ interface SharedEnvironmentOptions {
      */
     nodeCompatible?: boolean;
     webCompatible?: boolean;
+    /**
+     * Should Vite inject timestamp if module is invalidated
+     * Disabling this will break built-in HMR support
+     * @experimental
+     * @default true
+     */
+    injectInvalidationTimestamp?: boolean;
 }
 interface EnvironmentOptions extends SharedEnvironmentOptions {
     /**
@@ -3523,6 +3605,7 @@ type ResolvedEnvironmentOptions = {
     resolve: ResolvedEnvironmentResolveOptions;
     nodeCompatible: boolean;
     webCompatible: boolean;
+    injectInvalidationTimestamp: boolean;
     dev: ResolvedDevEnvironmentOptions;
     build: ResolvedBuildEnvironmentOptions;
 };
@@ -3788,7 +3871,7 @@ interface PluginHookUtils {
     getSortedPluginHooks: <K extends keyof Plugin>(hookName: K) => NonNullable<HookHandler<Plugin[K]>>[];
 }
 type ResolveFn = (id: string, importer?: string, aliasOnly?: boolean, ssr?: boolean) => Promise<string | undefined>;
-declare function resolveConfig(inlineConfig: InlineConfig, command: 'build' | 'serve', defaultMode?: string, defaultNodeEnv?: string, isPreview?: boolean): Promise<ResolvedConfig>;
+declare function resolveConfig(inlineConfig: InlineConfig, command: 'build' | 'serve', defaultMode?: string, defaultNodeEnv?: string, isPreview?: boolean, patchConfig?: ((config: ResolvedConfig) => void) | undefined): Promise<ResolvedConfig>;
 declare function sortUserPlugins(plugins: (Plugin | Plugin[])[] | undefined): [Plugin[], Plugin[], Plugin[]];
 declare function loadConfigFromFile(configEnv: ConfigEnv, configFile?: string, configRoot?: string, logLevel?: LogLevel, customLogger?: Logger): Promise<{
     path: string;
@@ -3798,7 +3881,7 @@ declare function loadConfigFromFile(configEnv: ConfigEnv, configFile?: string, c
 
 declare function buildErrorMessage(err: RollupError, args?: string[], includeStack?: boolean): string;
 
-declare function createNodeDevEnvironment(server: ViteDevServer, name: string, options?: DevEnvironmentSetup): DevEnvironment;
+declare function createNodeDevEnvironment(name: string, config: ResolvedConfig, options?: DevEnvironmentSetup): DevEnvironment;
 
 /**
  * @experimental
@@ -3812,9 +3895,9 @@ interface ServerModuleRunnerOptions extends Omit<ModuleRunnerOptions, 'root' | '
         logger?: ModuleRunnerHmr['logger'];
     };
     /**
-     * Provide a custom module runner. This controls how the code is executed.
+     * Provide a custom module evaluator. This controls how the code is executed.
      */
-    runner?: ModuleEvaluator;
+    evaluator?: ModuleEvaluator;
 }
 /**
  * Create an instance of the Vite SSR runtime that support HMR.
@@ -3827,11 +3910,11 @@ declare function createServerModuleRunner(environment: DevEnvironment, options?:
  * @experimental
  */
 declare class ServerHMRConnector implements ModuleRunnerHMRConnection {
-    private handlers;
     private hmrChannel;
+    private handlers;
     private hmrClient;
     private connected;
-    constructor(server: ViteDevServer);
+    constructor(hmrChannel: ServerHMRChannel);
     isReady(): boolean;
     send(message: string): void;
     onUpdate(handler: (payload: HMRPayload) => void): void;
@@ -3888,6 +3971,7 @@ declare function searchForWorkspaceRoot(current: string, root?: string): string;
 
 /**
  * Check if the url is allowed to be served, via the `server.fs` config.
+ * @deprecate use isFileLoadingAllowed
  */
 declare function isFileServingAllowed(url: string, server: ViteDevServer): boolean;
 
@@ -3907,4 +3991,4 @@ interface ManifestChunk {
     dynamicImports?: string[];
 }
 
-export { type Alias, type AliasOptions, type AnymatchFn, type AnymatchPattern, type AppType, type AwaitWriteFinishOptions, type BindCLIShortcutsOptions, BuildEnvironment, type BuildEnvironmentOptions, type BuildOptions, type CLIShortcut, type CSSModulesOptions, type CSSOptions, type CommonServerOptions, type ConfigEnv, Connect, type CorsOptions, type CorsOrigin, type DepOptimizationConfig, type DepOptimizationMetadata, type DepOptimizationOptions, DevEnvironment, type DevEnvironmentSetup, type ESBuildOptions, type ESBuildTransformResult, EnvironmentModuleGraph, EnvironmentModuleNode, type ExperimentalOptions, type ExportsData, FSWatcher, type FetchModuleOptions, type FileSystemServeOptions, type FilterPattern, type HMRBroadcaster, type HMRBroadcasterClient, type HMRChannel, type HTMLOptions, type HmrContext, type HmrOptions, type HookHandler, type HotUpdateContext, type HtmlTagDescriptor, HttpProxy, type IndexHtmlTransform, type IndexHtmlTransformContext, type IndexHtmlTransformHook, type IndexHtmlTransformResult, type InlineConfig, type InternalResolveOptions, type JsonOptions, type LegacyOptions, type LibraryFormats, type LibraryOptions, type LightningCSSOptions, type LogErrorOptions, type LogLevel, type LogOptions, type LogType, type Logger, type LoggerOptions, type Manifest, type ManifestChunk, type MapToFunction, type AnymatchMatcher as Matcher, ModuleGraph, ModuleNode, type ModulePreloadOptions, type OptimizedDepInfo, type Plugin, type PluginContainer, type PluginHookUtils, type PluginOption, type PreprocessCSSResult, type PreviewOptions, type PreviewServer, type PreviewServerHook, type ProxyOptions, RemoteEnvironmentTransport, type RenderBuiltAssetUrl, type ResolveFn, type ResolveModulePreloadDependenciesFn, type ResolveOptions, type ResolvedBuildEnvironmentOptions, type ResolvedBuildOptions, type ResolvedCSSOptions, type ResolvedConfig, type ResolvedModulePreloadOptions, type ResolvedPreviewOptions, type ResolvedSSROptions, type ResolvedServerOptions, type ResolvedServerUrls, type ResolvedUrl, type ResolvedWorkerOptions, type ResolverFunction, type ResolverObject, type RollupCommonJSOptions, type RollupDynamicImportVarsOptions, type SSROptions, type SSRTarget, type SendOptions, type ServerHMRChannel, ServerHMRConnector, type ServerHook, type ServerModuleRunnerOptions, type ServerOptions, SplitVendorChunkCache, type SsrDepOptimizationOptions, Terser, type TerserOptions, type TransformOptions, type TransformResult, type UserConfig, type UserConfigExport, type UserConfigFn, type UserConfigFnObject, type UserConfigFnPromise, type ViteDevServer, type WatchOptions, WebSocket, WebSocketAlias, type WebSocketClient, type WebSocketCustomListener, WebSocketServer, build, buildErrorMessage, createFilter, createLogger, createNodeDevEnvironment, createServer, createServerModuleRunner, createViteBuilder, defineConfig, fetchModule, formatPostcssSourceMap, isCSSRequest, isFileServingAllowed, loadConfigFromFile, loadEnv, mergeAlias, mergeConfig, normalizePath, optimizeDeps, preprocessCSS, preview, resolveConfig, resolveEnvPrefix, rollupVersion, searchForWorkspaceRoot, send, sortUserPlugins, splitVendorChunk, splitVendorChunkPlugin, transformWithEsbuild, VERSION as version };
+export { type Alias, type AliasOptions, type AnymatchFn, type AnymatchPattern, type AppType, type AwaitWriteFinishOptions, type BindCLIShortcutsOptions, BuildEnvironment, type BuildEnvironmentOptions, type BuildOptions, type BuilderOptions, type CLIShortcut, type CSSModulesOptions, type CSSOptions, type CommonServerOptions, type ConfigEnv, Connect, type CorsOptions, type CorsOrigin, type DepOptimizationConfig, type DepOptimizationMetadata, type DepOptimizationOptions, DevEnvironment, type DevEnvironmentOptions, type DevEnvironmentSetup, type ESBuildOptions, type ESBuildTransformResult, EnvironmentModuleGraph, EnvironmentModuleNode, type ExperimentalOptions, type ExportsData, FSWatcher, type FetchModuleOptions, type FileSystemServeOptions, type FilterPattern, type HMRBroadcaster, type HMRBroadcasterClient, type HMRChannel, type HTMLOptions, type HmrContext, type HmrOptions, type HookHandler, type HotUpdateContext, type HtmlTagDescriptor, HttpProxy, type IndexHtmlTransform, type IndexHtmlTransformContext, type IndexHtmlTransformHook, type IndexHtmlTransformResult, type InlineConfig, type InternalResolveOptions, type JsonOptions, type LegacyOptions, type LibraryFormats, type LibraryOptions, type LightningCSSOptions, type LogErrorOptions, type LogLevel, type LogOptions, type LogType, type Logger, type LoggerOptions, type Manifest, type ManifestChunk, type MapToFunction, type AnymatchMatcher as Matcher, ModuleGraph, ModuleNode, type ModulePreloadOptions, type OptimizedDepInfo, type Plugin, type PluginContainer, type PluginHookUtils, type PluginOption, type PreprocessCSSResult, type PreviewOptions, type PreviewServer, type PreviewServerHook, type ProxyOptions, RemoteEnvironmentTransport, type RenderBuiltAssetUrl, type ResolveFn, type ResolveModulePreloadDependenciesFn, type ResolveOptions, type ResolvedBuildEnvironmentOptions, type ResolvedBuildOptions, type ResolvedCSSOptions, type ResolvedConfig, type ResolvedDevEnvironmentOptions, type ResolvedModulePreloadOptions, type ResolvedPreviewOptions, type ResolvedSSROptions, type ResolvedServerOptions, type ResolvedServerUrls, type ResolvedUrl, type ResolvedWorkerOptions, type ResolverFunction, type ResolverObject, type RollupCommonJSOptions, type RollupDynamicImportVarsOptions, type SSROptions, type SSRTarget, type SendOptions, type ServerHMRChannel, ServerHMRConnector, type ServerHook, type ServerModuleRunnerOptions, type ServerOptions, SplitVendorChunkCache, type SsrDepOptimizationOptions, Terser, type TerserOptions, type TransformOptions, type TransformResult, type UserConfig, type UserConfigExport, type UserConfigFn, type UserConfigFnObject, type UserConfigFnPromise, type ViteBuilder, type ViteDevServer, type WatchOptions, WebSocket, WebSocketAlias, type WebSocketClient, type WebSocketCustomListener, WebSocketServer, build, buildErrorMessage, createBuilder, createFilter, createLogger, createNodeDevEnvironment, createServer, createServerModuleRunner, defineConfig, fetchModule, formatPostcssSourceMap, isCSSRequest, isFileServingAllowed, loadConfigFromFile, loadEnv, mergeAlias, mergeConfig, normalizePath, preprocessCSS, preview, resolveConfig, resolveEnvPrefix, rollupVersion, searchForWorkspaceRoot, send, sortUserPlugins, splitVendorChunk, splitVendorChunkPlugin, transformWithEsbuild, VERSION as version };

package/dist/node/index.js

@@ -1,17 +1,16 @@
 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-8UjKy9Ch.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-8UjKy9Ch.js';
 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';
@@ -19,6 +18,7 @@ import 'assert';
 import 'node:child_process';
 import 'node:http';
 import 'node:https';
+import 'tty';
 import 'util';
 import 'net';
 import 'url';
@@ -29,19 +29,20 @@ 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 'querystring';
 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.
@@ -199,116 +200,4 @@ class RemoteEnvironmentTransport {
     }
 }
 
-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) {
-        return {
-            connection: options.hmr.connection,
-            logger: options.hmr.logger,
-        };
-    }
-    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';
-    }
-    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());
-}
-
-export { RemoteEnvironmentTransport, ServerHMRConnector, createServerModuleRunner, isCSSRequest, splitVendorChunk, splitVendorChunkPlugin };
+export { RemoteEnvironmentTransport, isCSSRequest, splitVendorChunk, splitVendorChunkPlugin };