@dabble/patches 0.4.5 → 0.4.6

package/dist/net/webrtc/WebRTCAwareness.js

@@ -1,124 +1,115 @@
-import { signal } from '../../event-signal.js';
-/**
- * Implements the awareness protocol over WebRTC to synchronize peer states.
- * Awareness allows peers to share real-time information about their current state,
- * such as cursor position, selection, user info, or any other application-specific data.
- *
- * @template T - The type of awareness state to be shared between peers
- */
-export class WebRTCAwareness {
-    transport;
-    _states = [];
-    _localState = {};
-    /**
-     * Signal that emits when the awareness state is updated.
-     * Subscribers receive the complete new awareness state array.
-     */
-    onUpdate = signal();
-    /**
-     * The peer ID of this client, obtained from the WebRTC transport.
-     */
-    myId;
-    /**
-     * Creates a new WebRTC awareness instance.
-     * @param transport - The WebRTC transport to use for awareness communication
-     */
-    constructor(transport) {
-        this.transport = transport;
-        this.transport.onPeerConnect(this._addPeer.bind(this));
-        this.transport.onPeerDisconnect(this._removePeer.bind(this));
-        this.transport.onMessage(this._receiveData.bind(this));
+import "../../chunk-IZ2YBCUP.js";
+import { signal } from "../../event-signal.js";
+class WebRTCAwareness {
+  /**
+   * Creates a new WebRTC awareness instance.
+   * @param transport - The WebRTC transport to use for awareness communication
+   */
+  constructor(transport) {
+    this.transport = transport;
+    this.transport.onPeerConnect(this._addPeer.bind(this));
+    this.transport.onPeerDisconnect(this._removePeer.bind(this));
+    this.transport.onMessage(this._receiveData.bind(this));
+  }
+  _states = [];
+  _localState = {};
+  /**
+   * Signal that emits when the awareness state is updated.
+   * Subscribers receive the complete new awareness state array.
+   */
+  onUpdate = signal();
+  /**
+   * The peer ID of this client, obtained from the WebRTC transport.
+   */
+  myId;
+  /**
+   * Connects to the WebRTC network to start synchronizing awareness states.
+   * @returns A promise that resolves when the connection is established
+   */
+  async connect() {
+    await this.transport.connect();
+    this.myId = this.transport.id;
+  }
+  /**
+   * Disconnects from the WebRTC network and stops awareness synchronization.
+   */
+  disconnect() {
+    this.transport.disconnect();
+  }
+  /**
+   * Gets the current combined awareness state of all peers.
+   * @returns An array of awareness states from all connected peers
+   */
+  get states() {
+    return this._states;
+  }
+  /**
+   * Sets the combined awareness state and emits an update event.
+   * This method is protected and typically used internally.
+   * @param state - The new combined awareness state array
+   */
+  set states(state) {
+    this._states = state;
+    this.onUpdate.emit(this._states);
+  }
+  /**
+   * Gets this peer's local awareness state.
+   * @returns The current local awareness state
+   */
+  get localState() {
+    return this._localState;
+  }
+  /**
+   * Sets this peer's local awareness state and broadcasts it to all connected peers.
+   * @param value - The new local awareness state to set and broadcast
+   */
+  set localState(value) {
+    value.id = this.myId;
+    this._localState = value;
+    this.transport.send(JSON.stringify(value));
+  }
+  /**
+   * Handles a new peer connection by sending the local state to the new peer.
+   * @private
+   * @param peerId - ID of the newly connected peer
+   */
+  _addPeer(peerId) {
+    if (this._localState.id) {
+      this.transport.send(JSON.stringify(this._localState), peerId);
     }
-    /**
-     * Connects to the WebRTC network to start synchronizing awareness states.
-     * @returns A promise that resolves when the connection is established
-     */
-    async connect() {
-        await this.transport.connect();
-        // Get the peer ID from the transport after connection
-        this.myId = this.transport.id;
+  }
+  /**
+   * Handles a peer disconnection by removing their state from the awareness state.
+   * @private
+   * @param peerId - ID of the disconnected peer
+   */
+  _removePeer(peerId) {
+    this.states = this.states.filter((s) => s.id !== peerId);
+  }
+  /**
+   * Processes incoming awareness data from other peers.
+   * @private
+   * @param data - The serialized awareness state data received from a peer
+   */
+  _receiveData(data) {
+    let peerState;
+    try {
+      peerState = JSON.parse(data);
+      if (!peerState?.id) return;
+    } catch (err) {
+      console.error("Invalid peer data:", err);
+      return;
     }
-    /**
-     * Disconnects from the WebRTC network and stops awareness synchronization.
-     */
-    disconnect() {
-        this.transport.disconnect();
-    }
-    /**
-     * Gets the current combined awareness state of all peers.
-     * @returns An array of awareness states from all connected peers
-     */
-    get states() {
-        return this._states;
-    }
-    /**
-     * Sets the combined awareness state and emits an update event.
-     * This method is protected and typically used internally.
-     * @param state - The new combined awareness state array
-     */
-    set states(state) {
-        this._states = state;
-        this.onUpdate.emit(this._states);
-    }
-    /**
-     * Gets this peer's local awareness state.
-     * @returns The current local awareness state
-     */
-    get localState() {
-        return this._localState;
-    }
-    /**
-     * Sets this peer's local awareness state and broadcasts it to all connected peers.
-     * @param value - The new local awareness state to set and broadcast
-     */
-    set localState(value) {
-        value.id = this.myId;
-        this._localState = value;
-        this.transport.send(JSON.stringify(value));
-    }
-    /**
-     * Handles a new peer connection by sending the local state to the new peer.
-     * @private
-     * @param peerId - ID of the newly connected peer
-     */
-    _addPeer(peerId) {
-        // If localState has been set (id will exist once set)
-        if (this._localState.id) {
-            this.transport.send(JSON.stringify(this._localState), peerId);
-        }
-    }
-    /**
-     * Handles a peer disconnection by removing their state from the awareness state.
-     * @private
-     * @param peerId - ID of the disconnected peer
-     */
-    _removePeer(peerId) {
-        this.states = this.states.filter(s => s.id !== peerId);
-    }
-    /**
-     * Processes incoming awareness data from other peers.
-     * @private
-     * @param data - The serialized awareness state data received from a peer
-     */
-    _receiveData(data) {
-        let peerState;
-        try {
-            peerState = JSON.parse(data);
-            if (!peerState?.id)
-                return;
-        }
-        catch (err) {
-            console.error('Invalid peer data:', err);
-            return;
-        }
-        const update = [...this.states];
-        const existingIndex = update.findIndex(s => s.id === peerState.id);
-        if (existingIndex !== -1) {
-            update.splice(existingIndex, 1, { ...update[existingIndex], ...peerState });
-        }
-        else {
-            update.push(peerState);
-        }
-        this.states = update;
+    const update = [...this.states];
+    const existingIndex = update.findIndex((s) => s.id === peerState.id);
+    if (existingIndex !== -1) {
+      update.splice(existingIndex, 1, { ...update[existingIndex], ...peerState });
+    } else {
+      update.push(peerState);
     }
+    this.states = update;
+  }
 }
+export {
+  WebRTCAwareness
+};

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

@@ -1,12 +1,18 @@
+import { ClientTransport, ConnectionState } from '../protocol/types.js';
+import { Signal } from '../../event-signal.js';
 import Peer from 'simple-peer';
-import type { ClientTransport } from '../protocol/types.js';
-import type { WebSocketTransport } from '../websocket/WebSocketTransport.js';
+import { WebSocketTransport } from '../websocket/WebSocketTransport.js';
+import '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+
 /**
  * WebRTC-based transport implementation that enables direct peer-to-peer communication.
  * Uses a WebSocket transport as a signaling channel to establish WebRTC connections.
  * Once connections are established, data flows directly between peers without going through a server.
  */
-export declare class WebRTCTransport implements ClientTransport {
+declare class WebRTCTransport implements ClientTransport {
     private transport;
     private rpc;
     private peers;
@@ -16,22 +22,22 @@ export 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: import("../../event-signal.js").Signal<(data: string, peerId: string, peer: Peer.Instance) => void>;
+    readonly onMessage: 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: import("../../event-signal.js").Signal<(peerId: string, peer: Peer.Instance) => void>;
+    readonly onPeerConnect: Signal<(peerId: string, peer: Peer.Instance) => void>;
     /**
      * Signal that emits when a peer disconnects.
      * Provides the peer ID and peer instance.
      */
-    readonly onPeerDisconnect: import("../../event-signal.js").Signal<(peerId: string, peer: Peer.Instance) => void>;
+    readonly onPeerDisconnect: 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(): import("../../event-signal.js").Signal<(state: import("../protocol/types.js").ConnectionState) => void>;
+    get onStateChange(): Signal<(state: ConnectionState) => void>;
     /**
      * Creates a new WebRTC transport instance.
      * @param transport - The WebSocket transport to use for signaling
@@ -46,7 +52,7 @@ export declare class WebRTCTransport implements ClientTransport {
      * Gets the current connection state of the underlying signaling transport.
      * @returns The current connection state
      */
-    get state(): import("../protocol/types.js").ConnectionState;
+    get state(): ConnectionState;
     /**
      * Establishes the connection by connecting to the signaling server.
      * Peer connections will be established automatically after this.
@@ -78,3 +84,5 @@ export declare class WebRTCTransport implements ClientTransport {
      */
     private _removePeer;
 }
+
+export { WebRTCTransport };

package/dist/net/webrtc/WebRTCTransport.js

@@ -1,161 +1,153 @@
-import Peer from 'simple-peer';
-import { signal } from '../../event-signal.js';
-import { JSONRPCClient } from '../../net/protocol/JSONRPCClient.js';
-/**
- * WebRTC-based transport implementation that enables direct peer-to-peer communication.
- * Uses a WebSocket transport as a signaling channel to establish WebRTC connections.
- * Once connections are established, data flows directly between peers without going through a server.
- */
-export class WebRTCTransport {
-    transport;
-    rpc;
-    peers = new Map();
-    _id;
-    subscriptions;
-    /**
-     * Signal that emits when a message is received from a peer.
-     * Provides the message data, peer ID, and peer instance.
-     */
-    onMessage = signal();
-    /**
-     * Signal that emits when a new peer connection is established.
-     * Provides the peer ID and peer instance.
-     */
-    onPeerConnect = signal();
-    /**
-     * Signal that emits when a peer disconnects.
-     * Provides the peer ID and peer instance.
-     */
-    onPeerDisconnect = signal();
-    /**
-     * Signal that emits when the underlying signaling transport's state changes.
-     * This is delegated directly from the WebSocketTransport.
-     */
-    get onStateChange() {
-        return this.transport.onStateChange;
-    }
-    /**
-     * Creates a new WebRTC transport instance.
-     * @param transport - The WebSocket transport to use for signaling
-     */
-    constructor(transport) {
-        this.transport = transport;
-        this.rpc = new JSONRPCClient(transport);
-        this.subscriptions = [
-            this.rpc.on('peer-welcome', ({ id, peers }) => {
-                this._id = id;
-                peers.forEach((peerId) => this._connectToPeer(peerId, true));
-            }),
-            this.rpc.on('peer-disconnected', ({ id }) => {
-                this._removePeer(id);
-            }),
-            this.rpc.on('peer-signal', ({ from, data }) => {
-                if (!this.peers.has(from)) {
-                    this._connectToPeer(from, false);
-                }
-                this.peers.get(from)?.peer.signal(data);
-            }),
-        ];
-    }
-    /**
-     * Gets the unique ID assigned to this peer by the signaling server.
-     * @returns The peer ID, or undefined if not yet connected
-     */
-    get id() {
-        return this._id;
-    }
-    /**
-     * Gets the current connection state of the underlying signaling transport.
-     * @returns The current connection state
-     */
-    get state() {
-        return this.transport.state;
-    }
-    /**
-     * Establishes the connection by connecting to the signaling server.
-     * Peer connections will be established automatically after this.
-     * @returns A promise that resolves when connected to the signaling server
-     */
-    async connect() {
-        await this.transport.connect();
-    }
-    /**
-     * Terminates the connection for this transport.
-     * Must be implemented by concrete subclasses.
-     */
-    disconnect() {
-        this.subscriptions.forEach(u => u());
-        this.subscriptions.length = 0;
-        // Call _removePeer for each peer, which handles destroy()
-        const peerIds = Array.from(this.peers.keys());
-        peerIds.forEach(peerId => this._removePeer(peerId));
-        // Ensure the map is clear after removal
-        this.peers.clear();
-        // Disconnect the underlying transport if needed (optional, depends on desired behavior)
-        // this.transport.disconnect();
-    }
-    /**
-     * Sends data to one or all connected peers.
-     * @param data - The string data to send
-     * @param peerId - Optional ID of specific peer to send to; if omitted, sends to all peers
-     */
-    send(data, peerId) {
-        for (const info of this.peers.values()) {
-            if (peerId && info.id !== peerId)
-                continue;
-            if (info.connected) {
-                try {
-                    info.peer.send(data);
-                }
-                catch (e) {
-                    console.warn('Failed to send to peer:', e);
-                }
-            }
+import "../../chunk-IZ2YBCUP.js";
+import Peer from "simple-peer";
+import { signal } from "../../event-signal.js";
+import { JSONRPCClient } from "../../net/protocol/JSONRPCClient.js";
+import { rpcError } from "../protocol/utils.js";
+class WebRTCTransport {
+  /**
+   * Creates a new WebRTC transport instance.
+   * @param transport - The WebSocket transport to use for signaling
+   */
+  constructor(transport) {
+    this.transport = transport;
+    this.rpc = new JSONRPCClient(transport);
+    this.subscriptions = [
+      this.rpc.on("peer-welcome", ({ id, peers }) => {
+        this._id = id;
+        peers.forEach((peerId) => this._connectToPeer(peerId, true));
+      }),
+      this.rpc.on("peer-disconnected", ({ id }) => {
+        this._removePeer(id);
+      }),
+      this.rpc.on("peer-signal", ({ from, data }) => {
+        if (!this.peers.has(from)) {
+          this._connectToPeer(from, false);
         }
-    }
-    /**
-     * Establishes a WebRTC connection to a peer.
-     * @private
-     * @param peerId - ID of the peer to connect to
-     * @param initiator - Whether this peer is initiating the connection
-     */
-    _connectToPeer(peerId, initiator) {
-        const peer = new Peer({ initiator, trickle: false });
-        peer.on('signal', data => {
-            this.rpc.request('peer-signal', { to: peerId, data });
-        });
-        peer.on('connect', () => {
-            this.peers.set(peerId, { id: peerId, peer, connected: true });
-            this.onPeerConnect.emit(peerId, peer);
-        });
-        peer.on('data', raw => {
-            try {
-                this.onMessage.emit(raw, peerId, peer);
-            }
-            catch (e) {
-                console.error('Invalid peer data:', e);
-            }
-        });
-        peer.on('close', () => {
-            this._removePeer(peerId);
-        });
-        peer.on('error', err => {
-            console.error('Peer error:', err);
-            this._removePeer(peerId);
-        });
-        this.peers.set(peerId, { id: peerId, peer, connected: false });
-    }
-    /**
-     * Removes a peer from the connection pool and cleans up resources.
-     * @private
-     * @param peerId - ID of the peer to remove
-     */
-    _removePeer(peerId) {
-        const info = this.peers.get(peerId);
-        if (info) {
-            this.peers.delete(peerId);
-            this.onPeerDisconnect.emit(peerId, info.peer);
-            info.peer.destroy();
+        this.peers.get(from)?.peer.signal(data);
+      })
+    ];
+  }
+  rpc;
+  peers = /* @__PURE__ */ new Map();
+  _id;
+  subscriptions;
+  /**
+   * Signal that emits when a message is received from a peer.
+   * Provides the message data, peer ID, and peer instance.
+   */
+  onMessage = signal();
+  /**
+   * Signal that emits when a new peer connection is established.
+   * Provides the peer ID and peer instance.
+   */
+  onPeerConnect = signal();
+  /**
+   * Signal that emits when a peer disconnects.
+   * Provides the peer ID and peer instance.
+   */
+  onPeerDisconnect = signal();
+  /**
+   * Signal that emits when the underlying signaling transport's state changes.
+   * This is delegated directly from the WebSocketTransport.
+   */
+  get onStateChange() {
+    return this.transport.onStateChange;
+  }
+  /**
+   * Gets the unique ID assigned to this peer by the signaling server.
+   * @returns The peer ID, or undefined if not yet connected
+   */
+  get id() {
+    return this._id;
+  }
+  /**
+   * Gets the current connection state of the underlying signaling transport.
+   * @returns The current connection state
+   */
+  get state() {
+    return this.transport.state;
+  }
+  /**
+   * Establishes the connection by connecting to the signaling server.
+   * Peer connections will be established automatically after this.
+   * @returns A promise that resolves when connected to the signaling server
+   */
+  async connect() {
+    await this.transport.connect();
+  }
+  /**
+   * Terminates the connection for this transport.
+   * Must be implemented by concrete subclasses.
+   */
+  disconnect() {
+    this.subscriptions.forEach((u) => u());
+    this.subscriptions.length = 0;
+    const peerIds = Array.from(this.peers.keys());
+    peerIds.forEach((peerId) => this._removePeer(peerId));
+    this.peers.clear();
+  }
+  /**
+   * Sends data to one or all connected peers.
+   * @param data - The string data to send
+   * @param peerId - Optional ID of specific peer to send to; if omitted, sends to all peers
+   */
+  send(data, peerId) {
+    for (const info of this.peers.values()) {
+      if (peerId && info.id !== peerId) continue;
+      if (info.connected) {
+        try {
+          info.peer.send(data);
+        } catch (e) {
+          this.onMessage.emit(JSON.stringify(rpcError(-32e3, e.message)), peerId, info.peer);
         }
+      }
+    }
+  }
+  /**
+   * Establishes a WebRTC connection to a peer.
+   * @private
+   * @param peerId - ID of the peer to connect to
+   * @param initiator - Whether this peer is initiating the connection
+   */
+  _connectToPeer(peerId, initiator) {
+    const peer = new Peer({ initiator, trickle: false });
+    peer.on("signal", (data) => {
+      this.rpc.call("peer-signal", { to: peerId, data });
+    });
+    peer.on("connect", () => {
+      this.peers.set(peerId, { id: peerId, peer, connected: true });
+      this.onPeerConnect.emit(peerId, peer);
+    });
+    peer.on("data", (raw) => {
+      try {
+        this.onMessage.emit(raw, peerId, peer);
+      } catch (e) {
+        this.onMessage.emit(JSON.stringify(rpcError(-32700, "Parse error", e)), peerId, peer);
+      }
+    });
+    peer.on("close", () => {
+      this._removePeer(peerId);
+    });
+    peer.on("error", (err) => {
+      this.onMessage.emit(JSON.stringify(rpcError(-32e3, err.message)), peerId, peer);
+      this._removePeer(peerId);
+    });
+    this.peers.set(peerId, { id: peerId, peer, connected: false });
+  }
+  /**
+   * Removes a peer from the connection pool and cleans up resources.
+   * @private
+   * @param peerId - ID of the peer to remove
+   */
+  _removePeer(peerId) {
+    const info = this.peers.get(peerId);
+    if (info) {
+      this.peers.delete(peerId);
+      this.onPeerDisconnect.emit(peerId, info.peer);
+      info.peer.destroy();
     }
+  }
 }
+export {
+  WebRTCTransport
+};

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

@@ -1,2 +1,10 @@
-export * from './WebRTCAwareness.js';
-export * from './WebRTCTransport.js';
+export { WebRTCAwareness } from './WebRTCAwareness.js';
+export { WebRTCTransport } from './WebRTCTransport.js';
+import '../../event-signal.js';
+import '../protocol/types.js';
+import '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+import 'simple-peer';
+import '../websocket/WebSocketTransport.js';

package/dist/net/webrtc/index.js

@@ -1,2 +1,2 @@
-export * from './WebRTCAwareness.js';
-export * from './WebRTCTransport.js';
+export * from "./WebRTCAwareness.js";
+export * from "./WebRTCTransport.js";

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

@@ -4,13 +4,13 @@
  * "read"  – non-mutating operations (subscribe, getDoc, listVersions, …)
  * "write" – mutating operations (commitChanges, deleteDoc, …)
  */
-export type Access = 'read' | 'write';
+type Access = 'read' | 'write';
 /**
  * Context object for authorization providers.
  * @property {string} clientId - The ID of the client making the request.
  * @property {any} [data] - Additional data associated with the request.
  */
-export interface AuthContext {
+interface AuthContext {
     clientId?: string;
     [k: string]: any;
 }
@@ -20,7 +20,7 @@ export interface AuthContext {
  * specific – they may look at a JWT decoded during the WebSocket handshake,
  * consult an ACL service, inspect the actual RPC method, etc.
  */
-export interface AuthorizationProvider<T extends AuthContext = AuthContext> {
+interface AuthorizationProvider<T extends AuthContext = AuthContext> {
     /**
      * General-purpose hook executed for every JSON-RPC call that targets a
      * document. Implementations are free to look only at the first three
@@ -44,10 +44,12 @@ export interface AuthorizationProvider<T extends AuthContext = AuthContext> {
  * WARNING: This should only be used for development/testing purposes.
  * Never use this in production as it allows unrestricted access.
  */
-export declare const allowAll: AuthorizationProvider;
+declare const allowAll: AuthorizationProvider;
 /**
  * A secure default provider that denies all access.
  * This forces developers to explicitly implement proper authorization.
  * Use this as the default to ensure security by default.
  */
-export declare const denyAll: AuthorizationProvider;
+declare const denyAll: AuthorizationProvider;
+
+export { type Access, type AuthContext, type AuthorizationProvider, allowAll, denyAll };