@dabble/patches 0.4.4 → 0.4.6

package/dist/net/protocol/JSONRPCServer.js

@@ -1,129 +1,107 @@
-import { signal } from '../../event-signal.js';
-/**
- * Lightweight JSON-RPC 2.0 server adapter for {@link PatchesServer}.
- *
- * The class is intentionally transport-agnostic: it only needs an object that
- * fulfils the {@link Transport} contract (i.e. something that can exchange
- * string messages and notify when one arrives).  This makes it suitable for
- * WebSocket, TCP, or even `postMessage` usage.
- *
- * A new instance is typically created per connected client.  You therefore
- * pass in:
- *   • the {@link Transport} that represents this client connection
- *   • a shared (singleton) {@link PatchesServer}
- *   • the unique `clientId` that identifies the connection in subscription
- *     calls.  How you generate that ID (auth token, random GUID, etc.) is left
- *     to the host application.
- */
-export class JSONRPCServer {
-    /** Map of fully-qualified JSON-RPC method → handler function */
-    handlers = new Map();
-    /** Allow external callers to emit server-initiated notifications. */
-    notificationSignals = new Map();
-    /** Allow external callers to emit server-initiated notifications. */
-    onNotify = signal();
-    // -------------------------------------------------------------------------
-    // Registration API
-    // -------------------------------------------------------------------------
-    /**
-     * Registers a JSON-RPC method.
-     *
-     * @param method   Fully-qualified method name (e.g. "patches.subscribe").
-     * @param handler  Function that performs the work and returns the result.
-     */
-    registerMethod(method, handler) {
-        if (this.handlers.has(method)) {
-            throw new Error(`A handler for method '${method}' is already registered.`);
-        }
-        this.handlers.set(method, handler);
+import "../../chunk-IZ2YBCUP.js";
+import { signal } from "../../event-signal.js";
+import { rpcError, rpcNotification, rpcResponse } from "./utils.js";
+class JSONRPCServer {
+  /** Map of fully-qualified JSON-RPC method → handler function */
+  handlers = /* @__PURE__ */ new Map();
+  /** Allow external callers to emit server-initiated notifications. */
+  notificationSignals = /* @__PURE__ */ new Map();
+  /** Allow external callers to emit server-initiated notifications. */
+  onNotify = signal();
+  // -------------------------------------------------------------------------
+  // Registration API
+  // -------------------------------------------------------------------------
+  /**
+   * Registers a JSON-RPC method.
+   *
+   * @param method   Fully-qualified method name (e.g. "patches.subscribe").
+   * @param handler  Function that performs the work and returns the result.
+   */
+  registerMethod(method, handler) {
+    if (this.handlers.has(method)) {
+      throw new Error(`A handler for method '${method}' is already registered.`);
     }
-    // -------------------------------------------------------------------------
-    // Public helpers
-    // -------------------------------------------------------------------------
-    /**
-     * Subscribes to server-sent notifications for a specific method.
-     *
-     * @param method - The notification method name to subscribe to
-     * @param handler - The callback function that will be invoked when notifications are received
-     * @returns A function that can be called to unsubscribe from the notifications
-     * @template T - The type of the handler function
-     */
-    on(method, handler) {
-        let thisSignal = this.notificationSignals.get(method);
-        if (!thisSignal) {
-            thisSignal = signal();
-            this.notificationSignals.set(method, thisSignal);
-        }
-        return thisSignal(handler);
+    this.handlers.set(method, handler);
+  }
+  // -------------------------------------------------------------------------
+  // Public helpers
+  // -------------------------------------------------------------------------
+  /**
+   * Subscribes to server-sent notifications for a specific method.
+   *
+   * @param method - The notification method name to subscribe to
+   * @param handler - The callback function that will be invoked when notifications are received
+   * @returns A function that can be called to unsubscribe from the notifications
+   * @template T - The type of the handler function
+   */
+  on(method, handler) {
+    let thisSignal = this.notificationSignals.get(method);
+    if (!thisSignal) {
+      thisSignal = signal();
+      this.notificationSignals.set(method, thisSignal);
     }
-    /**
-     * Sends a JSON-RPC notification (no `id`, therefore no response expected) to
-     * the connected client.
-     */
-    async notify(method, params, exceptConnectionId) {
-        const msg = { jsonrpc: '2.0', method, params };
-        this.onNotify.emit(msg, exceptConnectionId);
+    return thisSignal(handler);
+  }
+  /**
+   * Sends a JSON-RPC notification (no `id`, therefore no response expected) to
+   * the connected client.
+   */
+  async notify(method, params, exceptConnectionId) {
+    const msg = rpcNotification(method, params);
+    this.onNotify.emit(msg, exceptConnectionId);
+  }
+  async processMessage(raw, ctx) {
+    let message;
+    const respond = typeof raw === "string" ? JSON.stringify : (r) => r;
+    if (typeof raw === "string") {
+      try {
+        message = JSON.parse(raw);
+      } catch (err) {
+        return respond(rpcError(-32700, "Parse error", err));
+      }
+    } else {
+      message = raw;
     }
-    async processMessage(raw, ctx) {
-        let message;
-        const respond = typeof raw === 'string' ? JSON.stringify : (r) => r;
-        // --- Parse & basic validation ------------------------------------------------
-        if (typeof raw === 'string') {
-            try {
-                message = JSON.parse(raw);
-            }
-            catch (err) {
-                return respond(rpcError(-32700, 'Parse error', err));
-            }
-        }
-        else {
-            message = raw;
-        }
-        // Ensure it looks like a JSON-RPC call (must have a method field)
-        if (!message || typeof message !== 'object' || !('method' in message)) {
-            const invalidId = message?.id ?? null;
-            return respond(rpcError(-32600, 'Invalid Request', invalidId));
-        }
-        // --- Distinguish request vs. notification -----------------------------------
-        if ('id' in message && message.id !== undefined) {
-            // -> Request ----------------------------------------------------------------
-            try {
-                const result = await this._dispatch(message.method, message.params, ctx);
-                const response = { jsonrpc: '2.0', id: message.id, result };
-                return respond(response);
-            }
-            catch (err) {
-                return respond(rpcError(err?.code ?? -32000, err?.message ?? 'Server error', err?.code ? undefined : err?.stack));
-            }
-        }
-        else {
-            // -> Notification -----------------------------------------------------------
-            // Forward the notification to any listeners and return nothing.
-            const thisSignal = this.notificationSignals.get(message.method);
-            if (thisSignal) {
-                thisSignal.emit(message.params, ctx?.clientId);
-            }
-            return undefined;
-        }
+    if (!message || typeof message !== "object" || !("method" in message)) {
+      const invalidId = message?.id ?? null;
+      return respond(rpcError(-32600, "Invalid Request", invalidId));
     }
-    /**
-     * Maps JSON-RPC method names to {@link PatchesServer} calls.
-     * @param connectionId - The WebSocket transport object.
-     * @param method - The JSON-RPC method name.
-     * @param params - The JSON-RPC parameters.
-     * @returns The result of the {@link PatchesServer} call.
-     */
-    async _dispatch(method, params, ctx) {
-        const handler = this.handlers.get(method);
-        if (!handler) {
-            throw new Error(`Unknown method '${method}'.`);
-        }
-        if (!params || typeof params !== 'object' || Array.isArray(params)) {
-            throw new Error(`Invalid parameters for method '${method}'.`);
-        }
-        return handler(params, ctx);
+    if ("id" in message && message.id !== void 0) {
+      try {
+        const result = await this._dispatch(message.method, message.params, ctx);
+        const response = rpcResponse(result, message.id);
+        return respond(response);
+      } catch (err) {
+        return respond(
+          rpcError(err?.code ?? -32e3, err?.message ?? "Server error", err?.code ? void 0 : err?.stack, message.id)
+        );
+      }
+    } else {
+      const thisSignal = this.notificationSignals.get(message.method);
+      if (thisSignal) {
+        thisSignal.emit(message.params, ctx?.clientId);
+      }
+      return void 0;
     }
+  }
+  /**
+   * Maps JSON-RPC method names to {@link PatchesServer} calls.
+   * @param connectionId - The WebSocket transport object.
+   * @param method - The JSON-RPC method name.
+   * @param params - The JSON-RPC parameters.
+   * @returns The result of the {@link PatchesServer} call.
+   */
+  async _dispatch(method, params, ctx) {
+    const handler = this.handlers.get(method);
+    if (!handler) {
+      throw new Error(`Unknown method '${method}'.`);
+    }
+    if (!params || typeof params !== "object" || Array.isArray(params)) {
+      throw new Error(`Invalid parameters for method '${method}'.`);
+    }
+    return handler(params, ctx);
+  }
 }
-function rpcError(code, message, data) {
-    return { jsonrpc: '2.0', id: null, error: { code, message, data } };
-}
+export {
+  JSONRPCServer
+};

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

@@ -1,5 +1,9 @@
-import type { Unsubscriber } from '../../event-signal.js';
-import type { Change, EditableVersionMetadata, ListVersionsOptions, PatchesState, VersionMetadata } from '../../types.js';
+import { Unsubscriber } from '../../event-signal.js';
+import { PatchesState, Change, ChangeInput, EditableVersionMetadata, ListVersionsOptions, VersionMetadata } from '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+
 /**
  * Represents the possible states of a network transport connection.
  * - 'connecting': Connection is being established
@@ -7,7 +11,7 @@ import type { Change, EditableVersionMetadata, ListVersionsOptions, PatchesState
  * - 'disconnected': Connection is not active
  * - 'error': Connection encountered an error
  */
-export type ConnectionState = 'connecting' | 'connected' | 'disconnected' | 'error';
+type ConnectionState = 'connecting' | 'connected' | 'disconnected' | 'error';
 /**
  * Minimal contract that the JSON-RPC layer (and therefore Patches core) relies on.
  * A transport only needs the ability to **send** raw strings and **deliver** raw
@@ -16,7 +20,7 @@ export type ConnectionState = 'connecting' | 'connected' | 'disconnected' | 'err
  * Anything beyond that (connect/disconnect lifecycle, connection state, etc.) is
  * not needed or handled by Patches and so is not defined here.
  */
-export interface ClientTransport {
+interface ClientTransport {
     /**
      * Sends a raw, already-encoded message over the wire.
      */
@@ -32,7 +36,7 @@ export interface ClientTransport {
  * Each message must indicate the **from / to** connection. Any additional lifecycle
  * management (upgrade, close, etc.) stays inside the concrete adapter.
  */
-export interface ServerTransport {
+interface ServerTransport {
     /** Get a list of all active connection IDs */
     getConnectionIds(): string[];
     /** Send a raw JSON-RPC string to a specific connection */
@@ -49,7 +53,7 @@ export interface ServerTransport {
 /**
  * Represents a JSON-RPC 2.0 request object.
  */
-export interface Request {
+interface JsonRpcRequest {
     /** JSON-RPC protocol version, always "2.0" */
     jsonrpc: '2.0';
     /** Request identifier, used to match responses to requests */
@@ -62,7 +66,7 @@ export interface Request {
 /**
  * Represents a JSON-RPC 2.0 response object.
  */
-export interface Response {
+interface JsonRpcResponse {
     /** JSON-RPC protocol version, always "2.0" */
     jsonrpc: '2.0';
     /** Response identifier, matches the id of the corresponding request */
@@ -83,7 +87,7 @@ export interface Response {
  * Represents a JSON-RPC 2.0 notification object.
  * Notifications are one-way messages that don't expect a response.
  */
-export interface Notification {
+interface JsonRpcNotification {
     /** JSON-RPC protocol version, always "2.0" */
     jsonrpc: '2.0';
     /** Name of the notification method */
@@ -92,8 +96,8 @@ export interface Notification {
     params?: any;
 }
 /** Union type for all possible JSON-RPC message types */
-export type Message = Request | Response | Notification;
-export interface ListOptions {
+type Message = JsonRpcRequest | JsonRpcResponse | JsonRpcNotification;
+interface ListOptions {
     startAt?: string;
     startAfter?: string;
     endAt?: string;
@@ -102,7 +106,7 @@ export interface ListOptions {
     limit?: number;
     reverse?: boolean;
 }
-export interface PatchesAPI {
+interface PatchesAPI {
     /**
      * Subscribes the connected client to one or more documents.
      * @param ids Document ID(s) to subscribe to.
@@ -119,7 +123,7 @@ export interface PatchesAPI {
     /** Get changes that occurred after a specific revision. */
     getChangesSince(docId: string, rev: number): Promise<Change[]>;
     /** Apply a set of changes from the client to a document. Returns the committed changes. */
-    commitChanges(docId: string, changes: Change[]): Promise<Change[]>;
+    commitChanges(docId: string, changes: ChangeInput[]): Promise<Change[]>;
     /** Delete a document. */
     deleteDoc(docId: string): Promise<void>;
     /** Create a new named version snapshot of a document's current state. */
@@ -133,18 +137,20 @@ export interface PatchesAPI {
     /** Update the name and other metadata of a specific version. */
     updateVersion(docId: string, versionId: string, metadata: EditableVersionMetadata): Promise<void>;
 }
-export interface PatchesNotificationParams {
+interface PatchesNotificationParams {
     docId: string;
     changes: Change[];
 }
-export interface AwarenessUpdateNotificationParams {
+interface AwarenessUpdateNotificationParams {
     docId: string;
     /** The awareness state from a specific client (server should add sender info) */
     state: any;
     /** Server should add the client ID of the sender */
     clientId?: string;
 }
-export interface SignalNotificationParams {
+interface SignalNotificationParams {
     fromClientId: string;
     data: any;
 }
+
+export type { AwarenessUpdateNotificationParams, ClientTransport, ConnectionState, JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, ListOptions, Message, PatchesAPI, PatchesNotificationParams, ServerTransport, SignalNotificationParams };

package/dist/net/protocol/types.js

@@ -1 +0,0 @@
-export {};

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

@@ -0,0 +1,12 @@
+import { JsonRpcResponse, JsonRpcNotification } from './types.js';
+import '../../event-signal.js';
+import '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+
+declare function rpcResponse<T = any>(result: T, id?: number): JsonRpcResponse;
+declare function rpcError(code: number, message: string, data?: any, id?: number): JsonRpcResponse;
+declare function rpcNotification(method: string, params?: any): JsonRpcNotification;
+
+export { rpcError, rpcNotification, rpcResponse };

package/dist/net/protocol/utils.js

@@ -0,0 +1,15 @@
+import "../../chunk-IZ2YBCUP.js";
+function rpcResponse(result, id) {
+  return { jsonrpc: "2.0", id: id ?? null, result };
+}
+function rpcError(code, message, data, id) {
+  return { jsonrpc: "2.0", id: id ?? null, error: { code, message, data } };
+}
+function rpcNotification(method, params) {
+  return { jsonrpc: "2.0", method, params };
+}
+export {
+  rpcError,
+  rpcNotification,
+  rpcResponse
+};

package/dist/net/types.d.ts

@@ -1,6 +1,8 @@
-export type SyncingState = 'initial' | 'updating' | null | Error;
-export interface PatchesState {
+type SyncingState = 'initial' | 'updating' | null | Error;
+interface PatchesState {
     online: boolean;
     connected: boolean;
     syncing: SyncingState;
 }
+
+export type { PatchesState, SyncingState };

package/dist/net/types.js

@@ -1 +0,0 @@
-export {};

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

@@ -1,4 +1,13 @@
-import type { WebRTCTransport } from './WebRTCTransport.js';
+import { Signal } from '../../event-signal.js';
+import { WebRTCTransport } from './WebRTCTransport.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';
+
 /**
  * Base type for awareness states, representing arbitrary structured data
  * that will be shared between peers.
@@ -11,7 +20,7 @@ type AwarenessState = Record<string, any>;
  *
  * @template T - The type of awareness state to be shared between peers
  */
-export declare class WebRTCAwareness<T extends AwarenessState = AwarenessState> {
+declare class WebRTCAwareness<T extends AwarenessState = AwarenessState> {
     private transport;
     private _states;
     private _localState;
@@ -19,7 +28,7 @@ export 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: import("../../event-signal.js").Signal<(states: T[]) => void>;
+    readonly onUpdate: Signal<(states: T[]) => void>;
     /**
      * The peer ID of this client, obtained from the WebRTC transport.
      */
@@ -78,4 +87,5 @@ export declare class WebRTCAwareness<T extends AwarenessState = AwarenessState>
      */
     private _receiveData;
 }
-export {};
+
+export { WebRTCAwareness };