vite 2.8.6 → 2.9.0-beta.10

package/types/importMeta.d.ts

@@ -4,10 +4,14 @@
 
 /* eslint-disable @typescript-eslint/consistent-type-imports */
 
-// Duplicate import('../src/node/importGlob').AssertOptions
-// Avoid breaking the production client type because this file is referenced
-// in vite/client.d.ts and in production src/node/importGlob.ts doesn't exist
-interface AssertOptions {
+// Duplicate of import('../src/node/importGlob').GlobOptions in order to
+// avoid breaking the production client type. Because this file is referenced
+// in vite/client.d.ts and in production src/node/importGlob.ts doesn't exist.
+interface GlobOptions {
+  as?: string
+  /**
+   * @deprecated
+   */
   assert?: {
     type: string
   }
@@ -16,57 +20,18 @@ interface AssertOptions {
 interface ImportMeta {
   url: string
 
-  readonly hot?: {
-    readonly data: any
-
-    accept(): void
-    accept(cb: (mod: any) => void): void
-    accept(dep: string, cb: (mod: any) => void): void
-    accept(deps: readonly string[], cb: (mods: any[]) => void): void
-
-    /**
-     * @deprecated
-     */
-    acceptDeps(): never
-
-    dispose(cb: (data: any) => void): void
-    decline(): void
-    invalidate(): void
-
-    on: {
-      (
-        event: 'vite:beforeUpdate',
-        cb: (payload: import('./hmrPayload').UpdatePayload) => void
-      ): void
-      (
-        event: 'vite:beforePrune',
-        cb: (payload: import('./hmrPayload').PrunePayload) => void
-      ): void
-      (
-        event: 'vite:beforeFullReload',
-        cb: (payload: import('./hmrPayload').FullReloadPayload) => void
-      ): void
-      (
-        event: 'vite:error',
-        cb: (payload: import('./hmrPayload').ErrorPayload) => void
-      ): void
-      <T extends string>(
-        event: import('./customEvent').CustomEventName<T>,
-        cb: (data: any) => void
-      ): void
-    }
-  }
+  readonly hot?: import('./hot').ViteHotContext
 
   readonly env: ImportMetaEnv
 
   glob<Module = { [key: string]: any }>(
     pattern: string,
-    options?: AssertOptions
+    options?: GlobOptions
   ): Record<string, () => Promise<Module>>
 
   globEager<Module = { [key: string]: any }>(
     pattern: string,
-    options?: AssertOptions
+    options?: GlobOptions
   ): Record<string, Module>
 }
 

package/types/shims.d.ts

@@ -93,11 +93,6 @@ declare module 'micromatch' {
   ): boolean
 }
 
-declare module 'compression' {
-  function compression(): any
-  export default compression
-}
-
 // LESS' types somewhat references this which doesn't make sense in Node,
 // so we have to shim it
 declare interface HTMLLinkElement {}

package/types/ws.d.ts

@@ -1,4 +1,7 @@
-// Type definitions for ws 8.2
+// 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>
@@ -7,6 +10,7 @@
 //                 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" />
@@ -40,6 +44,8 @@ declare class WebSocket extends EventEmitter {
   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:
@@ -58,11 +64,12 @@ declare class WebSocket extends EventEmitter {
   /** 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
+  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
@@ -89,6 +96,18 @@ declare class WebSocket extends EventEmitter {
   ): 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',
@@ -281,7 +300,7 @@ declare class WebSocket extends EventEmitter {
 }
 
 declare const WebSocketAlias: typeof WebSocket
-type WebSocketAlias = WebSocket
+interface WebSocketAlias extends WebSocket {} // tslint:disable-line no-empty-interface
 
 declare namespace WebSocket {
   /**
@@ -328,6 +347,7 @@ declare namespace WebSocket {
   interface ClientOptions extends SecureContextOptions {
     protocol?: string | undefined
     followRedirects?: boolean | undefined
+    generateMask?(mask: Buffer): void
     handshakeTimeout?: number | undefined
     maxRedirects?: number | undefined
     perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined
@@ -341,6 +361,7 @@ declare namespace WebSocket {
     checkServerIdentity?(servername: string, cert: CertMeta): boolean
     rejectUnauthorized?: boolean | undefined
     maxPayload?: number | undefined
+    skipUTF8Validation?: boolean | undefined
   }
 
   interface PerMessageDeflateOptions {
@@ -415,6 +436,7 @@ declare namespace WebSocket {
     perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined
     maxPayload?: number | undefined
     skipUTF8Validation?: boolean | undefined
+    WebSocket?: typeof WebSocket.WebSocket | undefined
   }
 
   interface AddressInfo {
@@ -424,10 +446,10 @@ declare namespace WebSocket {
   }
 
   // WebSocket Server
-  class Server extends EventEmitter {
+  class Server<T extends WebSocket = WebSocket> extends EventEmitter {
     options: ServerOptions
     path: string
-    clients: Set<WebSocket>
+    clients: Set<T>
 
     constructor(options?: ServerOptions, callback?: () => void)
 
@@ -437,56 +459,59 @@ declare namespace WebSocket {
       request: IncomingMessage,
       socket: Duplex,
       upgradeHead: Buffer,
-      callback: (client: WebSocket, request: IncomingMessage) => void
+      callback: (client: T, request: IncomingMessage) => void
     ): void
     shouldHandle(request: IncomingMessage): boolean | Promise<boolean>
 
     // Events
     on(
       event: 'connection',
-      cb: (this: Server, socket: WebSocket, request: IncomingMessage) => void
+      cb: (this: Server<T>, socket: T, request: IncomingMessage) => void
     ): this
-    on(event: 'error', cb: (this: Server, error: Error) => void): this
+    on(event: 'error', cb: (this: Server<T>, error: Error) => void): this
     on(
       event: 'headers',
-      cb: (this: Server, headers: string[], request: IncomingMessage) => void
+      cb: (this: Server<T>, headers: string[], request: IncomingMessage) => void
     ): this
-    on(event: 'close' | 'listening', cb: (this: Server) => void): this
+    on(event: 'close' | 'listening', cb: (this: Server<T>) => void): this
     on(
       event: string | symbol,
-      listener: (this: Server, ...args: any[]) => void
+      listener: (this: Server<T>, ...args: any[]) => void
     ): this
 
     once(
       event: 'connection',
-      cb: (this: Server, socket: WebSocket, request: IncomingMessage) => void
+      cb: (this: Server<T>, socket: T, request: IncomingMessage) => void
     ): this
-    once(event: 'error', cb: (this: Server, error: Error) => void): this
+    once(event: 'error', cb: (this: Server<T>, error: Error) => void): this
     once(
       event: 'headers',
-      cb: (this: Server, headers: string[], request: IncomingMessage) => void
+      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
-    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
+      cb: (this: Server<T>, socket: T, request: IncomingMessage) => void
     ): this
-    off(event: 'error', cb: (this: Server, error: Error) => void): this
+    off(event: 'error', cb: (this: Server<T>, error: Error) => void): this
     off(
       event: 'headers',
-      cb: (this: Server, headers: string[], request: IncomingMessage) => void
+      cb: (this: Server<T>, headers: string[], request: IncomingMessage) => void
     ): this
-    off(event: 'close' | 'listening', cb: (this: Server) => void): this
+    off(event: 'close' | 'listening', cb: (this: Server<T>) => void): this
     off(
       event: string | symbol,
-      listener: (this: Server, ...args: any[]) => void
+      listener: (this: Server<T>, ...args: any[]) => void
     ): this
 
     addListener(
       event: 'connection',
-      cb: (client: WebSocket, request: IncomingMessage) => void
+      cb: (client: T, request: IncomingMessage) => void
     ): this
     addListener(event: 'error', cb: (err: Error) => void): this
     addListener(
@@ -499,7 +524,7 @@ declare namespace WebSocket {
       listener: (...args: any[]) => void
     ): this
 
-    removeListener(event: 'connection', cb: (client: WebSocket) => void): this
+    removeListener(event: 'connection', cb: (client: T) => void): this
     removeListener(event: 'error', cb: (err: Error) => void): this
     removeListener(
       event: 'headers',
@@ -513,9 +538,9 @@ declare namespace WebSocket {
   }
 
   const WebSocketServer: typeof Server
-  type WebSocketServer = Server
+  interface WebSocketServer extends Server {} // tslint:disable-line no-empty-interface
   const WebSocket: typeof WebSocketAlias
-  type WebSocket = WebSocketAlias
+  interface WebSocket extends WebSocketAlias {} // tslint:disable-line no-empty-interface
 
   // WebSocket stream
   function createWebSocketStream(
@@ -524,5 +549,5 @@ declare namespace WebSocket {
   ): Duplex
 }
 
-//export = WebSocket;
+// export = WebSocket
 export { WebSocket, WebSocketAlias }