@dabble/patches 0.4.5 → 0.4.6

package/dist/net/websocket/SignalingService.js

@@ -1,138 +1,131 @@
-import { createId } from 'crypto-id';
-/**
- * Service that facilitates WebRTC connection establishment by relaying signaling messages.
- * Acts as a central hub for WebRTC peers to exchange connection information.
- */
-export class SignalingService {
-    clients = new Map();
-    /**
-     * Registers a new client connection with the signaling service.
-     * Assigns a unique ID to the client and informs them of other connected peers.
-     *
-     * @param send - Function to send messages to this client
-     * @param id - Optional client ID (generated if not provided)
-     * @returns The client's assigned ID
-     */
-    onClientConnected(send, id = createId(14)) {
-        this.clients.set(id, { send });
-        const welcome = {
-            jsonrpc: '2.0',
-            method: 'peer-welcome',
-            params: {
-                id,
-                peers: Array.from(this.clients.keys()).filter(pid => pid !== id),
-            },
-        };
-        send(welcome);
-        return id;
+import "../../chunk-IZ2YBCUP.js";
+import { createId } from "crypto-id";
+class SignalingService {
+  clients = /* @__PURE__ */ new Map();
+  /**
+   * Registers a new client connection with the signaling service.
+   * Assigns a unique ID to the client and informs them of other connected peers.
+   *
+   * @param send - Function to send messages to this client
+   * @param id - Optional client ID (generated if not provided)
+   * @returns The client's assigned ID
+   */
+  onClientConnected(send, id = createId(14)) {
+    this.clients.set(id, { send });
+    const welcome = {
+      jsonrpc: "2.0",
+      method: "peer-welcome",
+      params: {
+        id,
+        peers: Array.from(this.clients.keys()).filter((pid) => pid !== id)
+      }
+    };
+    send(welcome);
+    return id;
+  }
+  /**
+   * Handles a client disconnection by removing them from the registry
+   * and notifying all other connected clients.
+   *
+   * @param id - ID of the disconnected client
+   */
+  onClientDisconnected(id) {
+    this.clients.delete(id);
+    this.broadcast({
+      jsonrpc: "2.0",
+      method: "peer-disconnected",
+      params: { id }
+    });
+  }
+  /**
+   * Handles a signaling message from a client, relaying WebRTC session data
+   * between peers to facilitate connection establishment.
+   *
+   * @param fromId - ID of the client sending the message
+   * @param message - The JSON-RPC message or its string representation
+   * @returns True if the message was a valid signaling message and was handled, false otherwise
+   */
+  handleClientMessage(fromId, message) {
+    let parsed;
+    try {
+      parsed = typeof message === "string" ? JSON.parse(message) : message;
+    } catch {
+      return false;
     }
-    /**
-     * Handles a client disconnection by removing them from the registry
-     * and notifying all other connected clients.
-     *
-     * @param id - ID of the disconnected client
-     */
-    onClientDisconnected(id) {
-        this.clients.delete(id);
-        // Broadcast to all others
-        this.broadcast({
-            jsonrpc: '2.0',
-            method: 'peer-disconnected',
-            params: { id },
-        });
+    if (parsed.jsonrpc !== "2.0" || parsed.method !== "peer-signal" || !parsed.params?.to) return false;
+    const { params, id } = parsed;
+    const { to, data } = params;
+    const target = this.clients.get(to);
+    if (!target) {
+      this.respondError(fromId, id, "Target not connected");
+      return true;
     }
-    /**
-     * Handles a signaling message from a client, relaying WebRTC session data
-     * between peers to facilitate connection establishment.
-     *
-     * @param fromId - ID of the client sending the message
-     * @param message - The JSON-RPC message or its string representation
-     * @returns True if the message was a valid signaling message and was handled, false otherwise
-     */
-    handleClientMessage(fromId, message) {
-        let parsed;
-        try {
-            parsed = typeof message === 'string' ? JSON.parse(message) : message;
-        }
-        catch {
-            return false;
-        }
-        if (parsed.jsonrpc !== '2.0' || parsed.method !== 'peer-signal' || !parsed.params?.to)
-            return false;
-        const { params, id } = parsed;
-        const { to, data } = params;
-        const target = this.clients.get(to);
-        if (!target) {
-            this.respondError(fromId, id, 'Target not connected');
-            // Was a signaling message, even if the target is not connected
-            return true;
-        }
-        const outbound = {
-            jsonrpc: '2.0',
-            method: 'signal',
-            params: {
-                from: fromId,
-                data,
-            },
-        };
-        target.send(outbound);
-        if (id !== undefined) {
-            this.respond(fromId, id, 'ok');
-        }
-        return true;
+    const outbound = {
+      jsonrpc: "2.0",
+      method: "signal",
+      params: {
+        from: fromId,
+        data
+      }
+    };
+    target.send(outbound);
+    if (id !== void 0) {
+      this.respond(fromId, id, "ok");
     }
-    /**
-     * Sends a successful JSON-RPC response to a client.
-     *
-     * @private
-     * @param toId - ID of the client to send the response to
-     * @param id - Request ID to match in the response
-     * @param result - Result data to include in the response
-     */
-    respond(toId, id, result) {
-        const client = this.clients.get(toId);
-        if (!client)
-            return;
-        const response = {
-            jsonrpc: '2.0',
-            result,
-            id,
-        };
-        client.send(response);
-    }
-    /**
-     * Sends an error JSON-RPC response to a client.
-     *
-     * @private
-     * @param toId - ID of the client to send the error response to
-     * @param id - Request ID to match in the response, or undefined for notifications
-     * @param message - Error message to include
-     */
-    respondError(toId, id, message) {
-        if (id === undefined)
-            return;
-        const client = this.clients.get(toId);
-        if (!client)
-            return;
-        const response = {
-            jsonrpc: '2.0',
-            error: { code: -32000, message },
-            id,
-        };
-        client.send(response);
-    }
-    /**
-     * Broadcasts a message to all connected clients, optionally excluding one.
-     *
-     * @private
-     * @param message - The message to broadcast
-     * @param excludeId - Optional ID of a client to exclude from the broadcast
-     */
-    broadcast(message, excludeId) {
-        for (const [id, client] of this.clients.entries()) {
-            if (id !== excludeId) {
-                client.send(message);
-            }
-        }
+    return true;
+  }
+  /**
+   * Sends a successful JSON-RPC response to a client.
+   *
+   * @private
+   * @param toId - ID of the client to send the response to
+   * @param id - Request ID to match in the response
+   * @param result - Result data to include in the response
+   */
+  respond(toId, id, result) {
+    const client = this.clients.get(toId);
+    if (!client) return;
+    const response = {
+      jsonrpc: "2.0",
+      result,
+      id
+    };
+    client.send(response);
+  }
+  /**
+   * Sends an error JSON-RPC response to a client.
+   *
+   * @private
+   * @param toId - ID of the client to send the error response to
+   * @param id - Request ID to match in the response, or undefined for notifications
+   * @param message - Error message to include
+   */
+  respondError(toId, id, message) {
+    if (id === void 0) return;
+    const client = this.clients.get(toId);
+    if (!client) return;
+    const response = {
+      jsonrpc: "2.0",
+      error: { code: -32e3, message },
+      id
+    };
+    client.send(response);
+  }
+  /**
+   * Broadcasts a message to all connected clients, optionally excluding one.
+   *
+   * @private
+   * @param message - The message to broadcast
+   * @param excludeId - Optional ID of a client to exclude from the broadcast
+   */
+  broadcast(message, excludeId) {
+    for (const [id, client] of this.clients.entries()) {
+      if (id !== excludeId) {
+        client.send(message);
+      }
     }
+  }
 }
+export {
+  SignalingService
+};

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

@@ -1,12 +1,23 @@
-import type { ServerTransport } from '../protocol/types.js';
-import { type AuthContext, type AuthorizationProvider } from './AuthorizationProvider.js';
-import type { RPCServer } from './RPCServer.js';
+import { ServerTransport } from '../protocol/types.js';
+import { AuthorizationProvider, AuthContext } from './AuthorizationProvider.js';
+import { RPCServer } from './RPCServer.js';
+import '../../event-signal.js';
+import '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+import '../../server/PatchesBranchManager.js';
+import '../../server/PatchesServer.js';
+import '../../server/types.js';
+import '../../server/PatchesHistoryManager.js';
+import '../protocol/JSONRPCServer.js';
+
 /**
  * High-level client for the Patches real-time collaboration service.
  * This class provides document subscription, patch notification handling,
  * versioning, and other OT-specific functionality over a WebSocket connection.
  */
-export declare class WebSocketServer {
+declare class WebSocketServer {
     protected transport: ServerTransport;
     protected auth: AuthorizationProvider;
     /**
@@ -34,3 +45,5 @@ export declare class WebSocketServer {
         ids: string | string[];
     }, ctx?: AuthContext): Promise<string[]>;
 }
+
+export { WebSocketServer };

package/dist/net/websocket/WebSocketServer.js

@@ -1,75 +1,67 @@
-import { denyAll } from './AuthorizationProvider.js';
-/**
- * High-level client for the Patches real-time collaboration service.
- * This class provides document subscription, patch notification handling,
- * versioning, and other OT-specific functionality over a WebSocket connection.
- */
-export class WebSocketServer {
-    transport;
-    auth;
-    /**
-     * Creates a new Patches WebSocket client instance.
-     *
-     * @param transport - The transport layer implementation that will be used for sending/receiving messages
-     */
-    constructor(transport, rpcServer) {
-        this.transport = transport;
-        const { rpc, auth } = rpcServer;
-        this.auth = auth || denyAll;
-        // Subscription operations
-        rpc.registerMethod('subscribe', this.subscribe.bind(this));
-        rpc.registerMethod('unsubscribe', this.unsubscribe.bind(this));
-        rpc.onNotify(async (msg) => {
-            if (!msg.params?.docId)
-                return;
-            const { docId } = msg.params;
-            const msgString = JSON.stringify(msg);
-            const clientIds = await this.transport.listSubscriptions(docId);
-            clientIds.forEach(clientId => {
-                this.transport.send(clientId, msgString);
-            });
-        });
-    }
-    /**
-     * Subscribes the client to one or more documents to receive real-time updates.
-     * @param connectionId - The ID of the connection making the request
-     * @param params - The subscription parameters
-     * @param params.ids - Document ID or IDs to subscribe to
-     */
-    async subscribe(params, ctx) {
-        if (!ctx?.clientId)
-            return [];
-        const { ids } = params;
-        const allIds = Array.isArray(ids) ? ids : [ids];
-        const allowed = [];
-        await Promise.all(allIds.map(async (id) => {
-            try {
-                if (await this.auth.canAccess(ctx, id, 'read', 'subscribe', params)) {
-                    allowed.push(id);
-                }
-            }
-            catch {
-                // Treat exceptions from the provider as a denial for this doc
-            }
-        }));
-        if (allowed.length === 0) {
-            return [];
+import "../../chunk-IZ2YBCUP.js";
+import { denyAll } from "./AuthorizationProvider.js";
+class WebSocketServer {
+  transport;
+  auth;
+  /**
+   * Creates a new Patches WebSocket client instance.
+   *
+   * @param transport - The transport layer implementation that will be used for sending/receiving messages
+   */
+  constructor(transport, rpcServer) {
+    this.transport = transport;
+    const { rpc, auth } = rpcServer;
+    this.auth = auth || denyAll;
+    rpc.registerMethod("subscribe", this.subscribe.bind(this));
+    rpc.registerMethod("unsubscribe", this.unsubscribe.bind(this));
+    rpc.onNotify(async (msg) => {
+      if (!msg.params?.docId) return;
+      const { docId } = msg.params;
+      const msgString = JSON.stringify(msg);
+      const clientIds = await this.transport.listSubscriptions(docId);
+      clientIds.forEach((clientId) => {
+        this.transport.send(clientId, msgString);
+      });
+    });
+  }
+  /**
+   * Subscribes the client to one or more documents to receive real-time updates.
+   * @param connectionId - The ID of the connection making the request
+   * @param params - The subscription parameters
+   * @param params.ids - Document ID or IDs to subscribe to
+   */
+  async subscribe(params, ctx) {
+    if (!ctx?.clientId) return [];
+    const { ids } = params;
+    const allIds = Array.isArray(ids) ? ids : [ids];
+    const allowed = [];
+    await Promise.all(
+      allIds.map(async (id) => {
+        try {
+          if (await this.auth.canAccess(ctx, id, "read", "subscribe", params)) {
+            allowed.push(id);
+          }
+        } catch {
         }
-        return this.transport.addSubscription(ctx.clientId, allowed);
-    }
-    /**
-     * Unsubscribes the client from one or more documents.
-     * @param connectionId - The ID of the connection making the request
-     * @param params - The unsubscription parameters
-     * @param params.ids - Document ID or IDs to unsubscribe from
-     */
-    async unsubscribe(params, ctx) {
-        if (!ctx?.clientId)
-            return [];
-        const { ids } = params;
-        // We deliberately do **not** enforce authorization here –
-        // removing a subscription doesn't leak information and helps
-        // clean up server-side state if a client has lost access mid-session.
-        return this.transport.removeSubscription(ctx?.clientId, Array.isArray(ids) ? ids : [ids]);
+      })
+    );
+    if (allowed.length === 0) {
+      return [];
     }
+    return this.transport.addSubscription(ctx.clientId, allowed);
+  }
+  /**
+   * Unsubscribes the client from one or more documents.
+   * @param connectionId - The ID of the connection making the request
+   * @param params - The unsubscription parameters
+   * @param params.ids - Document ID or IDs to unsubscribe from
+   */
+  async unsubscribe(params, ctx) {
+    if (!ctx?.clientId) return [];
+    const { ids } = params;
+    return this.transport.removeSubscription(ctx?.clientId, Array.isArray(ids) ? ids : [ids]);
+  }
 }
+export {
+  WebSocketServer
+};

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

@@ -1,13 +1,19 @@
-import type { ClientTransport, ConnectionState } from '../protocol/types.js';
+import { Signal } from '../../event-signal.js';
+import { ClientTransport, ConnectionState } from '../protocol/types.js';
+import '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+
 /** WebSocket constructor options (subset) */
-export interface WebSocketOptions {
+interface WebSocketOptions {
     protocol?: string | string[];
 }
 /**
  * WebSocket-based transport implementation that provides communication over the WebSocket protocol.
  * Includes automatic reconnection with exponential backoff.
  */
-export declare class WebSocketTransport implements ClientTransport {
+declare class WebSocketTransport implements ClientTransport {
     private url;
     private wsOptions?;
     private _state;
@@ -23,12 +29,12 @@ export 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: import("../../event-signal.js").Signal<(state: ConnectionState) => void>;
+    readonly onStateChange: 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: import("../../event-signal.js").Signal<(data: string) => void>;
+    readonly onMessage: Signal<(data: string) => void>;
     /**
      * Creates a new WebSocket transport instance.
      * @param url - The WebSocket server URL to connect to
@@ -78,3 +84,5 @@ export declare class WebSocketTransport implements ClientTransport {
     /** Removes previously registered online/offline listeners (if any) */
     private _removeOnlineOfflineListeners;
 }
+
+export { type WebSocketOptions, WebSocketTransport };