crossws 0.2.4 → 0.3.0

package/dist/adapters/node.d.cts

@@ -1,298 +0,0 @@
-import { A as AdapterOptions, b as Adapter } from '../shared/crossws.381454fe.cjs';
-import { IncomingMessage as IncomingMessage$1 } from 'node:http';
-import { Duplex as Duplex$1 } from 'node:stream';
-import { EventEmitter } from 'events';
-import { IncomingMessage, Server as Server$1, ClientRequestArgs, ClientRequest, OutgoingHttpHeaders, Agent } 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 extends EventEmitter {
-    static readonly createWebSocketStream: typeof createWebSocketStream;
-    static readonly WebSocketServer: WebSocketServer;
-    static readonly Server: typeof Server;
-    static readonly WebSocket: typeof WebSocket;
-    /** 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: 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, 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: 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: 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: 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: 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;
-}
-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<U extends typeof WebSocket = typeof 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;
-    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 = typeof 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;
-    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, options?: DuplexOptions): Duplex;
-
-interface NodeAdapter {
-    handleUpgrade(req: IncomingMessage$1, socket: Duplex$1, head: Buffer): void;
-}
-interface NodeOptions extends AdapterOptions {
-    wss?: WebSocketServer;
-    serverOptions?: ServerOptions;
-}
-declare const _default: Adapter<NodeAdapter, NodeOptions>;
-
-export { type NodeAdapter, type NodeOptions, _default as default };

package/dist/adapters/uws.cjs

@@ -1,153 +0,0 @@
-'use strict';
-
-const types = require('../shared/crossws.36b9e66f.cjs');
-
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-const uws = types.defineWebSocketAdapter(
-  (options = {}) => {
-    const crossws = types.createCrossWS(options);
-    const getPeer = (ws) => {
-      const userData = ws.getUserData();
-      if (userData._peer) {
-        return userData._peer;
-      }
-      const peer = new UWSPeer({ uws: { ws, userData } });
-      userData._peer = peer;
-      return peer;
-    };
-    const websocket = {
-      ...options.uws,
-      close(ws, code, message) {
-        const peer = getPeer(ws);
-        crossws.$callHook("uws:close", peer, ws, code, message);
-        crossws.callHook("close", peer, { code, reason: message?.toString() });
-      },
-      drain(ws) {
-        const peer = getPeer(ws);
-        crossws.$callHook("uws:drain", peer, ws);
-      },
-      message(ws, message, isBinary) {
-        const peer = getPeer(ws);
-        crossws.$callHook("uws:message", peer, ws, message, isBinary);
-        const msg = new types.Message(message, isBinary);
-        crossws.callHook("message", peer, msg);
-      },
-      open(ws) {
-        const peer = getPeer(ws);
-        crossws.$callHook("uws:open", peer, ws);
-        crossws.callHook("open", peer);
-      },
-      ping(ws, message) {
-        const peer = getPeer(ws);
-        crossws.$callHook("uws:ping", peer, ws, message);
-      },
-      pong(ws, message) {
-        const peer = getPeer(ws);
-        crossws.$callHook("uws:pong", peer, ws, message);
-      },
-      subscription(ws, topic, newCount, oldCount) {
-        const peer = getPeer(ws);
-        crossws.$callHook(
-          "uws:subscription",
-          peer,
-          ws,
-          topic,
-          newCount,
-          oldCount
-        );
-      },
-      async upgrade(res, req, context) {
-        let aborted = false;
-        res.onAborted(() => {
-          aborted = true;
-        });
-        const { headers } = await crossws.upgrade({
-          get url() {
-            return req.getUrl();
-          },
-          get headers() {
-            return _getHeaders(req);
-          }
-        });
-        res.writeStatus("101 Switching Protocols");
-        for (const [key, value] of new Headers(headers)) {
-          res.writeHeader(key, value);
-        }
-        if (aborted) {
-          return;
-        }
-        res.cork(() => {
-          res.upgrade(
-            {
-              req,
-              res,
-              context
-            },
-            req.getHeader("sec-websocket-key"),
-            req.getHeader("sec-websocket-protocol"),
-            req.getHeader("sec-websocket-extensions"),
-            context
-          );
-        });
-      }
-    };
-    return {
-      websocket
-    };
-  }
-);
-class UWSPeer extends types.Peer {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "_headers");
-    __publicField(this, "_decoder", new TextDecoder());
-  }
-  get addr() {
-    try {
-      const addr = this._decoder.decode(
-        this.ctx.uws.ws?.getRemoteAddressAsText()
-      );
-      return addr.replace(/(0000:)+/, "");
-    } catch {
-    }
-  }
-  // TODO
-  // get readyState() {}
-  get url() {
-    return this.ctx.uws.userData.req.getUrl();
-  }
-  get headers() {
-    if (!this._headers) {
-      this._headers = _getHeaders(this.ctx.uws.userData.req);
-    }
-    return this._headers;
-  }
-  send(message, options) {
-    return this.ctx.uws.ws.send(
-      types.toBufferLike(message),
-      options?.binary,
-      options?.compress
-    );
-  }
-  subscribe(topic) {
-    this.ctx.uws.ws.subscribe(topic);
-  }
-  publish(topic, message, options) {
-    this.ctx.uws.ws.publish(topic, message, options?.binary, options?.compress);
-    return 0;
-  }
-}
-function _getHeaders(req) {
-  const headers = [];
-  req.forEach((key, value) => {
-    headers.push([key, value]);
-  });
-  return headers;
-}
-
-module.exports = uws;

package/dist/adapters/uws.d.cts

@@ -1,19 +0,0 @@
-import { A as AdapterOptions, b as Adapter } from '../shared/crossws.381454fe.cjs';
-import { WebSocketBehavior, HttpRequest, HttpResponse } from 'uWebSockets.js';
-
-type UserData = {
-    _peer?: any;
-    req: HttpRequest;
-    res: HttpResponse;
-    context: any;
-};
-type WebSocketHandler = WebSocketBehavior<UserData>;
-interface UWSAdapter {
-    websocket: WebSocketHandler;
-}
-interface UWSOptions extends AdapterOptions {
-    uws?: Exclude<WebSocketBehavior<any>, "close" | "drain" | "message" | "open" | "ping" | "pong" | "subscription" | "upgrade">;
-}
-declare const _default: Adapter<UWSAdapter, UWSOptions>;
-
-export { type UWSAdapter, type UWSOptions, _default as default };

package/dist/index.cjs

@@ -1,17 +0,0 @@
-'use strict';
-
-const types = require('./shared/crossws.36b9e66f.cjs');
-
-class WSError extends Error {
-  constructor(...args) {
-    super(...args);
-    this.name = "WSError";
-  }
-}
-
-exports.Message = types.Message;
-exports.Peer = types.Peer;
-exports.createCrossWS = types.createCrossWS;
-exports.defineHooks = types.defineHooks;
-exports.defineWebSocketAdapter = types.defineWebSocketAdapter;
-exports.WSError = WSError;

package/dist/index.d.cts

@@ -1,6 +0,0 @@
-import { A as AdapterOptions, C as CrossWS } from './shared/crossws.381454fe.cjs';
-export { b as Adapter, f as AdapterHooks, a as Caller, H as Hooks, M as Message, P as Peer, R as ResolveHooks, W as WSError, c as WSRequest, e as defineHooks, d as defineWebSocketAdapter } from './shared/crossws.381454fe.cjs';
-
-declare function createCrossWS(opts?: AdapterOptions): CrossWS;
-
-export { AdapterOptions, CrossWS, createCrossWS };