@dabble/patches 0.7.14 → 0.7.16

package/dist/net/PatchesSync.js

@@ -5,25 +5,29 @@ import {
   __publicField,
   __runInitializers
 } from "../chunk-IZ2YBCUP.js";
-var __receiveCommittedChanges_dec, _syncDoc_dec, _init;
+var __receiveCommittedChanges_dec, _syncDoc_dec, _a, _init;
 import { isEqual } from "@dabble/delta";
+import { batch, ReadonlyStoreClass, signal, store } from "easy-signal";
 import { breakChangesIntoBatches } from "../algorithms/ot/shared/changeBatching.js";
 import { BaseDoc } from "../client/BaseDoc.js";
 import { Patches } from "../client/Patches.js";
-import { signal } from "../event-signal.js";
 import { isDocLoaded } from "../shared/utils.js";
 import { blockable } from "../utils/concurrency.js";
 import { PatchesWebSocket } from "./websocket/PatchesWebSocket.js";
 import { onlineState } from "./websocket/onlineState.js";
-const EMPTY_SYNCED_DOC = {
+const EMPTY_DOC_STATE = {
   committedRev: 0,
   hasPending: false,
   syncStatus: "unsynced",
   isLoaded: false
 };
-_syncDoc_dec = [blockable], __receiveCommittedChanges_dec = [blockable];
-class PatchesSync {
+class PatchesSync extends (_a = ReadonlyStoreClass, _syncDoc_dec = [blockable], __receiveCommittedChanges_dec = [blockable], _a) {
   constructor(patches, url, options) {
+    super({
+      online: onlineState.isOnline,
+      connected: false,
+      syncStatus: "unsynced"
+    });
     this.options = options;
     __runInitializers(_init, 5, this);
     __publicField(this, "ws");
@@ -34,17 +38,10 @@ class PatchesSync {
     __publicField(this, "trackedDocs");
     /** Maps docId to the algorithm name used for that doc */
     __publicField(this, "docAlgorithms", /* @__PURE__ */ new Map());
-    __publicField(this, "_state", {
-      online: false,
-      connected: false,
-      syncStatus: "unsynced",
-      syncError: void 0
-    });
-    __publicField(this, "_syncedDocs", {});
     /**
-     * Signal emitted when the sync state changes.
+     * Reactive store tracking per-document sync state.
      */
-    __publicField(this, "onStateChange", signal());
+    __publicField(this, "docStates");
     /**
      * Signal emitted when an error occurs.
      */
@@ -54,16 +51,12 @@ class PatchesSync {
      * Provides the pending changes that were discarded so the application can handle them.
      */
     __publicField(this, "onRemoteDocDeleted", signal());
-    /**
-     * Signal emitted when the synced doc map changes.
-     */
-    __publicField(this, "onSyncedDocsChange", signal());
     this.patches = patches;
     this.maxPayloadBytes = options?.maxPayloadBytes;
     this.maxStorageBytes = options?.maxStorageBytes ?? patches.docOptions?.maxStorageBytes;
     this.sizeCalculator = options?.sizeCalculator ?? patches.docOptions?.sizeCalculator;
     this.ws = new PatchesWebSocket(url, options?.websocket);
-    this._state.online = onlineState.isOnline;
+    this.docStates = store({});
     this.trackedDocs = new Set(patches.trackedDocs);
     onlineState.onOnlineChange((online) => this.updateState({ online }));
     this.ws.onStateChange(this._handleConnectionChange.bind(this));
@@ -104,19 +97,6 @@ class PatchesSync {
       this.ws.connect();
     }
   }
-  /**
-   * Gets the current sync state.
-   */
-  get state() {
-    return this._state;
-  }
-  /**
-   * Map of all tracked documents and their current sync status.
-   * Updated immutably — new object reference on every change.
-   */
-  get syncedDocs() {
-    return this._syncedDocs;
-  }
   /**
    * Gets the JSON-RPC client for making custom RPC calls.
    * Useful for application-specific methods not part of the Patches protocol.
@@ -129,13 +109,12 @@ class PatchesSync {
    * @param update - The partial state to update.
    */
   updateState(update) {
-    const newState = { ...this._state, ...update };
+    const newState = { ...this.state, ...update };
     if (newState.syncStatus !== "error" && newState.syncError) {
       newState.syncError = void 0;
     }
-    if (!isEqual(this._state, newState)) {
-      this._state = newState;
-      this.onStateChange.emit(this._state);
+    if (!isEqual(this.state, newState)) {
+      this.state = newState;
     }
   }
   /**
@@ -193,12 +172,11 @@ class PatchesSync {
           syncError: void 0,
           isLoaded: false
         };
-        const existing = this._syncedDocs[doc.docId];
-        entry.isLoaded = existing?.isLoaded || isDocLoaded(entry);
+        const existing = this.docStates.state[doc.docId];
+        entry.isLoaded = existing?.isLoaded || isDocLoaded(entry.committedRev, entry.hasPending, entry.syncStatus);
         syncedEntries[doc.docId] = entry;
       }
-      this._syncedDocs = syncedEntries;
-      this.onSyncedDocsChange.emit(this._syncedDocs);
+      this.docStates.state = syncedEntries;
       if (activeDocIds.length > 0) {
         try {
           const subscribeIds = this._filterSubscribeIds(activeDocIds);
@@ -234,7 +212,7 @@ class PatchesSync {
   }
   async syncDoc(docId) {
     if (!this.state.connected) return;
-    this._updateSyncedDoc(docId, { syncStatus: "syncing" });
+    this._updateDocSyncState(docId, { syncStatus: "syncing" });
     const doc = this.patches.getOpenDoc(docId);
     const algorithm = this._getAlgorithm(docId);
     const baseDoc = doc;
@@ -255,13 +233,13 @@ class PatchesSync {
         } else {
           const snapshot = await this.ws.getDoc(docId);
           await algorithm.store.saveDoc(docId, snapshot);
-          this._updateSyncedDoc(docId, { committedRev: snapshot.rev });
+          this._updateDocSyncState(docId, { committedRev: snapshot.rev });
           if (baseDoc) {
             baseDoc.import({ ...snapshot, changes: [] });
           }
         }
       }
-      this._updateSyncedDoc(docId, { syncStatus: "synced" });
+      this._updateDocSyncState(docId, { syncStatus: "synced" });
       if (baseDoc) {
         baseDoc.updateSyncStatus("synced");
       }
@@ -271,7 +249,7 @@ class PatchesSync {
         return;
       }
       const syncError = err instanceof Error ? err : new Error(String(err));
-      this._updateSyncedDoc(docId, { syncStatus: "error", syncError });
+      this._updateDocSyncState(docId, { syncStatus: "error", syncError });
       console.error(`Error syncing doc ${docId}:`, err);
       this.onError.emit(syncError, { docId });
       if (baseDoc) {
@@ -304,24 +282,24 @@ class PatchesSync {
         maxStorageBytes: this.maxStorageBytes,
         sizeCalculator: this.sizeCalculator
       });
-      for (const batch of batches) {
+      for (const changeBatch of batches) {
         if (!this.state.connected) {
           throw new Error("Disconnected during flush");
         }
-        const committed = await this.ws.commitChanges(docId, batch);
+        const committed = await this.ws.commitChanges(docId, changeBatch);
         await this._applyServerChangesToDoc(docId, committed);
-        await algorithm.confirmSent(docId, batch);
+        await algorithm.confirmSent(docId, changeBatch);
         pending = await algorithm.getPendingToSend(docId) ?? [];
       }
       const stillHasPending = pending != null && pending.length > 0;
-      this._updateSyncedDoc(docId, { hasPending: stillHasPending, syncStatus: "synced" });
+      this._updateDocSyncState(docId, { hasPending: stillHasPending, syncStatus: "synced" });
     } catch (err) {
       if (this._isDocDeletedError(err)) {
         await this._handleRemoteDocDeleted(docId);
         return;
       }
       const flushError = err instanceof Error ? err : new Error(String(err));
-      this._updateSyncedDoc(docId, { syncStatus: "error", syncError: flushError });
+      this._updateDocSyncState(docId, { syncStatus: "error", syncError: flushError });
       console.error(`Flush failed for doc ${docId}:`, err);
       this.onError.emit(flushError, { docId });
       throw err;
@@ -344,7 +322,7 @@ class PatchesSync {
     await algorithm.applyServerChanges(docId, serverChanges, doc);
     if (serverChanges.length > 0) {
       const lastRev = serverChanges[serverChanges.length - 1].rev;
-      this._updateSyncedDoc(docId, { committedRev: lastRev });
+      this._updateDocSyncState(docId, { committedRev: lastRev });
     }
   }
   /**
@@ -369,7 +347,7 @@ class PatchesSync {
   _handleConnectionChange(connectionState) {
     const isConnected = connectionState === "connected";
     const isConnecting = connectionState === "connecting";
-    const newSyncStatus = isConnected ? this._state.syncStatus : isConnecting ? this._state.syncStatus : "unsynced";
+    const newSyncStatus = isConnected ? this.state.syncStatus : isConnecting ? this.state.syncStatus : "unsynced";
     this.updateState({ connected: isConnected, syncStatus: newSyncStatus });
     if (isConnected) {
       void this.syncAllKnownDocs();
@@ -377,37 +355,48 @@ class PatchesSync {
       this._resetSyncingStatuses();
     }
   }
-  async _handleDocsTracked(docIds) {
+  async _handleDocsTracked(docIds, algorithmName) {
     const newIds = docIds.filter((id) => !this.trackedDocs.has(id));
     if (!newIds.length) return;
     const alreadySubscribed = this._getActiveSubscriptions();
     newIds.forEach((id) => this.trackedDocs.add(id));
-    for (const docId of newIds) {
-      for (const algorithm of Object.values(this.patches.algorithms)) {
-        if (!algorithm) continue;
-        const docs = await algorithm.listDocs(false);
-        const tracked = docs.find((d) => d.docId === docId);
-        if (tracked?.algorithm) {
-          this.docAlgorithms.set(docId, tracked.algorithm);
-          break;
+    if (algorithmName) {
+      for (const docId of newIds) {
+        this.docAlgorithms.set(docId, algorithmName);
+      }
+    } else {
+      for (const docId of newIds) {
+        for (const algorithm of Object.values(this.patches.algorithms)) {
+          if (!algorithm) continue;
+          const docs = await algorithm.listDocs(false);
+          const tracked = docs.find((d) => d.docId === docId);
+          if (tracked?.algorithm) {
+            this.docAlgorithms.set(docId, tracked.algorithm);
+            break;
+          }
         }
       }
     }
+    const docData = [];
     for (const docId of newIds) {
       const algorithm = this._getAlgorithm(docId);
       const committedRev = await algorithm.getCommittedRev(docId);
       const pending = await algorithm.getPendingToSend(docId);
-      this._updateSyncedDoc(
+      docData.push({
         docId,
-        {
+        committedRev,
+        hasPending: pending != null && pending.length > 0
+      });
+    }
+    batch(() => {
+      for (const { docId, committedRev, hasPending } of docData) {
+        this._updateDocSyncState(docId, {
           committedRev,
-          hasPending: pending != null && pending.length > 0,
+          hasPending,
           syncStatus: committedRev === 0 ? "unsynced" : "synced"
-        },
-        false
-      );
-    }
-    this._emitSyncedChange();
+        });
+      }
+    });
     if (this.state.connected) {
       try {
         const subscribeIds = this._filterSubscribeIds(newIds).filter((id) => !alreadySubscribed.has(id));
@@ -426,8 +415,9 @@ class PatchesSync {
     if (!existingIds.length) return;
     const subscribedBefore = this._getActiveSubscriptions();
     existingIds.forEach((id) => this.trackedDocs.delete(id));
-    existingIds.forEach((id) => this._updateSyncedDoc(id, void 0, false));
-    this._emitSyncedChange();
+    batch(() => {
+      existingIds.forEach((id) => this._updateDocSyncState(id, void 0));
+    });
     const subscribedAfter = this._getActiveSubscriptions();
     const unsubscribeIds = [...subscribedBefore].filter((id) => !subscribedAfter.has(id));
     if (this.state.connected && unsubscribeIds.length) {
@@ -440,10 +430,9 @@ class PatchesSync {
   }
   async _handleDocChange(docId) {
     if (!this.trackedDocs.has(docId)) return;
-    this._updateSyncedDoc(docId, { hasPending: true }, !this.state.connected);
+    this._updateDocSyncState(docId, { hasPending: true });
     if (!this.state.connected) return;
-    this._updateSyncedDoc(docId, { syncStatus: "syncing" });
-    await this.flushDoc(docId);
+    await this.syncDoc(docId);
   }
   /**
    * Unified handler for remote document deletion (both real-time notifications and offline discovery).
@@ -457,37 +446,35 @@ class PatchesSync {
       await this.patches.closeDoc(docId);
     }
     this.trackedDocs.delete(docId);
-    this._updateSyncedDoc(docId, void 0);
+    this._updateDocSyncState(docId, void 0);
     await algorithm.confirmDeleteDoc(docId);
     await this.onRemoteDocDeleted.emit(docId, pendingChanges);
   }
   /**
-   * Adds, updates, or removes a synced doc entry immutably and emits onSyncedChange.
-   * - Pass a full SyncedDoc to add a new entry or overwrite an existing one.
-   * - Pass a Partial<SyncedDoc> to merge into an existing entry (no-ops if doc not in map).
+   * Adds, updates, or removes a doc state entry immutably and notifies via store.
+   * - Pass a full DocSyncState to add a new entry or overwrite an existing one.
+   * - Pass a Partial<DocSyncState> to merge into an existing entry (no-ops if doc not in map).
    * - Pass undefined to remove the entry.
    * No-ops if nothing actually changed.
    */
-  _updateSyncedDoc(docId, updates, emit = true) {
+  _updateDocSyncState(docId, updates) {
+    const currentDocs = this.docStates.state;
     if (updates === void 0) {
-      if (!(docId in this._syncedDocs)) return;
-      this._syncedDocs = { ...this._syncedDocs };
-      delete this._syncedDocs[docId];
+      if (!(docId in currentDocs)) return;
+      const newDocs = { ...currentDocs };
+      delete newDocs[docId];
+      this.docStates.state = newDocs;
     } else {
-      const updated = { ...EMPTY_SYNCED_DOC, ...this._syncedDocs[docId], ...updates };
+      const updated = { ...EMPTY_DOC_STATE, ...currentDocs[docId], ...updates };
       if (updated.syncStatus !== "error" && updated.syncError) {
         updated.syncError = void 0;
       }
       if (!updated.isLoaded) {
-        updated.isLoaded = isDocLoaded(updated);
+        updated.isLoaded = isDocLoaded(updated.committedRev, updated.hasPending, updated.syncStatus);
       }
-      if (isEqual(this._syncedDocs[docId], updated)) return;
-      this._syncedDocs = { ...this._syncedDocs, [docId]: updated };
+      if (isEqual(currentDocs[docId], updated)) return;
+      this.docStates.state = { ...currentDocs, [docId]: updated };
     }
-    if (emit) this._emitSyncedChange();
-  }
-  _emitSyncedChange() {
-    this.onSyncedDocsChange.emit(this._syncedDocs);
   }
   /**
    * Resets any docs with status 'syncing' back to a stable state on disconnect.
@@ -495,15 +482,14 @@ class PatchesSync {
    * docs with no pending and no committed rev become 'unsynced'.
    */
   _resetSyncingStatuses() {
-    let changed = false;
-    for (const [docId, doc] of Object.entries(this._syncedDocs)) {
-      if (doc.syncStatus === "syncing") {
-        const newStatus = doc.committedRev === 0 && !doc.hasPending ? "unsynced" : "synced";
-        this._updateSyncedDoc(docId, { syncStatus: newStatus }, false);
-        changed = true;
+    batch(() => {
+      for (const [docId, doc] of Object.entries(this.docStates.state)) {
+        if (doc.syncStatus === "syncing") {
+          const newStatus = doc.committedRev === 0 && !doc.hasPending ? "unsynced" : "synced";
+          this._updateDocSyncState(docId, { syncStatus: newStatus });
+        }
       }
-    }
-    if (changed) this._emitSyncedChange();
+    });
   }
   /**
    * Applies the subscribeFilter option to a list of doc IDs, returning the subset
@@ -526,7 +512,7 @@ class PatchesSync {
     return typeof err === "object" && err !== null && "code" in err && err.code === 410;
   }
 }
-_init = __decoratorStart(null);
+_init = __decoratorStart(_a);
 __decorateElement(_init, 1, "syncDoc", _syncDoc_dec, PatchesSync);
 __decorateElement(_init, 1, "_receiveCommittedChanges", __receiveCommittedChanges_dec, PatchesSync);
 __decoratorMetadata(_init, PatchesSync);

package/dist/net/http/FetchTransport.d.ts

@@ -1,4 +1,4 @@
-import { Signal } from '../../event-signal.js';
+import * as easy_signal from 'easy-signal';
 import { ClientTransport } from '../protocol/types.js';
 import '../../types.js';
 import '../../json-patch/JSONPatch.js';
@@ -11,7 +11,7 @@ import '../../json-patch/types.js';
 declare class FetchTransport implements ClientTransport {
     private url;
     private authHeader;
-    readonly onMessage: Signal<(raw: string) => void>;
+    readonly onMessage: easy_signal.Signal<(raw: string) => void>;
     private headers;
     constructor(url: string, authHeader: string);
     addHeadersToNextCall(headers: Record<string, string>): void;

package/dist/net/http/FetchTransport.js

@@ -1,5 +1,5 @@
 import "../../chunk-IZ2YBCUP.js";
-import { signal } from "../../event-signal.js";
+import { signal } from "easy-signal";
 import { rpcError } from "../protocol/utils.js";
 class FetchTransport {
   constructor(url, authHeader) {

package/dist/net/index.d.ts

@@ -13,11 +13,11 @@ export { JsonRpcMessage, SignalingService } from './websocket/SignalingService.j
 export { WebSocketServer, WebSocketServerOptions } from './websocket/WebSocketServer.js';
 export { WebSocketOptions, WebSocketTransport } from './websocket/WebSocketTransport.js';
 export { CommitChangesOptions } from '../types.js';
-import '../event-signal.js';
+import 'easy-signal';
 import '../algorithms/ot/shared/changeBatching.js';
 import '../client/ClientAlgorithm.js';
 import '../json-patch/types.js';
-import '../BaseDoc-vaMreJL5.js';
+import '../BaseDoc-BRIP2YZp.js';
 import '../client/PatchesStore.js';
 import '../client/Patches.js';
 import '../server/types.js';

package/dist/net/protocol/JSONRPCClient.d.ts

@@ -1,4 +1,4 @@
-import { SignalSubscriber, Unsubscriber } from '../../event-signal.js';
+import { SignalSubscriber, Unsubscriber } from 'easy-signal';
 import { ClientTransport } from './types.js';
 import '../../types.js';
 import '../../json-patch/JSONPatch.js';

package/dist/net/protocol/JSONRPCClient.js

@@ -1,5 +1,5 @@
 import "../../chunk-IZ2YBCUP.js";
-import { signal } from "../../event-signal.js";
+import { signal } from "easy-signal";
 import { JSONRPCParseError } from "../error.js";
 class JSONRPCClient {
   /**

package/dist/net/protocol/JSONRPCServer.d.ts

@@ -1,4 +1,4 @@
-import { Signal, Unsubscriber } from '../../event-signal.js';
+import { Signal, Unsubscriber } from 'easy-signal';
 import { AuthorizationProvider, AuthContext } from '../websocket/AuthorizationProvider.js';
 import { JsonRpcNotification, Message, JsonRpcResponse } from './types.js';
 import '../../server/types.js';

package/dist/net/protocol/JSONRPCServer.js

@@ -1,5 +1,5 @@
 import "../../chunk-IZ2YBCUP.js";
-import { signal } from "../../event-signal.js";
+import { signal } from "easy-signal";
 import { StatusError } from "../error.js";
 import { clearAuthContext, getAuthContext, setAuthContext } from "../serverContext.js";
 import { rpcError, rpcNotification, rpcResponse } from "./utils.js";

package/dist/net/protocol/types.d.ts

@@ -1,4 +1,4 @@
-import { Unsubscriber } from '../../event-signal.js';
+import { Unsubscriber } from 'easy-signal';
 import { PatchesState, Change, ChangeInput, CommitChangesOptions, EditableVersionMetadata, ListVersionsOptions, VersionMetadata } from '../../types.js';
 import '../../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/net/protocol/utils.d.ts

@@ -1,5 +1,5 @@
 import { JsonRpcResponse, JsonRpcNotification } from './types.js';
-import '../../event-signal.js';
+import 'easy-signal';
 import '../../types.js';
 import '../../json-patch/JSONPatch.js';
 import '@dabble/delta';

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

@@ -1,4 +1,4 @@
-import { Signal } from '../../event-signal.js';
+import * as easy_signal from 'easy-signal';
 import { WebRTCTransport } from './WebRTCTransport.js';
 import '../protocol/types.js';
 import '../../types.js';
@@ -29,7 +29,7 @@ declare class WebRTCAwareness<T extends AwarenessState = AwarenessState> {
      * Signal that emits when the awareness state is updated.
      * Subscribers receive the complete new awareness state array.
      */
-    readonly onUpdate: Signal<(states: T[]) => void>;
+    readonly onUpdate: easy_signal.Signal<(states: T[]) => void>;
     /**
      * The peer ID of this client, obtained from the WebRTC transport.
      */

package/dist/net/webrtc/WebRTCAwareness.js

@@ -1,5 +1,5 @@
 import "../../chunk-IZ2YBCUP.js";
-import { signal } from "../../event-signal.js";
+import { signal } from "easy-signal";
 class WebRTCAwareness {
   /**
    * Creates a new WebRTC awareness instance.

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

@@ -1,5 +1,5 @@
 import { ClientTransport, ConnectionState } from '../protocol/types.js';
-import { Signal } from '../../event-signal.js';
+import * as easy_signal from 'easy-signal';
 import Peer from 'simple-peer';
 import { WebSocketTransport } from '../websocket/WebSocketTransport.js';
 import '../../types.js';
@@ -23,22 +23,22 @@ declare class WebRTCTransport implements ClientTransport {
      * Signal that emits when a message is received from a peer.
      * Provides the message data, peer ID, and peer instance.
      */
-    readonly onMessage: Signal<(data: string, peerId: string, peer: Peer.Instance) => void>;
+    readonly onMessage: easy_signal.Signal<(data: string, peerId: string, peer: Peer.Instance) => void>;
     /**
      * Signal that emits when a new peer connection is established.
      * Provides the peer ID and peer instance.
      */
-    readonly onPeerConnect: Signal<(peerId: string, peer: Peer.Instance) => void>;
+    readonly onPeerConnect: easy_signal.Signal<(peerId: string, peer: Peer.Instance) => void>;
     /**
      * Signal that emits when a peer disconnects.
      * Provides the peer ID and peer instance.
      */
-    readonly onPeerDisconnect: Signal<(peerId: string, peer: Peer.Instance) => void>;
+    readonly onPeerDisconnect: easy_signal.Signal<(peerId: string, peer: Peer.Instance) => void>;
     /**
      * Signal that emits when the underlying signaling transport's state changes.
      * This is delegated directly from the WebSocketTransport.
      */
-    get onStateChange(): Signal<(state: ConnectionState) => void>;
+    get onStateChange(): easy_signal.Signal<(state: ConnectionState) => void>;
     /**
      * Creates a new WebRTC transport instance.
      * @param transport - The WebSocket transport to use for signaling

package/dist/net/webrtc/WebRTCTransport.js

@@ -1,6 +1,6 @@
 import "../../chunk-IZ2YBCUP.js";
 import Peer from "simple-peer";
-import { signal } from "../../event-signal.js";
+import { signal } from "easy-signal";
 import { JSONRPCClient } from "../../net/protocol/JSONRPCClient.js";
 import { rpcError } from "../protocol/utils.js";
 class WebRTCTransport {

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

@@ -1,6 +1,6 @@
 export { WebRTCAwareness } from './WebRTCAwareness.js';
 export { WebRTCTransport } from './WebRTCTransport.js';
-import '../../event-signal.js';
+import 'easy-signal';
 import '../protocol/types.js';
 import '../../types.js';
 import '../../json-patch/JSONPatch.js';

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

@@ -1,4 +1,4 @@
-import { Signal } from '../../event-signal.js';
+import { Signal } from 'easy-signal';
 import { PatchesClient } from '../PatchesClient.js';
 import { ConnectionState } from '../protocol/types.js';
 import { WebSocketTransport, WebSocketOptions } from './WebSocketTransport.js';

package/dist/net/websocket/PatchesWebSocket.js

@@ -1,5 +1,5 @@
 import "../../chunk-IZ2YBCUP.js";
-import {} from "../../event-signal.js";
+import {} from "easy-signal";
 import { PatchesClient } from "../PatchesClient.js";
 import { WebSocketTransport } from "./WebSocketTransport.js";
 class PatchesWebSocket extends PatchesClient {

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

@@ -1,5 +1,5 @@
 import { JsonRpcRequest, JsonRpcResponse } from '../protocol/types.js';
-import '../../event-signal.js';
+import 'easy-signal';
 import '../../types.js';
 import '../../json-patch/JSONPatch.js';
 import '@dabble/delta';

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

@@ -1,7 +1,7 @@
 import { JSONRPCServer } from '../protocol/JSONRPCServer.js';
 import { ServerTransport } from '../protocol/types.js';
 import { AuthorizationProvider, AuthContext } from './AuthorizationProvider.js';
-import '../../event-signal.js';
+import 'easy-signal';
 import '../../server/types.js';
 import '../../json-patch/types.js';
 import '../../types.js';

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

@@ -1,4 +1,5 @@
-import { Unsubscriber, Signal } from '../../event-signal.js';
+import * as easy_signal from 'easy-signal';
+import { Unsubscriber } from 'easy-signal';
 import { Deferred } from '../../utils/deferred.js';
 import { ClientTransport, ConnectionState } from '../protocol/types.js';
 import '../../types.js';
@@ -30,12 +31,12 @@ declare class WebSocketTransport implements ClientTransport {
      * Signal that emits when the connection state changes.
      * Subscribers will receive the new connection state as an argument.
      */
-    readonly onStateChange: Signal<(state: ConnectionState) => void>;
+    readonly onStateChange: easy_signal.Signal<(state: ConnectionState) => void>;
     /**
      * Signal that emits when a message is received from the transport.
      * Subscribers will receive the message data as a string.
      */
-    readonly onMessage: Signal<(data: string) => void>;
+    readonly onMessage: easy_signal.Signal<(data: string) => void>;
     /**
      * Creates a new WebSocket transport instance.
      * @param url - The WebSocket server URL to connect to

package/dist/net/websocket/WebSocketTransport.js

@@ -1,5 +1,5 @@
 import "../../chunk-IZ2YBCUP.js";
-import { signal } from "../../event-signal.js";
+import { signal } from "easy-signal";
 import { deferred } from "../../utils/deferred.js";
 import { onlineState } from "./onlineState.js";
 class WebSocketTransport {

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

@@ -1,7 +1,7 @@
-import { Signal } from '../../event-signal.js';
+import * as easy_signal from 'easy-signal';
 
 declare class OnlineState {
-    onOnlineChange: Signal<(isOnline: boolean) => void>;
+    onOnlineChange: easy_signal.Signal<(isOnline: boolean) => void>;
     protected _isOnline: boolean;
     constructor();
     get isOnline(): boolean;

package/dist/net/websocket/onlineState.js

@@ -1,5 +1,5 @@
 import "../../chunk-IZ2YBCUP.js";
-import { signal } from "../../event-signal.js";
+import { signal } from "easy-signal";
 class OnlineState {
   onOnlineChange = signal();
   _isOnline = typeof navigator !== "undefined" && navigator.onLine;

package/dist/server/LWWBranchManager.d.ts

@@ -3,7 +3,7 @@ import { Branch, EditableBranchMetadata, BranchStatus, Change } from '../types.j
 import { BranchManager } from './BranchManager.js';
 import { LWWServer } from './LWWServer.js';
 import { LWWStoreBackend, BranchingStoreBackend } from './types.js';
-import '../event-signal.js';
+import 'easy-signal';
 import '../net/websocket/AuthorizationProvider.js';
 import '../json-patch/types.js';
 import '../json-patch/JSONPatch.js';