crossws 0.0.0 → 0.0.1

package/dist/adapters/node.d.ts

@@ -0,0 +1,299 @@
+import { WebSocketAdapter } from '../index.js';
+import { IncomingMessage as IncomingMessage$1 } from 'node:http';
+import { Duplex as Duplex$1 } from 'node:stream';
+import { EventEmitter } from 'events';
+import { ClientRequestArgs, IncomingMessage, ClientRequest, Agent, Server as Server$1, OutgoingHttpHeaders } from 'http';
+import { Server as Server$2 } from 'https';
+import { Duplex, DuplexOptions } from 'stream';
+import { SecureContextOptions } from 'tls';
+import { URL } from 'url';
+import { ZlibOptions } from 'zlib';
+
+type BufferLike = string | Buffer | DataView | number | ArrayBufferView | Uint8Array | ArrayBuffer | SharedArrayBuffer | readonly any[] | readonly number[] | {
+    valueOf(): ArrayBuffer;
+} | {
+    valueOf(): SharedArrayBuffer;
+} | {
+    valueOf(): Uint8Array;
+} | {
+    valueOf(): readonly number[];
+} | {
+    valueOf(): string;
+} | {
+    [Symbol.toPrimitive](hint: string): string;
+};
+declare class WebSocket$1 extends EventEmitter {
+    static readonly createWebSocketStream: typeof createWebSocketStream;
+    static readonly WebSocketServer: WebSocketServer;
+    static readonly Server: typeof Server;
+    static readonly WebSocket: typeof WebSocket$1;
+    /** 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: Event) => void) | null;
+    onerror: ((event: ErrorEvent) => void) | null;
+    onclose: ((event: CloseEvent) => void) | null;
+    onmessage: ((event: MessageEvent) => void) | null;
+    constructor(address: null);
+    constructor(address: string | URL, options?: ClientOptions | ClientRequestArgs);
+    constructor(address: string | URL, protocols?: string | string[], options?: 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: 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;
+    addEventListener(method: "message", cb: (event: MessageEvent) => void, options?: EventListenerOptions): void;
+    addEventListener(method: "close", cb: (event: CloseEvent) => void, options?: EventListenerOptions): void;
+    addEventListener(method: "error", cb: (event: ErrorEvent) => void, options?: EventListenerOptions): void;
+    addEventListener(method: "open", cb: (event: Event) => void, options?: EventListenerOptions): void;
+    removeEventListener(method: "message", cb: (event: MessageEvent) => void): void;
+    removeEventListener(method: "close", cb: (event: CloseEvent) => void): void;
+    removeEventListener(method: "error", cb: (event: ErrorEvent) => void): void;
+    removeEventListener(method: "open", cb: (event: Event) => void): void;
+    on(event: "close", listener: (this: WebSocket$1, code: number, reason: Buffer) => void): this;
+    on(event: "error", listener: (this: WebSocket$1, err: Error) => void): this;
+    on(event: "upgrade", listener: (this: WebSocket$1, request: IncomingMessage) => void): this;
+    on(event: "message", listener: (this: WebSocket$1, data: 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;
+    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, err: Error) => void): this;
+    once(event: "upgrade", listener: (this: WebSocket$1, request: IncomingMessage) => void): this;
+    once(event: "message", listener: (this: WebSocket$1, data: 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: "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, err: Error) => void): this;
+    off(event: "upgrade", listener: (this: WebSocket$1, request: IncomingMessage) => void): this;
+    off(event: "message", listener: (this: WebSocket$1, data: 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: "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: (err: Error) => void): this;
+    addListener(event: "upgrade", listener: (request: IncomingMessage) => void): this;
+    addListener(event: "message", listener: (data: 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: 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;
+}
+/**
+ * Data represents the raw message payload received over the
+ */
+type RawData = Buffer | ArrayBuffer | Buffer[];
+/**
+ * Data represents the message payload received over the
+ */
+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;
+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$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 EventListenerOptions {
+    once?: boolean | undefined;
+}
+interface ServerOptions<U extends typeof WebSocket$1 = typeof WebSocket$1, 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;
+    clientTracking?: boolean | undefined;
+    perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined;
+    maxPayload?: number | undefined;
+    skipUTF8Validation?: boolean | undefined;
+    WebSocket?: U | undefined;
+}
+interface AddressInfo {
+    address: string;
+    family: string;
+    port: number;
+}
+declare class Server<T extends typeof WebSocket$1 = typeof WebSocket$1, 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;
+    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>;
+    on(event: "connection", cb: (this: Server<T>, socket: 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: string | symbol, listener: (this: Server<T>, ...args: any[]) => void): this;
+    once(event: "connection", cb: (this: Server<T>, socket: 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: 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: string | symbol, listener: (this: Server<T>, ...args: any[]) => void): this;
+    addListener(event: "connection", cb: (client: InstanceType<T>, request: InstanceType<U>) => void): this;
+    addListener(event: "error", cb: (err: Error) => void): this;
+    addListener(event: "headers", cb: (headers: string[], request: InstanceType<U>) => void): this;
+    addListener(event: "close" | "listening", cb: () => void): this;
+    addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+    removeListener(event: "connection", cb: (client: InstanceType<T>, request: InstanceType<U>) => void): this;
+    removeListener(event: "error", cb: (err: Error) => void): this;
+    removeListener(event: "headers", cb: (headers: string[], request: InstanceType<U>) => void): this;
+    removeListener(event: "close" | "listening", cb: () => void): this;
+    removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+}
+type WebSocketServer = Server;
+declare function createWebSocketStream(websocket: WebSocket$1, options?: DuplexOptions): Duplex;
+
+declare const WebSocket: WebSocket$1;
+interface AdapterOptions {
+    wss?: WebSocketServer;
+    serverOptions?: ServerOptions;
+}
+interface Adapter {
+    handleUpgrade(req: IncomingMessage$1, socket: Duplex$1, head: Buffer): void;
+}
+declare const _default: WebSocketAdapter<Adapter, AdapterOptions>;
+
+export { type Adapter, type AdapterOptions, WebSocket, _default as default };