redweb-client 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -1,130 +1,5 @@
-type ClientState = 'idle' | 'connecting' | 'open' | 'reconnecting' | 'closing' | 'closed';
-interface ProtocolMetadata {
-    requestId?: string;
-    sequence?: number;
-}
-interface ProtocolEnvelope<T = unknown> extends ProtocolMetadata {
-    v: string;
-    type: string;
-    payload: T;
-}
-interface ProtocolErrorEnvelope extends ProtocolMetadata {
-    v: string;
-    type: 'error';
-    error: {
-        code: string;
-        message: string;
-    };
-}
-interface LegacyErrorMessage extends ProtocolMetadata {
-    error: string;
-    type?: never;
-}
-type RedwebMessage<T = unknown> = ProtocolEnvelope<T> | ProtocolErrorEnvelope | LegacyErrorMessage | ({
-    type: string;
-    requestId?: string;
-    sequence?: number;
-} & Record<string, unknown>);
-interface SocketEventLike {
-    data?: unknown;
-    code?: number;
-    reason?: string;
-    wasClean?: boolean;
-    error?: unknown;
-}
-interface WebSocketLike {
-    readonly readyState: number;
-    binaryType?: string;
-    send(data: string | ArrayBufferLike | ArrayBufferView | Blob): void;
-    close(code?: number, reason?: string): void;
-    addEventListener(type: 'open' | 'message' | 'error' | 'close', listener: (event: SocketEventLike) => void): void;
-    removeEventListener(type: 'open' | 'message' | 'error' | 'close', listener: (event: SocketEventLike) => void): void;
-}
-interface ReconnectOptions {
-    enabled?: boolean;
-    maxAttempts?: number;
-    initialDelayMs?: number;
-    maxDelayMs?: number;
-    factor?: number;
-    jitter?: number;
-    shouldReconnect?: (event: SocketEventLike) => boolean;
-}
-interface RedwebClientOptions {
-    version?: string;
-    reconnect?: ReconnectOptions;
-    maxQueueSize?: number;
-    requestTimeoutMs?: number;
-    webSocketFactory?: (url: string) => WebSocketLike;
-    createRequestId?: () => string;
-    baseUrl?: string | URL;
-    random?: () => number;
-}
-interface RequestOptions extends ProtocolMetadata {
-    timeoutMs?: number;
-    signal?: AbortSignal;
-}
-interface WaitOptions {
-    timeoutMs?: number;
-    signal?: AbortSignal;
-}
-type MessageListener<T = unknown> = (message: RedwebMessage<T>) => void;
-type BinaryListener = (data: ArrayBuffer | ArrayBufferView | Blob) => void;
-type ErrorListener = (error: Error) => void;
-type StateListener = (state: ClientState) => void;
-type CloseListener = (event: SocketEventLike) => void;
-
-declare class RedwebClient<IncomingEvents extends object = Record<string, unknown>, OutgoingEvents extends object = Record<string, unknown>> {
-    readonly url: string;
-    readonly version: string | undefined;
-    state: ClientState;
-    socket: WebSocketLike | undefined;
-    private readonly factory;
-    private readonly reconnect;
-    private readonly maxQueueSize;
-    private readonly requestTimeoutMs;
-    private readonly createRequestId;
-    private readonly random;
-    private readonly listeners;
-    private readonly anyListeners;
-    private readonly binaryListeners;
-    private readonly errorListeners;
-    private readonly stateListeners;
-    private readonly closeListeners;
-    private readonly queue;
-    private readonly pending;
-    private connectPromise;
-    private reconnectTimer;
-    private reconnectAttempts;
-    private manualClose;
-    private disposed;
-    private requestSequence;
-    constructor(url: string, options?: RedwebClientOptions);
-    connect(): Promise<void>;
-    private openSocket;
-    close(code?: number, reason?: string): void;
-    dispose(): void;
-    send<K extends keyof OutgoingEvents & string>(type: K, payload: OutgoingEvents[K], metadata?: ProtocolMetadata): void;
-    sendRaw(data: string | ArrayBufferLike | ArrayBufferView | Blob): void;
-    private transmit;
-    request<TResponse = unknown, TPayload = unknown>(type: string, payload: TPayload, options?: RequestOptions): Promise<RedwebMessage<TResponse>>;
-    waitFor<K extends keyof IncomingEvents & string>(type: K, options?: WaitOptions): Promise<RedwebMessage<IncomingEvents[K]>>;
-    on<K extends keyof IncomingEvents & string>(type: K, listener: MessageListener<IncomingEvents[K]>): () => void;
-    onAny(listener: MessageListener): () => void;
-    onBinary(listener: BinaryListener): () => void;
-    onError(listener: ErrorListener): () => void;
-    onStateChange(listener: StateListener): () => void;
-    onClose(listener: CloseListener): () => void;
-    private subscribe;
-    private connectionUrl;
-    private transition;
-    private handleIncoming;
-    private finishPending;
-    private rejectPending;
-    private emitError;
-    private notify;
-    private flushQueue;
-    private scheduleReconnect;
-}
+import { P as ProtocolErrorEnvelope, a as ProtocolMetadata, R as RedwebMessage, b as ProtocolEnvelope } from './client-Dq8oKJwh.js';
+export { B as BinaryListener, C as ClientState, c as CloseListener, E as ErrorListener, L as LegacyErrorMessage, M as MessageListener, d as ReconnectOptions, e as RedwebClient, f as RedwebClientOptions, g as RequestOptions, S as SocketEventLike, h as StateListener, W as WaitOptions, i as WebSocketLike } from './client-Dq8oKJwh.js';
 
 declare const ERROR_CODES: Readonly<{
     readonly INVALID_MESSAGE: "INVALID_MESSAGE";
@@ -146,4 +21,4 @@ declare class RedwebProtocolError extends Error {
     constructor(envelope: ProtocolErrorEnvelope);
 }
 
-export { type BinaryListener, type ClientState, type CloseListener, ERROR_CODES, type ErrorListener, type LegacyErrorMessage, type MessageListener, type ProtocolEnvelope, type ProtocolErrorEnvelope, type ProtocolMetadata, type ReconnectOptions, RedwebClient, type RedwebClientOptions, type RedwebMessage, RedwebProtocolError, type RequestOptions, type SocketEventLike, type StateListener, type WaitOptions, type WebSocketLike, createLegacyEnvelope, createProtocolEnvelope, parseMessage, resolveWebSocketUrl };
+export { ERROR_CODES, ProtocolEnvelope, ProtocolErrorEnvelope, ProtocolMetadata, RedwebMessage, RedwebProtocolError, createLegacyEnvelope, createProtocolEnvelope, parseMessage, resolveWebSocketUrl };

package/dist/index.js

@@ -146,6 +146,7 @@ var RedwebClient = class {
   manualClose = false;
   disposed = false;
   requestSequence = 0;
+  generation = 0;
   constructor(url, options = {}) {
     this.url = resolveWebSocketUrl(url, options.baseUrl);
     const queryVersion = new URL(this.url).searchParams.get("redwebVersion") ?? void 0;
@@ -184,27 +185,51 @@ var RedwebClient = class {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = void 0;
     }
-    this.connectPromise = this.openSocket(false).finally(() => {
-      this.connectPromise = void 0;
+    let resolve;
+    let reject;
+    const promise = new Promise((yes, no) => {
+      resolve = yes;
+      reject = no;
     });
-    return this.connectPromise;
+    this.connectPromise = promise;
+    const finish = () => this.retire(promise);
+    void this.openSocket(false).then(() => {
+      finish();
+      resolve();
+    }, (error) => {
+      finish();
+      reject(error);
+    });
+    return promise;
+  }
+  current(generation) {
+    return this.generation === generation && !this.manualClose && !this.disposed;
+  }
+  retire(promise) {
+    if (this.connectPromise === promise) this.connectPromise = void 0;
   }
   openSocket(reconnecting) {
+    const opening = this.connectPromise;
+    const generation = ++this.generation;
     this.transition(reconnecting ? "reconnecting" : "connecting");
+    if (!this.current(generation)) return Promise.reject(new Error("WebSocket connection attempt was cancelled."));
     let socket;
     try {
       socket = this.factory(this.connectionUrl());
     } catch (error) {
-      this.transition("closed");
-      if (reconnecting && !this.manualClose) this.scheduleReconnect();
+      if (this.current(generation)) {
+        this.retire(opening);
+        this.transition("closed");
+        if (reconnecting && this.current(generation)) this.scheduleReconnect();
+      }
       return Promise.reject(toError(error, "Unable to create WebSocket."));
     }
-    this.socket = socket;
+    if (this.current(generation)) this.socket = socket;
     if ("binaryType" in socket) socket.binaryType = "arraybuffer";
     return new Promise((resolve, reject) => {
       let settled = false;
       const onOpen = () => {
-        if (this.socket !== socket) {
+        if (this.socket !== socket || !this.current(generation)) {
           if (!settled) reject(new Error("WebSocket connection attempt was superseded."));
           socket.close(1e3, "Superseded");
           return;
@@ -212,11 +237,15 @@ var RedwebClient = class {
         settled = true;
         this.reconnectAttempts = 0;
         this.transition("open");
+        if (!this.current(generation)) {
+          reject(new Error("WebSocket connection attempt was cancelled."));
+          return;
+        }
         this.flushQueue();
         resolve();
       };
       const onMessage = (event) => {
-        if (this.socket === socket) void this.handleIncoming(event.data);
+        if (this.socket === socket && this.current(generation)) void this.handleIncoming(event.data);
       };
       const onError = (event) => {
         if (this.socket !== socket) return;
@@ -238,18 +267,27 @@ var RedwebClient = class {
           reject(new Error("WebSocket closed before opening."));
         }
         this.rejectPending(new Error("WebSocket connection closed."));
+        const closedGeneration = this.generation;
+        this.retire(opening);
         this.transition("closed");
         this.notify(this.closeListeners, event);
-        if (!this.manualClose && this.reconnect.shouldReconnect(event)) this.scheduleReconnect();
+        if (!this.manualClose && this.reconnect.shouldReconnect(event) && this.generation === closedGeneration) this.scheduleReconnect();
       };
       socket.addEventListener("open", onOpen);
       socket.addEventListener("message", onMessage);
       socket.addEventListener("error", onError);
       socket.addEventListener("close", onClose);
+      if (!this.current(generation)) {
+        settled = true;
+        reject(new Error("WebSocket connection attempt was cancelled."));
+        socket.close(1e3, "Cancelled");
+      }
     });
   }
   close(code = 1e3, reason = "Client closed") {
     this.manualClose = true;
+    this.generation++;
+    this.connectPromise = void 0;
     if (this.reconnectTimer) {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = void 0;
@@ -284,6 +322,7 @@ var RedwebClient = class {
     this.transmit(data);
   }
   transmit(data, requestId) {
+    if (this.disposed) throw new Error("RedwebClient has been disposed.");
     if (this.socket?.readyState === OPEN) {
       this.socket.send(data);
       return;
@@ -458,21 +497,25 @@ var RedwebClient = class {
   flushQueue() {
     while (this.socket?.readyState === OPEN && this.queue.length > 0) {
       const entry = this.queue.shift();
-      if (entry !== void 0) this.socket.send(entry.data);
+      this.socket.send(entry.data);
     }
   }
   scheduleReconnect() {
-    if (this.disposed || !this.reconnect.enabled || this.reconnectAttempts >= this.reconnect.maxAttempts) return;
+    if (this.disposed || this.manualClose || !this.reconnect.enabled || this.reconnectAttempts >= this.reconnect.maxAttempts) return;
+    const generation = this.generation;
     const baseDelay = Math.min(
       this.reconnect.maxDelayMs,
       this.reconnect.initialDelayMs * this.reconnect.factor ** this.reconnectAttempts
     );
     const spread = baseDelay * this.reconnect.jitter;
     const delay = Math.max(0, Math.round(baseDelay - spread + this.random() * spread * 2));
+    if (!this.current(generation)) return;
     this.reconnectAttempts += 1;
     this.transition("reconnecting");
+    if (!this.current(generation)) return;
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = void 0;
+      if (!this.current(generation)) return;
       void this.openSocket(true).catch(() => {
       });
     }, delay);