vite 3.1.4 → 3.2.0-beta.0

package/types/ws.d.ts

@@ -1,553 +1 @@
-// Modified and inlined to avoid extra dependency
-// Source: https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/ws/index.d.ts
-
-// Type definitions for ws 8.5
-// Project: https://github.com/websockets/ws
-// Definitions by: Paul Loyd <https://github.com/loyd>
-//                 Margus Lamp <https://github.com/mlamp>
-//                 Philippe D'Alva <https://github.com/TitaneBoy>
-//                 reduckted <https://github.com/reduckted>
-//                 teidesu <https://github.com/teidesu>
-//                 Bartosz Wojtkowiak <https://github.com/wojtkowiak>
-//                 Kyle Hensel <https://github.com/k-yle>
-//                 Samuel Skeen <https://github.com/cwadrupldijjit>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-/// <reference types="node" />
-
-import { EventEmitter } from 'node:events'
-import type {
-  Agent,
-  ClientRequest,
-  ClientRequestArgs,
-  Server as HTTPServer,
-  IncomingMessage,
-  OutgoingHttpHeaders
-} from 'node:http'
-import type { Server as HTTPSServer } from 'node:https'
-import type { Duplex, DuplexOptions } from 'node:stream'
-import type { SecureContextOptions } from 'node:tls'
-import type { URL } from 'node:url'
-import type { ZlibOptions } from 'node:zlib'
-
-// WebSocket socket.
-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
-  /** Indicates whether the websocket is paused */
-  readonly isPaused: boolean
-  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) | null
-  onerror: ((event: WebSocket.ErrorEvent) => void) | null
-  onclose: ((event: WebSocket.CloseEvent) => void) | null
-  onmessage: ((event: WebSocket.MessageEvent) => void) | null
-
-  constructor(address: null)
-  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
-
-  /**
-   * Pause the websocket causing it to stop emitting events. Some events can still be
-   * emitted after this is called, until all buffered data is consumed. This method
-   * is a noop if the ready state is `CONNECTING` or `CLOSED`.
-   */
-  pause(): void
-  /**
-   * Make a paused socket resume emitting events. This method is a noop if the ready
-   * state is `CONNECTING` or `CLOSED`.
-   */
-  resume(): 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
-
-  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
-
-  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
-
-  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
-
-  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
-}
-
-declare const WebSocketAlias: typeof WebSocket
-interface WebSocketAlias extends WebSocket {} // tslint:disable-line no-empty-interface
-
-declare namespace WebSocket {
-  /**
-   * Data represents the raw message payload received over the WebSocket.
-   */
-  type RawData = Buffer | ArrayBuffer | Buffer[]
-
-  /**
-   * Data represents the message payload received over the WebSocket.
-   */
-  type Data = string | Buffer | ArrayBuffer | Buffer[]
-
-  /**
-   * CertMeta represents the accepted types for certificate & key data.
-   */
-  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.
-   */
-  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.
-   */
-  type VerifyClientCallbackAsync = (
-    info: { origin: string; secure: boolean; req: IncomingMessage },
-    callback: (
-      res: boolean,
-      code?: number,
-      message?: string,
-      headers?: OutgoingHttpHeaders
-    ) => void
-  ) => void
-
-  interface ClientOptions extends SecureContextOptions {
-    protocol?: string | undefined
-    followRedirects?: boolean | undefined
-    generateMask?(mask: Buffer): void
-    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
-    skipUTF8Validation?: boolean | undefined
-  }
-
-  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
-  }
-
-  interface Event {
-    type: string
-    target: WebSocket
-  }
-
-  interface ErrorEvent {
-    error: any
-    message: string
-    type: string
-    target: WebSocket
-  }
-
-  interface CloseEvent {
-    wasClean: boolean
-    code: number
-    reason: string
-    type: string
-    target: WebSocket
-  }
-
-  interface MessageEvent {
-    data: Data
-    type: string
-    target: WebSocket
-  }
-
-  interface EventListenerOptions {
-    once?: boolean | undefined
-  }
-
-  interface ServerOptions {
-    host?: string | undefined
-    port?: number | undefined
-    backlog?: number | undefined
-    server?: HTTPServer | HTTPSServer | undefined
-    verifyClient?:
-      | VerifyClientCallbackAsync
-      | VerifyClientCallbackSync
-      | undefined
-    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
-    WebSocket?: typeof WebSocket.WebSocket | undefined
-  }
-
-  interface AddressInfo {
-    address: string
-    family: string
-    port: number
-  }
-
-  // WebSocket Server
-  class Server<T extends WebSocket = WebSocket> extends EventEmitter {
-    options: ServerOptions
-    path: string
-    clients: Set<T>
-
-    constructor(options?: ServerOptions, callback?: () => void)
-
-    address(): AddressInfo | string
-    close(cb?: (err?: Error) => void): void
-    handleUpgrade(
-      request: IncomingMessage,
-      socket: Duplex,
-      upgradeHead: Buffer,
-      callback: (client: T, request: IncomingMessage) => void
-    ): void
-    shouldHandle(request: IncomingMessage): boolean | Promise<boolean>
-
-    // Events
-    on(
-      event: 'connection',
-      cb: (this: Server<T>, socket: T, request: IncomingMessage) => void
-    ): this
-    on(event: 'error', cb: (this: Server<T>, error: Error) => void): this
-    on(
-      event: 'headers',
-      cb: (this: Server<T>, headers: string[], request: IncomingMessage) => void
-    ): this
-    on(event: 'close' | 'listening', cb: (this: Server<T>) => void): this
-    on(
-      event: string | symbol,
-      listener: (this: Server<T>, ...args: any[]) => void
-    ): this
-
-    once(
-      event: 'connection',
-      cb: (this: Server<T>, socket: T, request: IncomingMessage) => void
-    ): this
-    once(event: 'error', cb: (this: Server<T>, error: Error) => void): this
-    once(
-      event: 'headers',
-      cb: (this: Server<T>, headers: string[], request: IncomingMessage) => void
-    ): this
-    once(event: 'close' | 'listening', cb: (this: Server<T>) => void): this
-    once(
-      event: string | symbol,
-      listener: (this: Server<T>, ...args: any[]) => void
-    ): this
-
-    off(
-      event: 'connection',
-      cb: (this: Server<T>, socket: T, request: IncomingMessage) => void
-    ): this
-    off(event: 'error', cb: (this: Server<T>, error: Error) => void): this
-    off(
-      event: 'headers',
-      cb: (this: Server<T>, headers: string[], request: IncomingMessage) => void
-    ): this
-    off(event: 'close' | 'listening', cb: (this: Server<T>) => void): this
-    off(
-      event: string | symbol,
-      listener: (this: Server<T>, ...args: any[]) => void
-    ): this
-
-    addListener(
-      event: 'connection',
-      cb: (client: T, 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: T) => 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
-  }
-
-  const WebSocketServer: typeof Server
-  interface WebSocketServer extends Server {} // tslint:disable-line no-empty-interface
-  const WebSocket: typeof WebSocketAlias
-  interface WebSocket extends WebSocketAlias {} // tslint:disable-line no-empty-interface
-
-  // WebSocket stream
-  function createWebSocketStream(
-    websocket: WebSocket,
-    options?: DuplexOptions
-  ): Duplex
-}
-
-// export = WebSocket
-export { WebSocket, WebSocketAlias }
+export type { WebSocket, WebSocketAlias } from '../dist/node'

