ventiws 1.0.0-alpha

package/dist/index.d.cts

@@ -0,0 +1,400 @@
+/// <reference types="node" />
+import { EventEmitter } from "node:events";
+import { Agent, ClientRequest, ClientRequestArgs, IncomingMessage, OutgoingHttpHeaders, Server as Server$1 } from "node:http";
+import { Server as Server$2 } from "node:https";
+import { createConnection } from "node:net";
+import { Duplex, DuplexOptions } from "node:stream";
+import { SecureContextOptions } from "node:tls";
+import { URL } from "node:url";
+import { ZlibOptions } from "node:zlib";
+declare namespace ws_d_exports {
+  export { AddressInfo, CertMeta, ClientOptions, CloseEvent, Data, ErrorEvent, Event, EventListenerOptions, FinishRequestCallback, MessageEvent, PerMessageDeflateOptions, RawData, Server, ServerOptions, VerifyClientCallbackAsync, VerifyClientCallbackSync, WebSocket$1 as WebSocket, WebSocketEventMap, WebSocketServer$1 as WebSocketServer, createWebSocketStream$1 as createWebSocketStream, WebSocket$1 as default };
+}
+// can not get all overload of BufferConstructor['from'], need to copy all it's first arguments here
+// https://github.com/microsoft/TypeScript/issues/32164
+type BufferLike = string | Buffer | DataView | number | ArrayBufferView | Uint8Array | ArrayBuffer | SharedArrayBuffer | Blob | readonly any[] | readonly number[] | {
+  valueOf(): ArrayBuffer;
+} | {
+  valueOf(): SharedArrayBuffer;
+} | {
+  valueOf(): Uint8Array;
+} | {
+  valueOf(): readonly number[];
+} | {
+  valueOf(): string;
+} | {
+  [Symbol.toPrimitive](hint: string): string;
+};
+// WebSocket socket.
+declare class WebSocket$1 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$1.CONNECTING | typeof WebSocket$1.OPEN | typeof WebSocket$1.CLOSING | typeof WebSocket$1.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$1.Event) => void) | null;
+  onerror: ((event: WebSocket$1.ErrorEvent) => void) | null;
+  onclose: ((event: WebSocket$1.CloseEvent) => void) | null;
+  onmessage: ((event: WebSocket$1.MessageEvent) => void) | null;
+  constructor(address: null);
+  constructor(address: string | URL, options?: WebSocket$1.ClientOptions | ClientRequestArgs);
+  constructor(address: string | URL, protocols?: string | string[], options?: WebSocket$1.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;
+  // https://github.com/websockets/ws/issues/2076#issuecomment-1250354722
+  send(data: BufferLike, cb?: (err?: Error) => void): void;
+  send(data: BufferLike, 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<K extends keyof WebSocket$1.WebSocketEventMap>(type: K, listener: ((event: WebSocket$1.WebSocketEventMap[K]) => void) | {
+    handleEvent(event: WebSocket$1.WebSocketEventMap[K]): void;
+  }, options?: WebSocket$1.EventListenerOptions): void;
+  removeEventListener<K extends keyof WebSocket$1.WebSocketEventMap>(type: K, listener: ((event: WebSocket$1.WebSocketEventMap[K]) => void) | {
+    handleEvent(event: WebSocket$1.WebSocketEventMap[K]): void;
+  }): void;
+  // Events
+  on(event: "close", listener: (this: WebSocket$1, code: number, reason: Buffer) => void): this;
+  on(event: "error", listener: (this: WebSocket$1, error: Error) => void): this;
+  on(event: "upgrade", listener: (this: WebSocket$1, request: IncomingMessage) => void): this;
+  on(event: "message", listener: (this: WebSocket$1, data: WebSocket$1.RawData, isBinary: boolean) => void): this;
+  on(event: "open", listener: (this: WebSocket$1) => void): this;
+  on(event: "ping" | "pong", listener: (this: WebSocket$1, data: Buffer) => void): this;
+  // Narrowed from @types/ws: this client owns a `net.Socket` rather than an
+  // `http.ClientRequest`, so there is no request object to hand a listener. The URL and
+  // the status are what a caller needs in order to decide, and `close()` is how it
+  // declines. See `docs/compliance-api.md`.
+  on(event: "redirect", listener: (this: WebSocket$1, url: string, request: ClientRequest) => void): this;
+  on(event: "unexpected-response", listener: (this: WebSocket$1, request: ClientRequest, response: IncomingMessage) => void): this;
+  on(event: string | symbol, listener: (this: WebSocket$1, ...args: any[]) => void): this;
+  once(event: "close", listener: (this: WebSocket$1, code: number, reason: Buffer) => void): this;
+  once(event: "error", listener: (this: WebSocket$1, error: Error) => void): this;
+  once(event: "upgrade", listener: (this: WebSocket$1, request: IncomingMessage) => void): this;
+  once(event: "message", listener: (this: WebSocket$1, data: WebSocket$1.RawData, isBinary: boolean) => void): this;
+  once(event: "open", listener: (this: WebSocket$1) => void): this;
+  once(event: "ping" | "pong", listener: (this: WebSocket$1, data: Buffer) => void): this;
+  once(event: "redirect", listener: (this: WebSocket$1, url: string, request: ClientRequest) => void): this;
+  once(event: "unexpected-response", listener: (this: WebSocket$1, request: ClientRequest, response: IncomingMessage) => void): this;
+  once(event: string | symbol, listener: (this: WebSocket$1, ...args: any[]) => void): this;
+  off(event: "close", listener: (this: WebSocket$1, code: number, reason: Buffer) => void): this;
+  off(event: "error", listener: (this: WebSocket$1, error: Error) => void): this;
+  off(event: "upgrade", listener: (this: WebSocket$1, request: IncomingMessage) => void): this;
+  off(event: "message", listener: (this: WebSocket$1, data: WebSocket$1.RawData, isBinary: boolean) => void): this;
+  off(event: "open", listener: (this: WebSocket$1) => void): this;
+  off(event: "ping" | "pong", listener: (this: WebSocket$1, data: Buffer) => void): this;
+  off(event: "redirect", listener: (this: WebSocket$1, url: string, request: ClientRequest) => void): this;
+  off(event: "unexpected-response", listener: (this: WebSocket$1, request: ClientRequest, response: IncomingMessage) => void): this;
+  off(event: string | symbol, listener: (this: WebSocket$1, ...args: any[]) => void): this;
+  addListener(event: "close", listener: (code: number, reason: Buffer) => void): this;
+  addListener(event: "error", listener: (error: Error) => void): this;
+  addListener(event: "upgrade", listener: (request: IncomingMessage) => void): this;
+  addListener(event: "message", listener: (data: WebSocket$1.RawData, isBinary: boolean) => void): this;
+  addListener(event: "open", listener: () => void): this;
+  addListener(event: "ping" | "pong", listener: (data: Buffer) => void): this;
+  addListener(event: "redirect", listener: (url: string, request: ClientRequest) => 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: (error: Error) => void): this;
+  removeListener(event: "upgrade", listener: (request: IncomingMessage) => void): this;
+  removeListener(event: "message", listener: (data: WebSocket$1.RawData, isBinary: boolean) => void): this;
+  removeListener(event: "open", listener: () => void): this;
+  removeListener(event: "ping" | "pong", listener: (data: Buffer) => void): this;
+  removeListener(event: "redirect", listener: (url: string, request: ClientRequest) => 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$1;
+interface WebSocketAlias extends WebSocket$1 {} // eslint-disable-line @typescript-eslint/no-empty-interface
+declare namespace WebSocket$1 {
+  /**
+   * 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<Request extends IncomingMessage = IncomingMessage> = (info: {
+    origin: string;
+    secure: boolean;
+    req: Request;
+  }) => 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<Request extends IncomingMessage = IncomingMessage> = (info: {
+    origin: string;
+    secure: boolean;
+    req: Request;
+  }, callback: (res: boolean, code?: number, message?: string, headers?: OutgoingHttpHeaders) => void) => void;
+  /**
+   * FinishRequestCallback is a callback for last minute customization of the
+   * headers. If finishRequest is set, then it has the responsibility to call
+   * request.end() once it is done setting request headers.
+   */
+  type FinishRequestCallback = (request: ClientRequest, websocket: WebSocket$1) => 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;
+    allowSynchronousEvents?: boolean | undefined;
+    autoPong?: boolean | undefined;
+    maxPayload?: number | undefined;
+    skipUTF8Validation?: boolean | undefined;
+    createConnection?: typeof createConnection | undefined;
+    finishRequest?: FinishRequestCallback | 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$1;
+  }
+  interface ErrorEvent {
+    error: any;
+    message: string;
+    type: string;
+    target: WebSocket$1;
+  }
+  interface CloseEvent {
+    wasClean: boolean;
+    code: number;
+    reason: string;
+    type: string;
+    target: WebSocket$1;
+  }
+  interface MessageEvent {
+    data: Data;
+    type: string;
+    target: WebSocket$1;
+  }
+  interface WebSocketEventMap {
+    open: Event;
+    error: ErrorEvent;
+    close: CloseEvent;
+    message: MessageEvent;
+  }
+  interface EventListenerOptions {
+    once?: boolean | undefined;
+  }
+  interface ServerOptions<U extends typeof WebSocket$1.WebSocket = typeof WebSocket$1.WebSocket, V extends typeof IncomingMessage = typeof IncomingMessage> {
+    host?: string | undefined;
+    port?: number | undefined;
+    backlog?: number | undefined;
+    server?: Server$1<V> | Server$2<V> | undefined;
+    verifyClient?: VerifyClientCallbackAsync<InstanceType<V>> | VerifyClientCallbackSync<InstanceType<V>> | undefined;
+    handleProtocols?: (protocols: Set<string>, request: InstanceType<V>) => string | false;
+    path?: string | undefined;
+    noServer?: boolean | undefined;
+    allowSynchronousEvents?: boolean | undefined;
+    autoPong?: boolean | undefined;
+    clientTracking?: boolean | undefined;
+    perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined;
+    maxPayload?: number | undefined;
+    skipUTF8Validation?: boolean | undefined;
+    WebSocket?: U | undefined;
+  }
+  interface AddressInfo {
+    address: string;
+    family: string;
+    port: number;
+  }
+  // WebSocket Server
+  class Server<T extends typeof WebSocket$1.WebSocket = typeof WebSocket$1.WebSocket, U extends typeof IncomingMessage = typeof IncomingMessage> extends EventEmitter {
+    options: ServerOptions<T, U>;
+    path: string;
+    clients: Set<InstanceType<T>>;
+    constructor(options?: ServerOptions<T, U>, callback?: () => void);
+    address(): AddressInfo | string | null;
+    close(cb?: (err?: Error) => void): void;
+    handleUpgrade(request: InstanceType<U>, socket: Duplex, upgradeHead: Buffer, callback: (client: InstanceType<T>, request: InstanceType<U>) => void): void;
+    shouldHandle(request: InstanceType<U>): boolean | Promise<boolean>;
+    // Events
+    on(event: "connection", cb: (this: Server<T>, websocket: InstanceType<T>, request: InstanceType<U>) => void): this;
+    on(event: "error", cb: (this: Server<T>, error: Error) => void): this;
+    on(event: "headers", cb: (this: Server<T>, headers: string[], request: InstanceType<U>) => void): this;
+    on(event: "close" | "listening", cb: (this: Server<T>) => void): this;
+    on(event: "wsClientError", cb: (this: Server<T>, error: Error, socket: Duplex, request: InstanceType<U>) => void): this;
+    on(event: string | symbol, listener: (this: Server<T>, ...args: any[]) => void): this;
+    once(event: "connection", cb: (this: Server<T>, websocket: InstanceType<T>, request: InstanceType<U>) => void): this;
+    once(event: "error", cb: (this: Server<T>, error: Error) => void): this;
+    once(event: "headers", cb: (this: Server<T>, headers: string[], request: InstanceType<U>) => void): this;
+    once(event: "close" | "listening", cb: (this: Server<T>) => void): this;
+    once(event: "wsClientError", cb: (this: Server<T>, error: Error, socket: Duplex, request: InstanceType<U>) => void): this;
+    once(event: string | symbol, listener: (this: Server<T>, ...args: any[]) => void): this;
+    off(event: "connection", cb: (this: Server<T>, socket: InstanceType<T>, request: InstanceType<U>) => void): this;
+    off(event: "error", cb: (this: Server<T>, error: Error) => void): this;
+    off(event: "headers", cb: (this: Server<T>, headers: string[], request: InstanceType<U>) => void): this;
+    off(event: "close" | "listening", cb: (this: Server<T>) => void): this;
+    off(event: "wsClientError", cb: (this: Server<T>, error: Error, socket: Duplex, request: InstanceType<U>) => void): this;
+    off(event: string | symbol, listener: (this: Server<T>, ...args: any[]) => void): this;
+    addListener(event: "connection", cb: (websocket: InstanceType<T>, request: InstanceType<U>) => void): this;
+    addListener(event: "error", cb: (error: Error) => void): this;
+    addListener(event: "headers", cb: (headers: string[], request: InstanceType<U>) => void): this;
+    addListener(event: "close" | "listening", cb: () => void): this;
+    addListener(event: "wsClientError", cb: (error: Error, socket: Duplex, request: InstanceType<U>) => void): this;
+    addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+    removeListener(event: "connection", cb: (websocket: InstanceType<T>, request: InstanceType<U>) => void): this;
+    removeListener(event: "error", cb: (error: Error) => void): this;
+    removeListener(event: "headers", cb: (headers: string[], request: InstanceType<U>) => void): this;
+    removeListener(event: "close" | "listening", cb: () => void): this;
+    removeListener(event: "wsClientError", cb: (error: Error, socket: Duplex, request: InstanceType<U>) => void): this;
+    removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+  }
+  const WebSocketServer: typeof Server;
+  interface WebSocketServer extends Server {} // eslint-disable-line @typescript-eslint/no-empty-interface
+  const WebSocket: typeof WebSocketAlias;
+  interface WebSocket extends WebSocketAlias {} // eslint-disable-line @typescript-eslint/no-empty-interface
+  // WebSocket stream
+  function createWebSocketStream(websocket: WebSocket$1, options?: DuplexOptions): Duplex;
+}
+type Server<T extends typeof WebSocket$1.WebSocket = typeof WebSocket$1.WebSocket, U extends typeof IncomingMessage = typeof IncomingMessage> = WebSocket$1.Server<T, U>;
+type RawData = WebSocket$1.RawData;
+type Data = WebSocket$1.Data;
+type CertMeta = WebSocket$1.CertMeta;
+type VerifyClientCallbackSync<Request extends IncomingMessage = IncomingMessage> = WebSocket$1.VerifyClientCallbackSync<Request>;
+type VerifyClientCallbackAsync<Request extends IncomingMessage = IncomingMessage> = WebSocket$1.VerifyClientCallbackAsync<Request>;
+type FinishRequestCallback = WebSocket$1.FinishRequestCallback;
+type ClientOptions = WebSocket$1.ClientOptions;
+type PerMessageDeflateOptions = WebSocket$1.PerMessageDeflateOptions;
+type Event = WebSocket$1.Event;
+type ErrorEvent = WebSocket$1.ErrorEvent;
+type CloseEvent = WebSocket$1.CloseEvent;
+type MessageEvent = WebSocket$1.MessageEvent;
+type WebSocketEventMap = WebSocket$1.WebSocketEventMap;
+type EventListenerOptions = WebSocket$1.EventListenerOptions;
+type ServerOptions<U extends typeof WebSocket$1.WebSocket = typeof WebSocket$1.WebSocket, V extends typeof IncomingMessage = typeof IncomingMessage> = WebSocket$1.ServerOptions<U, V>;
+type AddressInfo = WebSocket$1.AddressInfo;
+type WebSocketServer$1 = WebSocket$1.WebSocketServer;
+// Type-level parity with upstream's ESM entry; the runtime value lands with
+// the compat factory.
+type createWebSocketStream$1 = typeof WebSocket$1.createWebSocketStream;
+//#endregion
+//#region src/compat/stream.d.ts
+export declare function createWebSocketStream(ws: WebSocket$1, options?: DuplexOptions): Duplex;
+//#endregion
+//#region src/compat/constructors.d.ts
+type SocketConstructor = typeof WebSocket$1;
+type ServerConstructor = typeof WebSocket$1.WebSocketServer;
+declare const WebSocket: SocketConstructor;
+type WebSocket = WebSocket$1;
+declare const WebSocketServer: ServerConstructor;
+type WebSocketServer = WebSocketServer$1;
+declare namespace WebSocket {
+  type RawData = WebSocket$1.RawData;
+  type Data = WebSocket$1.Data;
+  type CertMeta = WebSocket$1.CertMeta;
+  type VerifyClientCallbackSync<Request extends IncomingMessage = IncomingMessage> = WebSocket$1.VerifyClientCallbackSync<Request>;
+  type VerifyClientCallbackAsync<Request extends IncomingMessage = IncomingMessage> = WebSocket$1.VerifyClientCallbackAsync<Request>;
+  type FinishRequestCallback = WebSocket$1.FinishRequestCallback;
+  type ClientOptions = WebSocket$1.ClientOptions;
+  type PerMessageDeflateOptions = WebSocket$1.PerMessageDeflateOptions;
+  type Event = WebSocket$1.Event;
+  type ErrorEvent = WebSocket$1.ErrorEvent;
+  type CloseEvent = WebSocket$1.CloseEvent;
+  type MessageEvent = WebSocket$1.MessageEvent;
+  type WebSocketEventMap = WebSocket$1.WebSocketEventMap;
+  type EventListenerOptions = WebSocket$1.EventListenerOptions;
+  type ServerOptions<U extends typeof WebSocket$1 = typeof WebSocket$1, V extends typeof IncomingMessage = typeof IncomingMessage> = WebSocket$1.ServerOptions<U, V>;
+  type AddressInfo = WebSocket$1.AddressInfo;
+  type Server<T extends typeof WebSocket$1 = typeof WebSocket$1, U extends typeof IncomingMessage = typeof IncomingMessage> = WebSocket$1.Server<T, U>;
+  type WebSocketServer = WebSocketServer$1;
+  type WebSocket = WebSocket$1;
+  type createWebSocketStream = typeof WebSocket$1.createWebSocketStream;
+}
+//#endregion
+//#region src/binding/native-limits.d.ts
+type NativeEngineLimits = {
+  readonly connectionCapacity: number;
+  readonly messageBytes: number;
+  readonly frameBytes: number;
+  readonly inboundSlots: number;
+  readonly outboundSlots: number;
+  readonly maxFragments: number;
+  readonly maxPayloadBytes: number;
+};
+//#endregion
+//#region src/binding/server.d.ts
+export declare function engineLimits(): NativeEngineLimits;
+//#endregion
+export { type AddressInfo, type CertMeta, type ClientOptions, type CloseEvent, type Data, type NativeEngineLimits as EngineLimits, type ErrorEvent, type Event, type EventListenerOptions, type FinishRequestCallback, type MessageEvent, type PerMessageDeflateOptions, type RawData, type Server, type ServerOptions, type VerifyClientCallbackAsync, type VerifyClientCallbackSync, WebSocket, WebSocket as default, type WebSocketEventMap, WebSocketServer };