vite 2.7.0 → 2.7.4

package/dist/node/index.d.ts

@@ -1,54 +1,52 @@
 /// <reference types="node" />
 
-import { Agent } from 'http';
-import { BuildOptions as BuildOptions_2 } from 'esbuild';
-import { ClientRequest } from 'http';
-import { ClientRequestArgs } from 'http';
-import { CustomPluginOptions } from 'rollup';
-import { Duplex } from 'stream';
-import { DuplexOptions } from 'stream';
+import type { Agent } from 'http';
+import type { BuildOptions as BuildOptions_2 } from 'esbuild';
+import type { ClientRequest } from 'http';
+import type { ClientRequestArgs } from 'http';
+import type { CustomPluginOptions } from 'rollup';
+import type { Duplex } from 'stream';
+import type { DuplexOptions } from 'stream';
 import { TransformOptions as EsbuildTransformOptions } from 'esbuild';
 import { EventEmitter } from 'events';
 import * as events from 'events';
-import * as fs from 'fs';
+import type * as fs from 'fs';
 import * as http from 'http';
-import { IncomingMessage } from 'http';
-import { InputOptions } from 'rollup';
-import { LoadResult } from 'rollup';
-import { ModuleFormat } from 'rollup';
-import { ModuleInfo } from 'rollup';
-import * as net from 'net';
-import { OutgoingHttpHeaders } from 'http';
-import { OutputBundle } from 'rollup';
-import { OutputChunk } from 'rollup';
-import { PartialResolvedId } from 'rollup';
-import { Plugin as Plugin_2 } from 'rollup';
-import { PluginContext } from 'rollup';
-import { PluginHooks } from 'rollup';
-import * as Postcss from 'postcss';
-import { ResolveIdResult } from 'rollup';
-import { RollupError } from 'rollup';
-import { RollupOptions } from 'rollup';
-import { RollupOutput } from 'rollup';
-import { RollupWatcher } from 'rollup';
-import { SecureContextOptions } from 'tls';
-import { Server } from 'http';
-import { Server as Server_2 } from 'net';
-import { Server as Server_3 } from 'https';
-import { ServerOptions as ServerOptions_2 } from 'https';
-import { ServerResponse } from 'http';
-import { Socket } from 'net';
-import { SourceDescription } from 'rollup';
-import { SourceMap } from 'rollup';
-import * as stream from 'stream';
-import { TransformPluginContext } from 'rollup';
-import { TransformResult as TransformResult_2 } from 'esbuild';
-import { TransformResult as TransformResult_3 } from 'rollup';
-import { URL } from 'url';
-import * as url from 'url';
-import { WatcherOptions } from 'rollup';
-import { WebSocketServer as WebSocketServer_2 } from 'ws';
-import { ZlibOptions } from 'zlib';
+import type { IncomingMessage } from 'http';
+import type { InputOptions } from 'rollup';
+import type { LoadResult } from 'rollup';
+import type { ModuleFormat } from 'rollup';
+import type { ModuleInfo } from 'rollup';
+import type * as net from 'net';
+import type { OutgoingHttpHeaders } from 'http';
+import type { OutputBundle } from 'rollup';
+import type { OutputChunk } from 'rollup';
+import type { PartialResolvedId } from 'rollup';
+import type { Plugin as Plugin_2 } from 'rollup';
+import type { PluginContext } from 'rollup';
+import type { PluginHooks } from 'rollup';
+import type * as Postcss from 'postcss';
+import type { ResolveIdResult } from 'rollup';
+import type { RollupError } from 'rollup';
+import type { RollupOptions } from 'rollup';
+import type { RollupOutput } from 'rollup';
+import type { RollupWatcher } from 'rollup';
+import type { SecureContextOptions } from 'tls';
+import type { Server } from 'http';
+import type { Server as Server_2 } from 'https';
+import type { Server as Server_3 } from 'net';
+import type { ServerOptions as ServerOptions_2 } from 'https';
+import type { ServerResponse } from 'http';
+import type { SourceDescription } from 'rollup';
+import type { SourceMap } from 'rollup';
+import type * as stream from 'stream';
+import type { TransformPluginContext } from 'rollup';
+import type { TransformResult as TransformResult_2 } from 'esbuild';
+import type { TransformResult as TransformResult_3 } from 'rollup';
+import type { URL } from 'url';
+import type * as url from 'url';
+import type { WatcherOptions } from 'rollup';
+import type { ZlibOptions } from 'zlib';
 
 export declare interface Alias {
     find: string | RegExp
@@ -1064,7 +1062,7 @@ export declare interface ManifestChunk {
 
 export declare type Matcher = AnymatchPattern | AnymatchPattern[]
 
-export declare function mergeConfig(a: Record<string, any>, b: Record<string, any>, isRoot?: boolean): Record<string, any>;
+export declare function mergeConfig(defaults: Record<string, any>, overrides: Record<string, any>, isRoot?: boolean): Record<string, any>;
 
 export declare class ModuleGraph {
     private resolveId;
@@ -1298,7 +1296,7 @@ export declare interface PreviewServer {
 /**
  * @deprecated Use `server.printUrls()` instead
  */
-export declare function printHttpServerUrls(server: Server_2, config: ResolvedConfig): void;
+export declare function printHttpServerUrls(server: Server_3, config: ResolvedConfig): void;
 
 export declare interface ProxyOptions extends HttpProxy.ServerOptions {
     /**
@@ -2182,280 +2180,264 @@ export declare interface WatchOptions {
     | boolean
 }
 
-export declare namespace WebSocket {
-    // WebSocket socket.
-    export class WebSocket extends EventEmitter {
-        /** The connection is not yet open. */
-        static readonly CONNECTING: 0
-        /** The connection is open and ready to communicate. */
-        static readonly OPEN: 1
-        /** The connection is in the process of closing. */
-        static readonly CLOSING: 2
-        /** The connection is closed. */
-        static readonly CLOSED: 3
-
-        binaryType: 'nodebuffer' | 'arraybuffer' | 'fragments'
-        readonly bufferedAmount: number
-        readonly extensions: string
-        readonly protocol: string
-        /** The current state of the connection */
-        readonly readyState:
-        | typeof WebSocket.CONNECTING
-        | typeof WebSocket.OPEN
-        | typeof WebSocket.CLOSING
-        | typeof WebSocket.CLOSED
-        readonly url: string
-
-        /** The connection is not yet open. */
-        readonly CONNECTING: 0
-        /** The connection is open and ready to communicate. */
-        readonly OPEN: 1
-        /** The connection is in the process of closing. */
-        readonly CLOSING: 2
-        /** The connection is closed. */
-        readonly CLOSED: 3
-
-        onopen: (event: WebSocket.OpenEvent) => void
-        onerror: (event: WebSocket.ErrorEvent) => void
-        onclose: (event: WebSocket.CloseEvent) => void
-        onmessage: (event: WebSocket.MessageEvent) => void
-
-        constructor(
-        address: string | URL,
-        options?: WebSocket.ClientOptions | ClientRequestArgs
-        )
-        constructor(
-        address: string | URL,
-        protocols?: string | string[],
-        options?: WebSocket.ClientOptions | ClientRequestArgs
-        )
-
-        close(code?: number, data?: string): void
-        ping(data?: any, mask?: boolean, cb?: (err: Error) => void): void
-        pong(data?: any, mask?: boolean, cb?: (err: Error) => void): void
-        send(data: any, cb?: (err?: Error) => void): void
-        send(
-        data: any,
-        options: {
-            mask?: boolean | undefined
-            binary?: boolean | undefined
-            compress?: boolean | undefined
-            fin?: boolean | undefined
-        },
-        cb?: (err?: Error) => void
-        ): void
-        terminate(): void
-
-        // HTML5 WebSocket events
-        addEventListener(
-        method: 'message',
-        cb: (event: { data: any; type: string; target: WebSocket }) => void,
-        options?: WebSocket.EventListenerOptions
-        ): void
-        addEventListener(
-        method: 'close',
-        cb: (event: {
-            wasClean: boolean
-            code: number
-            reason: string
-            target: WebSocket
-        }) => void,
-        options?: WebSocket.EventListenerOptions
-        ): void
-        addEventListener(
-        method: 'error',
-        cb: (event: {
-            error: any
-            message: any
-            type: string
-            target: WebSocket
-        }) => void,
-        options?: WebSocket.EventListenerOptions
-        ): void
-        addEventListener(
-        method: 'open',
-        cb: (event: { target: WebSocket }) => void,
-        options?: WebSocket.EventListenerOptions
-        ): void
-        addEventListener(
-        method: string,
-        listener: () => void,
-        options?: WebSocket.EventListenerOptions
-        ): void
-
-        removeEventListener(
-        method: 'message',
-        cb?: (event: { data: any; type: string; target: WebSocket }) => void
-        ): void
-        removeEventListener(
-        method: 'close',
-        cb?: (event: {
-            wasClean: boolean
-            code: number
-            reason: string
-            target: WebSocket
-        }) => void
-        ): void
-        removeEventListener(
-        method: 'error',
-        cb?: (event: {
-            error: any
-            message: any
-            type: string
-            target: WebSocket
-        }) => void
-        ): void
-        removeEventListener(
-        method: 'open',
-        cb?: (event: { target: WebSocket }) => void
-        ): void
-        removeEventListener(method: string, listener?: () => void): void
+export declare class WebSocket extends EventEmitter {
+    /** The connection is not yet open. */
+    static readonly CONNECTING: 0
+    /** The connection is open and ready to communicate. */
+    static readonly OPEN: 1
+    /** The connection is in the process of closing. */
+    static readonly CLOSING: 2
+    /** The connection is closed. */
+    static readonly CLOSED: 3
+
+    binaryType: 'nodebuffer' | 'arraybuffer' | 'fragments'
+    readonly bufferedAmount: number
+    readonly extensions: string
+    readonly protocol: string
+    /** The current state of the connection */
+    readonly readyState:
+    | typeof WebSocket.CONNECTING
+    | typeof WebSocket.OPEN
+    | typeof WebSocket.CLOSING
+    | typeof WebSocket.CLOSED
+    readonly url: string
+
+    /** The connection is not yet open. */
+    readonly CONNECTING: 0
+    /** The connection is open and ready to communicate. */
+    readonly OPEN: 1
+    /** The connection is in the process of closing. */
+    readonly CLOSING: 2
+    /** The connection is closed. */
+    readonly CLOSED: 3
+
+    onopen: (event: WebSocket.Event) => void
+    onerror: (event: WebSocket.ErrorEvent) => void
+    onclose: (event: WebSocket.CloseEvent) => void
+    onmessage: (event: WebSocket.MessageEvent) => void
+
+    constructor(
+    address: string | URL,
+    options?: WebSocket.ClientOptions | ClientRequestArgs
+    )
+    constructor(
+    address: string | URL,
+    protocols?: string | string[],
+    options?: WebSocket.ClientOptions | ClientRequestArgs
+    )
+
+    close(code?: number, data?: string | Buffer): void
+    ping(data?: any, mask?: boolean, cb?: (err: Error) => void): void
+    pong(data?: any, mask?: boolean, cb?: (err: Error) => void): void
+    send(data: any, cb?: (err?: Error) => void): void
+    send(
+    data: any,
+    options: {
+        mask?: boolean | undefined
+        binary?: boolean | undefined
+        compress?: boolean | undefined
+        fin?: boolean | undefined
+    },
+    cb?: (err?: Error) => void
+    ): void
+    terminate(): void
+
+    // HTML5 WebSocket events
+    addEventListener(
+    method: 'message',
+    cb: (event: WebSocket.MessageEvent) => void,
+    options?: WebSocket.EventListenerOptions
+    ): void
+    addEventListener(
+    method: 'close',
+    cb: (event: WebSocket.CloseEvent) => void,
+    options?: WebSocket.EventListenerOptions
+    ): void
+    addEventListener(
+    method: 'error',
+    cb: (event: WebSocket.ErrorEvent) => void,
+    options?: WebSocket.EventListenerOptions
+    ): void
+    addEventListener(
+    method: 'open',
+    cb: (event: WebSocket.Event) => void,
+    options?: WebSocket.EventListenerOptions
+    ): void
+
+    removeEventListener(
+    method: 'message',
+    cb: (event: WebSocket.MessageEvent) => void
+    ): void
+    removeEventListener(
+    method: 'close',
+    cb: (event: WebSocket.CloseEvent) => void
+    ): void
+    removeEventListener(
+    method: 'error',
+    cb: (event: WebSocket.ErrorEvent) => void
+    ): void
+    removeEventListener(
+    method: 'open',
+    cb: (event: WebSocket.Event) => void
+    ): void
+
+    // Events
+    on(
+    event: 'close',
+    listener: (this: WebSocket, code: number, reason: Buffer) => void
+    ): this
+    on(event: 'error', listener: (this: WebSocket, err: Error) => void): this
+    on(
+    event: 'upgrade',
+    listener: (this: WebSocket, request: IncomingMessage) => void
+    ): this
+    on(
+    event: 'message',
+    listener: (
+    this: WebSocket,
+    data: WebSocket.RawData,
+    isBinary: boolean
+    ) => void
+    ): this
+    on(event: 'open', listener: (this: WebSocket) => void): this
+    on(
+    event: 'ping' | 'pong',
+    listener: (this: WebSocket, data: Buffer) => void
+    ): this
+    on(
+    event: 'unexpected-response',
+    listener: (
+    this: WebSocket,
+    request: ClientRequest,
+    response: IncomingMessage
+    ) => void
+    ): this
+    on(
+    event: string | symbol,
+    listener: (this: WebSocket, ...args: any[]) => void
+    ): this
 
-        // Events
-        on(
-        event: 'close',
-        listener: (this: WebSocket, code: number, reason: string) => void
-        ): this
-        on(event: 'error', listener: (this: WebSocket, err: Error) => void): this
-        on(
-        event: 'upgrade',
-        listener: (this: WebSocket, request: IncomingMessage) => void
-        ): this
-        on(
-        event: 'message',
-        listener: (this: WebSocket, data: WebSocket.Data) => void
-        ): this
-        on(event: 'open', listener: (this: WebSocket) => void): this
-        on(
-        event: 'ping' | 'pong',
-        listener: (this: WebSocket, data: Buffer) => void
-        ): this
-        on(
-        event: 'unexpected-response',
-        listener: (
-        this: WebSocket,
-        request: ClientRequest,
-        response: IncomingMessage
-        ) => void
-        ): this
-        on(
-        event: string | symbol,
-        listener: (this: WebSocket, ...args: any[]) => void
-        ): this
+    once(
+    event: 'close',
+    listener: (this: WebSocket, code: number, reason: Buffer) => void
+    ): this
+    once(event: 'error', listener: (this: WebSocket, err: Error) => void): this
+    once(
+    event: 'upgrade',
+    listener: (this: WebSocket, request: IncomingMessage) => void
+    ): this
+    once(
+    event: 'message',
+    listener: (
+    this: WebSocket,
+    data: WebSocket.RawData,
+    isBinary: boolean
+    ) => void
+    ): this
+    once(event: 'open', listener: (this: WebSocket) => void): this
+    once(
+    event: 'ping' | 'pong',
+    listener: (this: WebSocket, data: Buffer) => void
+    ): this
+    once(
+    event: 'unexpected-response',
+    listener: (
+    this: WebSocket,
+    request: ClientRequest,
+    response: IncomingMessage
+    ) => void
+    ): this
+    once(
+    event: string | symbol,
+    listener: (this: WebSocket, ...args: any[]) => void
+    ): this
 
-        once(
-        event: 'close',
-        listener: (this: WebSocket, code: number, reason: string) => void
-        ): this
-        once(event: 'error', listener: (this: WebSocket, err: Error) => void): this
-        once(
-        event: 'upgrade',
-        listener: (this: WebSocket, request: IncomingMessage) => void
-        ): this
-        once(
-        event: 'message',
-        listener: (this: WebSocket, data: WebSocket.Data) => void
-        ): this
-        once(event: 'open', listener: (this: WebSocket) => void): this
-        once(
-        event: 'ping' | 'pong',
-        listener: (this: WebSocket, data: Buffer) => void
-        ): this
-        once(
-        event: 'unexpected-response',
-        listener: (
-        this: WebSocket,
-        request: ClientRequest,
-        response: IncomingMessage
-        ) => void
-        ): this
-        once(
-        event: string | symbol,
-        listener: (this: WebSocket, ...args: any[]) => void
-        ): this
+    off(
+    event: 'close',
+    listener: (this: WebSocket, code: number, reason: Buffer) => void
+    ): this
+    off(event: 'error', listener: (this: WebSocket, err: Error) => void): this
+    off(
+    event: 'upgrade',
+    listener: (this: WebSocket, request: IncomingMessage) => void
+    ): this
+    off(
+    event: 'message',
+    listener: (
+    this: WebSocket,
+    data: WebSocket.RawData,
+    isBinary: boolean
+    ) => void
+    ): this
+    off(event: 'open', listener: (this: WebSocket) => void): this
+    off(
+    event: 'ping' | 'pong',
+    listener: (this: WebSocket, data: Buffer) => void
+    ): this
+    off(
+    event: 'unexpected-response',
+    listener: (
+    this: WebSocket,
+    request: ClientRequest,
+    response: IncomingMessage
+    ) => void
+    ): this
+    off(
+    event: string | symbol,
+    listener: (this: WebSocket, ...args: any[]) => void
+    ): this
 
-        off(
-        event: 'close',
-        listener: (this: WebSocket, code: number, reason: string) => void
-        ): this
-        off(event: 'error', listener: (this: WebSocket, err: Error) => void): this
-        off(
-        event: 'upgrade',
-        listener: (this: WebSocket, request: IncomingMessage) => void
-        ): this
-        off(
-        event: 'message',
-        listener: (this: WebSocket, data: WebSocket.Data) => void
-        ): this
-        off(event: 'open', listener: (this: WebSocket) => void): this
-        off(
-        event: 'ping' | 'pong',
-        listener: (this: WebSocket, data: Buffer) => void
-        ): this
-        off(
-        event: 'unexpected-response',
-        listener: (
-        this: WebSocket,
-        request: ClientRequest,
-        response: IncomingMessage
-        ) => void
-        ): this
-        off(
-        event: string | symbol,
-        listener: (this: WebSocket, ...args: any[]) => void
-        ): this
+    addListener(
+    event: 'close',
+    listener: (code: number, reason: Buffer) => void
+    ): this
+    addListener(event: 'error', listener: (err: Error) => void): this
+    addListener(
+    event: 'upgrade',
+    listener: (request: IncomingMessage) => void
+    ): this
+    addListener(
+    event: 'message',
+    listener: (data: WebSocket.RawData, isBinary: boolean) => void
+    ): this
+    addListener(event: 'open', listener: () => void): this
+    addListener(event: 'ping' | 'pong', listener: (data: Buffer) => void): this
+    addListener(
+    event: 'unexpected-response',
+    listener: (request: ClientRequest, response: IncomingMessage) => void
+    ): this
+    addListener(event: string | symbol, listener: (...args: any[]) => void): this
 
-        addListener(
-        event: 'close',
-        listener: (code: number, message: string) => void
-        ): this
-        addListener(event: 'error', listener: (err: Error) => void): this
-        addListener(
-        event: 'upgrade',
-        listener: (request: IncomingMessage) => void
-        ): this
-        addListener(
-        event: 'message',
-        listener: (data: WebSocket.Data) => void
-        ): this
-        addListener(event: 'open', listener: () => void): this
-        addListener(event: 'ping' | 'pong', listener: (data: Buffer) => void): this
-        addListener(
-        event: 'unexpected-response',
-        listener: (request: ClientRequest, response: IncomingMessage) => void
-        ): this
-        addListener(
-        event: string | symbol,
-        listener: (...args: any[]) => void
-        ): this
+    removeListener(
+    event: 'close',
+    listener: (code: number, reason: Buffer) => void
+    ): this
+    removeListener(event: 'error', listener: (err: Error) => void): this
+    removeListener(
+    event: 'upgrade',
+    listener: (request: IncomingMessage) => void
+    ): this
+    removeListener(
+    event: 'message',
+    listener: (data: WebSocket.RawData, isBinary: boolean) => void
+    ): this
+    removeListener(event: 'open', listener: () => void): this
+    removeListener(event: 'ping' | 'pong', listener: (data: Buffer) => void): this
+    removeListener(
+    event: 'unexpected-response',
+    listener: (request: ClientRequest, response: IncomingMessage) => void
+    ): this
+    removeListener(
+    event: string | symbol,
+    listener: (...args: any[]) => void
+    ): this
+}
 
-        removeListener(
-        event: 'close',
-        listener: (code: number, message: string) => void
-        ): this
-        removeListener(event: 'error', listener: (err: Error) => void): this
-        removeListener(
-        event: 'upgrade',
-        listener: (request: IncomingMessage) => void
-        ): this
-        removeListener(
-        event: 'message',
-        listener: (data: WebSocket.Data) => void
-        ): this
-        removeListener(event: 'open', listener: () => void): this
-        removeListener(
-        event: 'ping' | 'pong',
-        listener: (data: Buffer) => void
-        ): this
-        removeListener(
-        event: 'unexpected-response',
-        listener: (request: ClientRequest, response: IncomingMessage) => void
-        ): this
-        removeListener(
-        event: string | symbol,
-        listener: (...args: any[]) => void
-        ): this
-    }
+export declare namespace WebSocket {
+    /**
+     * Data represents the raw message payload received over the WebSocket.
+     */
+    export type RawData = Buffer | ArrayBuffer | Buffer[]
 
     /**
      * Data represents the message payload received over the WebSocket.
@@ -2534,7 +2516,7 @@ export declare namespace WebSocket {
         concurrencyLimit?: number | undefined
     }
 
-    export interface OpenEvent {
+    export interface Event {
         type: string
         target: WebSocket
     }
@@ -2568,17 +2550,21 @@ export declare namespace WebSocket {
         host?: string | undefined
         port?: number | undefined
         backlog?: number | undefined
-        server?: Server | Server_3 | undefined
+        server?: Server | Server_2 | undefined
         verifyClient?:
         | VerifyClientCallbackAsync
         | VerifyClientCallbackSync
         | undefined
-        handleProtocols?: any
+        handleProtocols?: (
+        protocols: Set<string>,
+        request: IncomingMessage
+        ) => string | false
         path?: string | undefined
         noServer?: boolean | undefined
         clientTracking?: boolean | undefined
         perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined
         maxPayload?: number | undefined
+        skipUTF8Validation?: boolean | undefined
     }
 
     export interface AddressInfo {
@@ -2599,7 +2585,7 @@ export declare namespace WebSocket {
         close(cb?: (err?: Error) => void): void
         handleUpgrade(
         request: IncomingMessage,
-        socket: Socket,
+        socket: Duplex,
         upgradeHead: Buffer,
         callback: (client: WebSocket, request: IncomingMessage) => void
         ): void
@@ -2676,6 +2662,11 @@ export declare namespace WebSocket {
         ): this
     }
 
+    const WebSocketServer: typeof Server
+    export type WebSocketServer = Server
+    const WebSocket: typeof WebSocketAlias
+    export type WebSocket = WebSocketAlias
+
     // WebSocket stream
     export function createWebSocketStream(
     websocket: WebSocket,
@@ -2683,9 +2674,13 @@ export declare namespace WebSocket {
     ): Duplex
 }
 
+export declare const WebSocketAlias: typeof WebSocket;
+
+export declare type WebSocketAlias = WebSocket
+
 export declare interface WebSocketServer {
-    on: WebSocketServer_2['on'];
-    off: WebSocketServer_2['off'];
+    on: WebSocket.Server['on'];
+    off: WebSocket.Server['off'];
     send(payload: HMRPayload): void;
     close(): Promise<void>;
 }