@dabble/patches 0.4.4 → 0.4.6

package/dist/net/websocket/WebSocketTransport.js

@@ -1,220 +1,191 @@
-import { signal } from '../../event-signal.js';
-import { deferred } from '../../utils/deferred.js';
-import { onlineState } from './onlineState.js';
-/**
- * WebSocket-based transport implementation that provides communication over the WebSocket protocol.
- * Includes automatic reconnection with exponential backoff.
- */
-export class WebSocketTransport {
-    url;
-    wsOptions;
-    _state = 'disconnected';
-    ws = null;
-    reconnectTimer = null;
-    backoff = 1000;
-    connecting = false;
-    connectionDeferred = null;
-    onlineUnsubscriber = null;
-    /** Flag representing the *intent* to be connected. It is set by `connect()` and cleared by `disconnect()`. */
-    shouldBeConnected = false;
-    /**
-     * Signal that emits when the connection state changes.
-     * Subscribers will receive the new connection state as an argument.
-     */
-    onStateChange = signal();
-    /**
-     * Signal that emits when a message is received from the transport.
-     * Subscribers will receive the message data as a string.
-     */
-    onMessage = signal();
-    /**
-     * Creates a new WebSocket transport instance.
-     * @param url - The WebSocket server URL to connect to
-     * @param wsOptions - Optional configuration for the WebSocket connection
-     */
-    constructor(url, wsOptions) {
-        this.url = url;
-        this.wsOptions = wsOptions;
+import "../../chunk-IZ2YBCUP.js";
+import { signal } from "../../event-signal.js";
+import { deferred } from "../../utils/deferred.js";
+import { onlineState } from "./onlineState.js";
+class WebSocketTransport {
+  /**
+   * Creates a new WebSocket transport instance.
+   * @param url - The WebSocket server URL to connect to
+   * @param wsOptions - Optional configuration for the WebSocket connection
+   */
+  constructor(url, wsOptions) {
+    this.url = url;
+    this.wsOptions = wsOptions;
+  }
+  _state = "disconnected";
+  ws = null;
+  reconnectTimer = null;
+  backoff = 1e3;
+  connecting = false;
+  connectionDeferred = null;
+  onlineUnsubscriber = null;
+  /** Flag representing the *intent* to be connected. It is set by `connect()` and cleared by `disconnect()`. */
+  shouldBeConnected = false;
+  /**
+   * Signal that emits when the connection state changes.
+   * Subscribers will receive the new connection state as an argument.
+   */
+  onStateChange = signal();
+  /**
+   * Signal that emits when a message is received from the transport.
+   * Subscribers will receive the message data as a string.
+   */
+  onMessage = signal();
+  /**
+   * Gets the current connection state of the transport.
+   * @returns The current connection state ('connecting', 'connected', 'disconnected', or 'error')
+   */
+  get state() {
+    return this._state;
+  }
+  /**
+   * Sets the connection state and emits a state change event.
+   * This method is protected and should only be called by subclasses.
+   * @param state - The new connection state
+   */
+  set state(state) {
+    if (state === this._state) return;
+    this._state = state;
+    this.onStateChange.emit(state);
+  }
+  /**
+   * Establishes a connection to the WebSocket server.
+   * If a connection is already open or in progress, this method returns immediately.
+   * On connection failure, an automatic reconnection attempt will be scheduled.
+   * @returns A promise that resolves when the connection is established or rejects on error
+   */
+  async connect() {
+    this.shouldBeConnected = true;
+    this._ensureOnlineOfflineListeners();
+    if (onlineState.isOffline) {
+      if (!this.connectionDeferred) {
+        this.connectionDeferred = deferred();
+      }
+      return this.connectionDeferred.promise;
     }
-    /**
-     * Gets the current connection state of the transport.
-     * @returns The current connection state ('connecting', 'connected', 'disconnected', or 'error')
-     */
-    get state() {
-        return this._state;
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      return Promise.resolve();
     }
-    /**
-     * Sets the connection state and emits a state change event.
-     * This method is protected and should only be called by subclasses.
-     * @param state - The new connection state
-     */
-    set state(state) {
-        if (state === this._state)
-            return;
-        this._state = state;
-        this.onStateChange.emit(state);
+    if (this.connecting && this.connectionDeferred) {
+      return this.connectionDeferred.promise;
     }
-    /**
-     * Establishes a connection to the WebSocket server.
-     * If a connection is already open or in progress, this method returns immediately.
-     * On connection failure, an automatic reconnection attempt will be scheduled.
-     * @returns A promise that resolves when the connection is established or rejects on error
-     */
-    async connect() {
-        // Record the caller's intent.
-        this.shouldBeConnected = true;
-        // Make sure we react to browser connectivity changes
-        this._ensureOnlineOfflineListeners();
-        // If the browser is known to be offline, defer the actual connection until
-        // it comes back online.  We still return a promise that resolves once the
-        // connection is eventually established, so callers can `await` safely.
-        if (onlineState.isOffline) {
-            if (!this.connectionDeferred) {
-                this.connectionDeferred = deferred();
-            }
-            return this.connectionDeferred.promise;
-        }
-        // Return existing connection if already connected
-        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-            return Promise.resolve();
-        }
-        // Return pending connection promise if already connecting
-        if (this.connecting && this.connectionDeferred) {
-            return this.connectionDeferred.promise;
-        }
-        this.connecting = true;
-        this.state = 'connecting';
-        // Create a new connection promise
-        this.connectionDeferred = deferred();
-        const { resolve, reject } = this.connectionDeferred;
-        try {
-            // Pass protocol option if available (standard 2nd arg)
-            // Other options like headers are not standard and require specific server/client handling
-            // or a different WebSocket client library.
-            this.ws = new WebSocket(this.url, this.wsOptions?.protocol);
-            this.ws.onopen = () => {
-                this.backoff = 1000; // Reset backoff on successful connection
-                this.state = 'connected';
-                this.connecting = false;
-                resolve();
-            };
-            this.ws.onclose = () => {
-                this.state = 'disconnected';
-                // If we were in the process of connecting, reject the promise
-                if (this.connecting) {
-                    reject(new Error('Connection closed'));
-                    this.connecting = false;
-                }
-                // Schedule reconnect regardless of whether it was a clean close
-                // as WebSockets don't always emit error events before closing
-                this._scheduleReconnect();
-            };
-            this.ws.onerror = error => {
-                this.state = 'error';
-                // If we're in the connection phase, reject the promise
-                if (this.connecting) {
-                    this.connecting = false;
-                    reject(error);
-                }
-                else {
-                    // If error happens after established connection,
-                    // schedule a reconnect. The socket will likely close
-                    // right after this, but we schedule it anyway to be sure.
-                    this._scheduleReconnect();
-                }
-                // Log the error for debugging
-                console.error('WebSocket error:', error);
-            };
-            this.ws.onmessage = event => {
-                this.onMessage.emit(event.data);
-            };
+    this.connecting = true;
+    this.state = "connecting";
+    this.connectionDeferred = deferred();
+    const { resolve, reject } = this.connectionDeferred;
+    try {
+      this.ws = new WebSocket(this.url, this.wsOptions?.protocol);
+      this.ws.onopen = () => {
+        this.backoff = 1e3;
+        this.state = "connected";
+        this.connecting = false;
+        resolve();
+      };
+      this.ws.onclose = () => {
+        this.state = "disconnected";
+        if (this.connecting) {
+          reject(new Error("Connection closed"));
+          this.connecting = false;
         }
-        catch (error) {
-            this.state = 'error';
-            this.connecting = false;
-            reject(error);
-            this._scheduleReconnect();
+        this._scheduleReconnect();
+      };
+      this.ws.onerror = (error) => {
+        this.state = "error";
+        if (this.connecting) {
+          this.connecting = false;
+          reject(error);
+        } else {
+          this._scheduleReconnect();
         }
-        return this.connectionDeferred.promise;
+        console.error("WebSocket error:", error);
+      };
+      this.ws.onmessage = (event) => {
+        this.onMessage.emit(event.data);
+      };
+    } catch (error) {
+      this.state = "error";
+      this.connecting = false;
+      reject(error);
+      this._scheduleReconnect();
     }
-    /**
-     * Terminates the WebSocket connection and cancels any pending reconnection attempts.
-     */
-    disconnect() {
-        // Clearing the intent stops automatic reconnection attempts.
-        this.shouldBeConnected = false;
-        // Remove listener now that we no longer intend to stay connected.
-        this._removeOnlineOfflineListeners();
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-            this.reconnectTimer = null;
-        }
-        this.connecting = false;
-        if (this.ws) {
-            // Only attempt to close if not already closed
-            if (this.ws.readyState !== WebSocket.CLOSED && this.ws.readyState !== WebSocket.CLOSING) {
-                this.ws.close();
-            }
-            this.ws = null;
-        }
-        this.state = 'disconnected';
+    return this.connectionDeferred.promise;
+  }
+  /**
+   * Terminates the WebSocket connection and cancels any pending reconnection attempts.
+   */
+  disconnect() {
+    this.shouldBeConnected = false;
+    this._removeOnlineOfflineListeners();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
     }
-    /**
-     * Sends data through the WebSocket connection.
-     * @param data - The string data to send
-     * @throws {Error} If the WebSocket is not connected
-     */
-    send(data) {
-        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-            throw new Error('WebSocket is not connected');
-        }
-        this.ws.send(data);
+    this.connecting = false;
+    if (this.ws) {
+      if (this.ws.readyState !== WebSocket.CLOSED && this.ws.readyState !== WebSocket.CLOSING) {
+        this.ws.close();
+      }
+      this.ws = null;
     }
-    /**
-     * Schedules a reconnection attempt using exponential backoff.
-     * The backoff time increases with each failed attempt, up to a maximum of 30 seconds.
-     * @private
-     */
-    _scheduleReconnect() {
-        // Only schedule a reconnect if the caller still wants to be connected.
-        if (!this.shouldBeConnected || onlineState.isOffline) {
-            return;
-        }
-        if (this.reconnectTimer) {
-            return;
-        }
-        this.reconnectTimer = setTimeout(() => {
-            this.reconnectTimer = null;
-            this.connect().catch(err => {
-                console.error('WebSocket reconnect failed:', err);
-            });
-        }, this.backoff);
-        this.backoff = Math.min(this.backoff * 1.5, 30000);
+    this.state = "disconnected";
+  }
+  /**
+   * Sends data through the WebSocket connection.
+   * @param data - The string data to send
+   * @throws {Error} If the WebSocket is not connected
+   */
+  send(data) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("WebSocket is not connected");
     }
-    /**
-     * Internal helper that adds (once) listeners for the browser's online/offline
-     * events so we can automatically attempt to connect when the network comes
-     * back and forcibly close when it goes away.
-     */
-    _ensureOnlineOfflineListeners() {
-        if (!this.onlineUnsubscriber) {
-            this.onlineUnsubscriber = onlineState.onOnlineChange(isOnline => {
-                if (isOnline && this.shouldBeConnected && !this.connecting && this.state !== 'connected') {
-                    const { resolve, reject } = this.connectionDeferred;
-                    this.connectionDeferred = null;
-                    this.connect().then(resolve, reject);
-                }
-                else if (!isOnline && this.ws) {
-                    this.ws.close();
-                }
-            });
-        }
+    this.ws.send(data);
+  }
+  /**
+   * Schedules a reconnection attempt using exponential backoff.
+   * The backoff time increases with each failed attempt, up to a maximum of 30 seconds.
+   * @private
+   */
+  _scheduleReconnect() {
+    if (!this.shouldBeConnected || onlineState.isOffline) {
+      return;
+    }
+    if (this.reconnectTimer) {
+      return;
     }
-    /** Removes previously registered online/offline listeners (if any) */
-    _removeOnlineOfflineListeners() {
-        if (this.onlineUnsubscriber) {
-            this.onlineUnsubscriber();
-            this.onlineUnsubscriber = null;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect().catch((err) => {
+        console.error("WebSocket reconnect failed:", err);
+      });
+    }, this.backoff);
+    this.backoff = Math.min(this.backoff * 1.5, 3e4);
+  }
+  /**
+   * Internal helper that adds (once) listeners for the browser's online/offline
+   * events so we can automatically attempt to connect when the network comes
+   * back and forcibly close when it goes away.
+   */
+  _ensureOnlineOfflineListeners() {
+    if (!this.onlineUnsubscriber) {
+      this.onlineUnsubscriber = onlineState.onOnlineChange((isOnline) => {
+        if (isOnline && this.shouldBeConnected && !this.connecting && this.state !== "connected") {
+          const { resolve, reject } = this.connectionDeferred;
+          this.connectionDeferred = null;
+          this.connect().then(resolve, reject);
+        } else if (!isOnline && this.ws) {
+          this.ws.close();
         }
+      });
+    }
+  }
+  /** Removes previously registered online/offline listeners (if any) */
+  _removeOnlineOfflineListeners() {
+    if (this.onlineUnsubscriber) {
+      this.onlineUnsubscriber();
+      this.onlineUnsubscriber = null;
     }
+  }
 }
+export {
+  WebSocketTransport
+};

package/dist/net/websocket/onlineState.d.ts

@@ -1,9 +1,12 @@
+import { Signal } from '../../event-signal.js';
+
 declare class OnlineState {
-    onOnlineChange: import("../../event-signal.js").Signal<(isOnline: boolean) => void>;
+    onOnlineChange: Signal<(isOnline: boolean) => void>;
     protected _isOnline: boolean;
     constructor();
     get isOnline(): boolean;
     get isOffline(): boolean;
 }
-export declare const onlineState: OnlineState;
-export {};
+declare const onlineState: OnlineState;
+
+export { onlineState };

package/dist/net/websocket/onlineState.js

@@ -1,24 +1,28 @@
-import { signal } from '../../event-signal.js';
+import "../../chunk-IZ2YBCUP.js";
+import { signal } from "../../event-signal.js";
 class OnlineState {
-    onOnlineChange = signal();
-    _isOnline = typeof navigator !== 'undefined' && navigator.onLine;
-    constructor() {
-        if (typeof addEventListener === 'function') {
-            addEventListener('online', () => {
-                this._isOnline = true;
-                this.onOnlineChange.emit(true);
-            });
-            addEventListener('offline', () => {
-                this._isOnline = false;
-                this.onOnlineChange.emit(false);
-            });
-        }
-    }
-    get isOnline() {
-        return this._isOnline;
-    }
-    get isOffline() {
-        return !this._isOnline;
+  onOnlineChange = signal();
+  _isOnline = typeof navigator !== "undefined" && navigator.onLine;
+  constructor() {
+    if (typeof addEventListener === "function") {
+      addEventListener("online", () => {
+        this._isOnline = true;
+        this.onOnlineChange.emit(true);
+      });
+      addEventListener("offline", () => {
+        this._isOnline = false;
+        this.onOnlineChange.emit(false);
+      });
     }
+  }
+  get isOnline() {
+    return this._isOnline;
+  }
+  get isOffline() {
+    return !this._isOnline;
+  }
 }
-export const onlineState = new OnlineState();
+const onlineState = new OnlineState();
+export {
+  onlineState
+};

package/dist/server/PatchesBranchManager.d.ts

@@ -1,12 +1,17 @@
-import type { Branch, BranchStatus, Change, EditableBranchMetadata } from '../types.js';
-import type { PatchesServer } from './PatchesServer.js';
-import type { BranchingStoreBackend } from './types.js';
+import { Branch, EditableBranchMetadata, BranchStatus, Change } from '../types.js';
+import { PatchesServer } from './PatchesServer.js';
+import { BranchingStoreBackend } from './types.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../json-patch/types.js';
+import '../event-signal.js';
+
 /**
  * Helps manage branches for a document. A branch is a document that is branched from another document. Its first
  * version will be the point-in-time of the original document at the time of the branch. Branches allow for parallel
  * development of a document with the ability to merge changes back into the original document later.
  */
-export declare class PatchesBranchManager {
+declare class PatchesBranchManager {
     private readonly store;
     private readonly patchesServer;
     constructor(store: BranchingStoreBackend, patchesServer: PatchesServer);
@@ -45,4 +50,6 @@ export declare class PatchesBranchManager {
      */
     mergeBranch(branchId: string): Promise<Change[]>;
 }
-export declare function assertBranchMetadata(metadata?: EditableBranchMetadata): void;
+declare function assertBranchMetadata(metadata?: EditableBranchMetadata): void;
+
+export { PatchesBranchManager, assertBranchMetadata };