@dabble/patches 0.5.6 → 0.5.8

package/dist/algorithms/shared/changeBatching.js

@@ -142,7 +142,10 @@ function breakTextOp(origChange, textOp, maxBytes, startRev, sizeCalculator) {
       testBatchOps.push({ retain: retainToPrefixCurrentPiece });
     }
     testBatchOps.push(op);
-    const testBatchSize = getSizeForStorage({ ...origChange, ops: [{ ...textOp, value: testBatchOps }] }, sizeCalculator);
+    const testBatchSize = getSizeForStorage(
+      { ...origChange, ops: [{ ...textOp, value: testBatchOps }] },
+      sizeCalculator
+    );
     if (currentOpsForNextChangePiece.length > 0 && testBatchSize > maxBytes) {
       flushCurrentChangePiece();
     }

package/dist/client/PatchesDoc.js

@@ -88,7 +88,13 @@ class PatchesDoc {
    * @returns The generated Change objects.
    */
   change(mutator) {
-    const changes = makeChange(this._snapshot, mutator, this._changeMetadata, this._maxStorageBytes, this._sizeCalculator);
+    const changes = makeChange(
+      this._snapshot,
+      mutator,
+      this._changeMetadata,
+      this._maxStorageBytes,
+      this._sizeCalculator
+    );
     if (changes.length === 0) {
       return changes;
     }

package/dist/net/PatchesSync.d.ts

@@ -11,6 +11,7 @@ import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../json-patch/types.js';
 import './PatchesClient.js';
+import '../utils/deferred.js';
 import '../client/PatchesDoc.js';
 
 interface PatchesSyncState {
@@ -53,6 +54,14 @@ declare class PatchesSync {
         docId?: string;
     }) => void>;
     constructor(patches: Patches, url: string, options?: PatchesSyncOptions | undefined);
+    /**
+     * Gets the URL of the WebSocket connection.
+     */
+    get url(): string;
+    /**
+     * Sets the URL of the WebSocket connection.
+     */
+    set url(url: string);
     /**
      * Gets the current sync state.
      */

package/dist/net/PatchesSync.js

@@ -50,6 +50,22 @@ class PatchesSync {
     patches.onUntrackDocs(this._handleDocsUntracked.bind(this));
     patches.onDeleteDoc(this._handleDocDeleted.bind(this));
   }
+  /**
+   * Gets the URL of the WebSocket connection.
+   */
+  get url() {
+    return this.ws.transport.url;
+  }
+  /**
+   * Sets the URL of the WebSocket connection.
+   */
+  set url(url) {
+    this.ws.transport.url = url;
+    if (this.state.connected) {
+      this.ws.disconnect();
+      this.ws.connect();
+    }
+  }
   /**
    * Gets the current sync state.
    */

package/dist/net/index.d.ts

@@ -26,5 +26,6 @@ import '../compression/index.js';
 import '../algorithms/shared/lz.js';
 import '../json-patch/types.js';
 import '../server/PatchesHistoryManager.js';
+import '../utils/deferred.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/net/webrtc/WebRTCAwareness.d.ts

@@ -7,6 +7,7 @@ import '@dabble/delta';
 import '../../json-patch/types.js';
 import 'simple-peer';
 import '../websocket/WebSocketTransport.js';
+import '../../utils/deferred.js';
 
 /**
  * Base type for awareness states, representing arbitrary structured data

package/dist/net/webrtc/WebRTCTransport.d.ts

@@ -6,6 +6,7 @@ import '../../types.js';
 import '../../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../../json-patch/types.js';
+import '../../utils/deferred.js';
 
 /**
  * WebRTC-based transport implementation that enables direct peer-to-peer communication.

package/dist/net/webrtc/index.d.ts

@@ -8,3 +8,4 @@ import '@dabble/delta';
 import '../../json-patch/types.js';
 import 'simple-peer';
 import '../websocket/WebSocketTransport.js';
+import '../../utils/deferred.js';

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

@@ -7,6 +7,7 @@ import '../../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../../json-patch/types.js';
 import '../protocol/JSONRPCClient.js';
+import '../../utils/deferred.js';
 
 /**
  * High-level client for the Patches real-time collaboration service.

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

@@ -1,4 +1,5 @@
-import { Signal } from '../../event-signal.js';
+import { Unsubscriber, Signal } from '../../event-signal.js';
+import { Deferred } from '../../utils/deferred.js';
 import { ClientTransport, ConnectionState } from '../protocol/types.js';
 import '../../types.js';
 import '../../json-patch/JSONPatch.js';
@@ -14,17 +15,17 @@ interface WebSocketOptions {
  * Includes automatic reconnection with exponential backoff.
  */
 declare class WebSocketTransport implements ClientTransport {
-    private url;
-    private wsOptions?;
-    private _state;
-    private ws;
-    private reconnectTimer;
-    private backoff;
-    private connecting;
-    private connectionDeferred;
-    private onlineUnsubscriber;
+    url: string;
+    wsOptions?: WebSocketOptions | undefined;
+    protected _state: ConnectionState;
+    protected ws: WebSocket | null;
+    protected reconnectTimer: any;
+    protected backoff: number;
+    protected connecting: boolean;
+    protected connectionDeferred: Deferred | null;
+    protected onlineUnsubscriber: Unsubscriber | null;
     /** Flag representing the *intent* to be connected. It is set by `connect()` and cleared by `disconnect()`. */
-    private shouldBeConnected;
+    protected shouldBeConnected: boolean;
     /**
      * Signal that emits when the connection state changes.
      * Subscribers will receive the new connection state as an argument.
@@ -72,17 +73,17 @@ declare class WebSocketTransport implements ClientTransport {
     /**
      * Schedules a reconnection attempt using exponential backoff.
      * The backoff time increases with each failed attempt, up to a maximum of 30 seconds.
-     * @private
+     * @protected
      */
-    private _scheduleReconnect;
+    protected _scheduleReconnect(): void;
     /**
      * 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.
      */
-    private _ensureOnlineOfflineListeners;
+    protected _ensureOnlineOfflineListeners(): void;
     /** Removes previously registered online/offline listeners (if any) */
-    private _removeOnlineOfflineListeners;
+    protected _removeOnlineOfflineListeners(): void;
 }
 
 export { type WebSocketOptions, WebSocketTransport };

package/dist/net/websocket/WebSocketTransport.js

@@ -143,7 +143,7 @@ class WebSocketTransport {
   /**
    * Schedules a reconnection attempt using exponential backoff.
    * The backoff time increases with each failed attempt, up to a maximum of 30 seconds.
-   * @private
+   * @protected
    */
   _scheduleReconnect() {
     if (!this.shouldBeConnected || onlineState.isOffline) {

package/dist/solid/context.d.ts

@@ -0,0 +1,68 @@
+import { JSX } from 'solid-js';
+import { Patches } from '../client/Patches.js';
+import { PatchesSync } from '../net/PatchesSync.js';
+import '../event-signal.js';
+import '../types.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../json-patch/types.js';
+import '../client/PatchesDoc.js';
+import '../algorithms/shared/changeBatching.js';
+import '../client/PatchesStore.js';
+import '../net/protocol/types.js';
+import '../net/protocol/JSONRPCClient.js';
+import '../net/websocket/PatchesWebSocket.js';
+import '../net/PatchesClient.js';
+import '../net/websocket/WebSocketTransport.js';
+import '../utils/deferred.js';
+
+/**
+ * Context value containing Patches and optional PatchesSync instances.
+ */
+interface PatchesContextValue {
+    patches: Patches;
+    sync?: PatchesSync;
+}
+/**
+ * Props for the PatchesProvider component.
+ */
+interface PatchesProviderProps {
+    patches: Patches;
+    sync?: PatchesSync;
+    children: JSX.Element;
+}
+/**
+ * Provider component for making Patches and PatchesSync available to child components.
+ *
+ * @example
+ * ```tsx
+ * import { PatchesProvider } from '@dabble/patches/solid';
+ * import { Patches, InMemoryStore } from '@dabble/patches/client';
+ *
+ * const patches = new Patches({ store: new InMemoryStore() });
+ *
+ * <PatchesProvider patches={patches}>
+ *   <App />
+ * </PatchesProvider>
+ * ```
+ */
+declare function PatchesProvider(props: PatchesProviderProps): any;
+/**
+ * Hook to access the Patches context.
+ *
+ * @throws Error if called outside of a PatchesProvider
+ * @returns PatchesContextValue containing patches and optional sync instances
+ *
+ * @example
+ * ```tsx
+ * import { usePatchesContext } from '@dabble/patches/solid';
+ *
+ * function MyComponent() {
+ *   const { patches, sync } = usePatchesContext();
+ *   // Use patches and sync...
+ * }
+ * ```
+ */
+declare function usePatchesContext(): PatchesContextValue;
+
+export { type PatchesContextValue, PatchesProvider, type PatchesProviderProps, usePatchesContext };

package/dist/solid/context.js

@@ -0,0 +1,20 @@
+import "../chunk-IZ2YBCUP.js";
+import { createContext, useContext } from "solid-js";
+const PatchesContext = createContext();
+function PatchesProvider(props) {
+  const value = { patches: props.patches, sync: props.sync };
+  return /* @__PURE__ */ React.createElement(PatchesContext.Provider, { value, children: props.children });
+}
+function usePatchesContext() {
+  const context = useContext(PatchesContext);
+  if (!context) {
+    throw new Error(
+      "usePatchesContext must be called within a PatchesProvider. Make sure your component is wrapped with <PatchesProvider>."
+    );
+  }
+  return context;
+}
+export {
+  PatchesProvider,
+  usePatchesContext
+};

package/dist/solid/doc-manager.d.ts

@@ -0,0 +1,88 @@
+import { Patches } from '../client/Patches.js';
+import { PatchesDoc } from '../client/PatchesDoc.js';
+import '../event-signal.js';
+import '../types.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../json-patch/types.js';
+import '../client/PatchesStore.js';
+import '../algorithms/shared/changeBatching.js';
+
+/**
+ * Reference counting manager for PatchesDoc instances.
+ *
+ * Tracks how many Solid components are using each document and only opens/closes
+ * documents when the reference count goes to/from zero.
+ *
+ * This prevents the footgun where multiple components open the same doc but the
+ * first one to unmount closes it for everyone else.
+ */
+declare class DocManager {
+    private refCounts;
+    private pendingOps;
+    /**
+     * Opens a document with reference counting.
+     *
+     * - If this is the first reference, calls patches.openDoc()
+     * - If doc is already open, returns existing instance and increments count
+     * - Handles concurrent opens to the same doc safely
+     *
+     * @param patches - Patches instance
+     * @param docId - Document ID to open
+     * @returns Promise resolving to PatchesDoc instance
+     */
+    openDoc<T extends object>(patches: Patches, docId: string): Promise<PatchesDoc<T>>;
+    /**
+     * Closes a document with reference counting.
+     *
+     * - Decrements the reference count
+     * - Only calls patches.closeDoc() when count reaches zero
+     * - Safe to call even if doc was never opened
+     *
+     * @param patches - Patches instance
+     * @param docId - Document ID to close
+     */
+    closeDoc(patches: Patches, docId: string): Promise<void>;
+    /**
+     * Increments the reference count for a document without opening it.
+     *
+     * Used in explicit mode to track usage and prevent premature closes
+     * from autoClose mode.
+     *
+     * @param docId - Document ID
+     */
+    incrementRefCount(docId: string): void;
+    /**
+     * Decrements the reference count for a document without closing it.
+     *
+     * Used in explicit mode to release usage tracking.
+     *
+     * @param docId - Document ID
+     */
+    decrementRefCount(docId: string): void;
+    /**
+     * Gets the current reference count for a document.
+     *
+     * Useful for debugging or advanced use cases.
+     *
+     * @param docId - Document ID
+     * @returns Current reference count (0 if not tracked)
+     */
+    getRefCount(docId: string): number;
+    /**
+     * Clears all reference counts without closing documents.
+     *
+     * Use with caution - this is mainly for testing or cleanup scenarios
+     * where you want to reset the manager state.
+     */
+    reset(): void;
+}
+/**
+ * Gets or creates a DocManager for a Patches instance.
+ *
+ * @param patches - Patches instance
+ * @returns DocManager for this Patches instance
+ */
+declare function getDocManager(patches: Patches): DocManager;
+
+export { DocManager, getDocManager };

package/dist/solid/doc-manager.js

@@ -0,0 +1,125 @@
+import "../chunk-IZ2YBCUP.js";
+class DocManager {
+  refCounts = /* @__PURE__ */ new Map();
+  pendingOps = /* @__PURE__ */ new Map();
+  /**
+   * Opens a document with reference counting.
+   *
+   * - If this is the first reference, calls patches.openDoc()
+   * - If doc is already open, returns existing instance and increments count
+   * - Handles concurrent opens to the same doc safely
+   *
+   * @param patches - Patches instance
+   * @param docId - Document ID to open
+   * @returns Promise resolving to PatchesDoc instance
+   */
+  async openDoc(patches, docId) {
+    const currentCount = this.refCounts.get(docId) || 0;
+    if (currentCount === 0 && this.pendingOps.has(docId)) {
+      const doc = await this.pendingOps.get(docId);
+      this.refCounts.set(docId, (this.refCounts.get(docId) || 0) + 1);
+      return doc;
+    }
+    if (currentCount > 0) {
+      this.refCounts.set(docId, currentCount + 1);
+      const doc = patches.getOpenDoc(docId);
+      if (!doc) {
+        throw new Error(`Document ${docId} has ref count ${currentCount} but is not open in Patches`);
+      }
+      return doc;
+    }
+    const openPromise = patches.openDoc(docId);
+    this.pendingOps.set(docId, openPromise);
+    try {
+      const doc = await openPromise;
+      this.refCounts.set(docId, 1);
+      return doc;
+    } catch (error) {
+      this.refCounts.delete(docId);
+      throw error;
+    } finally {
+      this.pendingOps.delete(docId);
+    }
+  }
+  /**
+   * Closes a document with reference counting.
+   *
+   * - Decrements the reference count
+   * - Only calls patches.closeDoc() when count reaches zero
+   * - Safe to call even if doc was never opened
+   *
+   * @param patches - Patches instance
+   * @param docId - Document ID to close
+   */
+  async closeDoc(patches, docId) {
+    const currentCount = this.refCounts.get(docId) || 0;
+    if (currentCount === 0) {
+      return;
+    }
+    if (currentCount === 1) {
+      this.refCounts.delete(docId);
+      await patches.closeDoc(docId);
+    } else {
+      this.refCounts.set(docId, currentCount - 1);
+    }
+  }
+  /**
+   * Increments the reference count for a document without opening it.
+   *
+   * Used in explicit mode to track usage and prevent premature closes
+   * from autoClose mode.
+   *
+   * @param docId - Document ID
+   */
+  incrementRefCount(docId) {
+    const currentCount = this.refCounts.get(docId) || 0;
+    this.refCounts.set(docId, currentCount + 1);
+  }
+  /**
+   * Decrements the reference count for a document without closing it.
+   *
+   * Used in explicit mode to release usage tracking.
+   *
+   * @param docId - Document ID
+   */
+  decrementRefCount(docId) {
+    const currentCount = this.refCounts.get(docId) || 0;
+    if (currentCount > 0) {
+      this.refCounts.set(docId, currentCount - 1);
+    }
+  }
+  /**
+   * Gets the current reference count for a document.
+   *
+   * Useful for debugging or advanced use cases.
+   *
+   * @param docId - Document ID
+   * @returns Current reference count (0 if not tracked)
+   */
+  getRefCount(docId) {
+    return this.refCounts.get(docId) || 0;
+  }
+  /**
+   * Clears all reference counts without closing documents.
+   *
+   * Use with caution - this is mainly for testing or cleanup scenarios
+   * where you want to reset the manager state.
+   */
+  reset() {
+    this.refCounts.clear();
+    this.pendingOps.clear();
+  }
+}
+const managers = /* @__PURE__ */ new WeakMap();
+function getDocManager(patches) {
+  let manager = managers.get(patches);
+  if (!manager) {
+    manager = new DocManager();
+    managers.set(patches, manager);
+  }
+  return manager;
+}
+export {
+  DocManager,
+  getDocManager
+};

package/dist/solid/index.d.ts

@@ -0,0 +1,20 @@
+export { PatchesContextValue, PatchesProvider, PatchesProviderProps, usePatchesContext } from './context.js';
+export { MaybeAccessor, UsePatchesDocOptions, UsePatchesDocReturn, UsePatchesSyncReturn, createPatchesDoc, usePatchesDoc, usePatchesSync } from './primitives.js';
+export { DocManager, getDocManager } from './doc-manager.js';
+import 'solid-js';
+import '../client/Patches.js';
+import '../event-signal.js';
+import '../types.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../json-patch/types.js';
+import '../client/PatchesDoc.js';
+import '../algorithms/shared/changeBatching.js';
+import '../client/PatchesStore.js';
+import '../net/PatchesSync.js';
+import '../net/protocol/types.js';
+import '../net/protocol/JSONRPCClient.js';
+import '../net/websocket/PatchesWebSocket.js';
+import '../net/PatchesClient.js';
+import '../net/websocket/WebSocketTransport.js';
+import '../utils/deferred.js';

package/dist/solid/index.js

@@ -0,0 +1,17 @@
+import "../chunk-IZ2YBCUP.js";
+import { PatchesProvider, usePatchesContext } from "./context.js";
+import {
+  usePatchesDoc,
+  usePatchesSync,
+  createPatchesDoc
+} from "./primitives.js";
+import { getDocManager, DocManager } from "./doc-manager.js";
+export {
+  DocManager,
+  PatchesProvider,
+  createPatchesDoc,
+  getDocManager,
+  usePatchesContext,
+  usePatchesDoc,
+  usePatchesSync
+};