vite 2.6.9 → 2.6.13

package/dist/node/index.d.ts

@@ -1,8 +1,14 @@
 /// <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 { TransformOptions as EsbuildTransformOptions } from 'esbuild';
+import { EventEmitter } from 'events';
 import * as events from 'events';
 import * as fs from 'fs';
 import * as http from 'http';
@@ -12,6 +18,7 @@ import { InputOptions } from 'rollup';
 import { LoadResult } from 'rollup';
 import { ModuleFormat } from 'rollup';
 import * as net from 'net';
+import { OutgoingHttpHeaders } from 'http';
 import { OutputBundle } from 'rollup';
 import { OutputChunk } from 'rollup';
 import { PartialResolvedId } from 'rollup';
@@ -24,18 +31,22 @@ 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_2 } from 'https';
+import { Server as Server_3 } from 'net';
 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 WebSocket from 'ws';
+import { ZlibOptions } from 'zlib';
 
 export declare interface Alias {
     find: string | RegExp
@@ -1177,7 +1188,7 @@ export declare type PluginOption = Plugin | false | null | undefined;
  */
 export declare function preview(config: ResolvedConfig, serverOptions: Pick<ServerOptions, 'port' | 'host'>): Promise<Server>;
 
-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 {
     /**
@@ -2058,6 +2069,507 @@ 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
+
+        // 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: 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: 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, 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, 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
+    }
+
+    /**
+     * Data represents the message payload received over the WebSocket.
+     */
+    export type Data = string | Buffer | ArrayBuffer | Buffer[]
+
+    /**
+     * CertMeta represents the accepted types for certificate & key data.
+     */
+    export type CertMeta = string | string[] | Buffer | Buffer[]
+
+    /**
+     * VerifyClientCallbackSync is a synchronous callback used to inspect the
+     * incoming message. The return value (boolean) of the function determines
+     * whether or not to accept the handshake.
+     */
+    export type VerifyClientCallbackSync = (info: {
+        origin: string
+        secure: boolean
+        req: IncomingMessage
+    }) => boolean
+
+    /**
+     * VerifyClientCallbackAsync is an asynchronous callback used to inspect the
+     * incoming message. The return value (boolean) of the function determines
+     * whether or not to accept the handshake.
+     */
+    export type VerifyClientCallbackAsync = (
+    info: { origin: string; secure: boolean; req: IncomingMessage },
+    callback: (
+    res: boolean,
+    code?: number,
+    message?: string,
+    headers?: OutgoingHttpHeaders
+    ) => void
+    ) => void
+
+    export interface ClientOptions extends SecureContextOptions {
+        protocol?: string | undefined
+        followRedirects?: boolean | undefined
+        handshakeTimeout?: number | undefined
+        maxRedirects?: number | undefined
+        perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined
+        localAddress?: string | undefined
+        protocolVersion?: number | undefined
+        headers?: { [key: string]: string } | undefined
+        origin?: string | undefined
+        agent?: Agent | undefined
+        host?: string | undefined
+        family?: number | undefined
+        checkServerIdentity?(servername: string, cert: CertMeta): boolean
+        rejectUnauthorized?: boolean | undefined
+        maxPayload?: number | undefined
+    }
+
+    export interface PerMessageDeflateOptions {
+        serverNoContextTakeover?: boolean | undefined
+        clientNoContextTakeover?: boolean | undefined
+        serverMaxWindowBits?: number | undefined
+        clientMaxWindowBits?: number | undefined
+        zlibDeflateOptions?:
+        | {
+            flush?: number | undefined
+            finishFlush?: number | undefined
+            chunkSize?: number | undefined
+            windowBits?: number | undefined
+            level?: number | undefined
+            memLevel?: number | undefined
+            strategy?: number | undefined
+            dictionary?: Buffer | Buffer[] | DataView | undefined
+            info?: boolean | undefined
+        }
+        | undefined
+        zlibInflateOptions?: ZlibOptions | undefined
+        threshold?: number | undefined
+        concurrencyLimit?: number | undefined
+    }
+
+    export interface OpenEvent {
+        type: string
+        target: WebSocket
+    }
+
+    export interface ErrorEvent {
+        error: any
+        message: string
+        type: string
+        target: WebSocket
+    }
+
+    export interface CloseEvent {
+        wasClean: boolean
+        code: number
+        reason: string
+        type: string
+        target: WebSocket
+    }
+
+    export interface MessageEvent {
+        data: Data
+        type: string
+        target: WebSocket
+    }
+
+    export interface EventListenerOptions {
+        once?: boolean | undefined
+    }
+
+    export interface ServerOptions {
+        host?: string | undefined
+        port?: number | undefined
+        backlog?: number | undefined
+        server?: Server | Server_2 | undefined
+        verifyClient?:
+        | VerifyClientCallbackAsync
+        | VerifyClientCallbackSync
+        | undefined
+        handleProtocols?: any
+        path?: string | undefined
+        noServer?: boolean | undefined
+        clientTracking?: boolean | undefined
+        perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined
+        maxPayload?: number | undefined
+    }
+
+    export interface AddressInfo {
+        address: string
+        family: string
+        port: number
+    }
+
+    // WebSocket Server
+    export class Server extends EventEmitter {
+        options: ServerOptions
+        path: string
+        clients: Set<WebSocket>
+
+        constructor(options?: ServerOptions, callback?: () => void)
+
+        address(): AddressInfo | string
+        close(cb?: (err?: Error) => void): void
+        handleUpgrade(
+        request: IncomingMessage,
+        socket: Socket,
+        upgradeHead: Buffer,
+        callback: (client: WebSocket, request: IncomingMessage) => void
+        ): void
+        shouldHandle(request: IncomingMessage): boolean | Promise<boolean>
+
+        // Events
+        on(
+        event: 'connection',
+        cb: (this: Server, socket: WebSocket, request: IncomingMessage) => void
+        ): this
+        on(event: 'error', cb: (this: Server, error: Error) => void): this
+        on(
+        event: 'headers',
+        cb: (this: Server, headers: string[], request: IncomingMessage) => void
+        ): this
+        on(event: 'close' | 'listening', cb: (this: Server) => void): this
+        on(
+        event: string | symbol,
+        listener: (this: Server, ...args: any[]) => void
+        ): this
+
+        once(
+        event: 'connection',
+        cb: (this: Server, socket: WebSocket, request: IncomingMessage) => void
+        ): this
+        once(event: 'error', cb: (this: Server, error: Error) => void): this
+        once(
+        event: 'headers',
+        cb: (this: Server, headers: string[], request: IncomingMessage) => void
+        ): this
+        once(event: 'close' | 'listening', cb: (this: Server) => void): this
+        once(event: string | symbol, listener: (...args: any[]) => void): this
+
+        off(
+        event: 'connection',
+        cb: (this: Server, socket: WebSocket, request: IncomingMessage) => void
+        ): this
+        off(event: 'error', cb: (this: Server, error: Error) => void): this
+        off(
+        event: 'headers',
+        cb: (this: Server, headers: string[], request: IncomingMessage) => void
+        ): this
+        off(event: 'close' | 'listening', cb: (this: Server) => void): this
+        off(
+        event: string | symbol,
+        listener: (this: Server, ...args: any[]) => void
+        ): this
+
+        addListener(
+        event: 'connection',
+        cb: (client: WebSocket, request: IncomingMessage) => void
+        ): this
+        addListener(event: 'error', cb: (err: Error) => void): this
+        addListener(
+        event: 'headers',
+        cb: (headers: string[], request: IncomingMessage) => void
+        ): this
+        addListener(event: 'close' | 'listening', cb: () => void): this
+        addListener(
+        event: string | symbol,
+        listener: (...args: any[]) => void
+        ): this
+
+        removeListener(event: 'connection', cb: (client: WebSocket) => void): this
+        removeListener(event: 'error', cb: (err: Error) => void): this
+        removeListener(
+        event: 'headers',
+        cb: (headers: string[], request: IncomingMessage) => void
+        ): this
+        removeListener(event: 'close' | 'listening', cb: () => void): this
+        removeListener(
+        event: string | symbol,
+        listener: (...args: any[]) => void
+        ): this
+    }
+
+    // WebSocket stream
+    export function createWebSocketStream(
+    websocket: WebSocket,
+    options?: DuplexOptions
+    ): Duplex
+}
+
 export declare interface WebSocketServer {
     on: WebSocket.Server['on'];
     off: WebSocket.Server['off'];

package/dist/node/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var build = require('./chunks/dep-be032392.js');
+var build = require('./chunks/dep-85dbaaa7.js');
 require('fs');
 require('path');
 require('events');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite",
-  "version": "2.6.9",
+  "version": "2.6.13",
   "license": "MIT",
   "author": "Evan You",
   "description": "Native-ESM powered web dev build tool",
@@ -54,6 +54,8 @@
   },
   "devDependencies": {
     "@ampproject/remapping": "^1.0.1",
+    "@babel/parser": "^7.15.8",
+    "@babel/types": "^7.15.6",
     "@rollup/plugin-alias": "^3.1.5",
     "@rollup/plugin-commonjs": "^21.0.0",
     "@rollup/plugin-dynamic-import-vars": "^1.4.0",

package/src/client/overlay.ts

@@ -106,8 +106,8 @@ code {
   <pre class="stack"></pre>
   <div class="tip">
     Click outside or fix the code to dismiss.<br>
-    You can also disable this overlay with
-    <code>hmr: { overlay: false }</code> in <code>vite.config.js.</code>
+    You can also disable this overlay by setting
+    <code>server.hmr.overlay</code> to <code>false</code> in <code>vite.config.js.</code>
   </div>
 </div>
 `