package/types/package.json

@@ -1,3 +0,0 @@
-{
-  "//": "this file is just here to make pnpm happy with --frozen-lockfile"
-}

package/types/shims.d.ts

@@ -1,96 +0,0 @@
-declare module 'connect' {
-  const connect: () => any
-  export = connect
-}
-
-declare module 'cors' {
-  function cors(options: any): any
-  export = cors
-}
-
-declare module 'selfsigned' {
-  export function generate(attrs: any, options: any, done?: any): any
-}
-
-declare module 'http-proxy' {
-  const proxy: any
-  export = proxy
-}
-
-declare module 'connect-history-api-fallback' {
-  const plugin: any
-  export = plugin
-}
-
-declare module 'launch-editor-middleware' {
-  const plugin: any
-  export = plugin
-}
-
-declare module 'postcss-load-config' {
-  import type { Plugin, ProcessOptions } from 'postcss'
-  function load(
-    inline: any,
-    root: string
-  ): Promise<{
-    options: ProcessOptions
-    plugins: Plugin[]
-  }>
-  export = load
-}
-
-declare module 'postcss-import' {
-  import type { Plugin } from 'postcss'
-  const plugin: (options: {
-    resolve: (
-      id: string,
-      basedir: string,
-      importOptions: any
-    ) => string | string[] | Promise<string | string[]>
-    nameLayer: (index: number, rootFilename: string) => string
-  }) => Plugin
-  export = plugin
-}
-
-declare module 'postcss-modules' {
-  import type { Plugin } from 'postcss'
-  const plugin: (options: any) => Plugin
-  export = plugin
-}
-
-declare module '@rollup/plugin-dynamic-import-vars' {
-  import type { Plugin } from 'rollup'
-  import type { BaseNode } from 'estree'
-
-  interface Options {
-    include?: string | RegExp | (string | RegExp)[]
-    exclude?: string | RegExp | (string | RegExp)[]
-    warnOnError?: boolean
-  }
-
-  const p: (o?: Options) => Plugin
-  export default p
-  export function dynamicImportToGlob(
-    ast: BaseNode,
-    source: string
-  ): null | string
-}
-
-declare module 'rollup-plugin-web-worker-loader' {
-  import type { Plugin } from 'rollup'
-
-  interface Options {
-    targetPlatform?: string
-    pattern?: RegExp
-    extensions?: string[]
-    sourcemap?: boolean
-    inline?: boolean
-  }
-
-  const p: (o?: Options) => Plugin
-  export default p
-}
-
-// LESS' types somewhat references this which doesn't make sense in Node,
-// so we have to shim it
-declare interface HTMLLinkElement {}