@dabble/patches 0.4.5 → 0.4.6

package/dist/net/error.d.ts

@@ -1,4 +1,6 @@
-export declare class StatusError extends Error {
+declare class StatusError extends Error {
     code: number;
     constructor(code: number, message: string);
 }
+
+export { StatusError };

package/dist/net/error.js

@@ -1,7 +1,10 @@
-export class StatusError extends Error {
-    code;
-    constructor(code, message) {
-        super(message);
-        this.code = code;
-    }
+import "../chunk-IZ2YBCUP.js";
+class StatusError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
 }
+export {
+  StatusError
+};

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

@@ -0,0 +1,21 @@
+import { Signal } from '../../event-signal.js';
+import { ClientTransport } from '../protocol/types.js';
+import '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+
+/**
+ * Transport that uses fetch to send and receive messages.
+ */
+declare class FetchTransport implements ClientTransport {
+    private url;
+    private authHeader;
+    readonly onMessage: Signal<(raw: string) => void>;
+    private headers;
+    constructor(url: string, authHeader: string);
+    addHeadersToNextCall(headers: Record<string, string>): void;
+    send(raw: string): Promise<void>;
+}
+
+export { FetchTransport };

package/dist/net/http/FetchTransport.js

@@ -0,0 +1,34 @@
+import "../../chunk-IZ2YBCUP.js";
+import { signal } from "../../event-signal.js";
+import { rpcError } from "../protocol/utils.js";
+class FetchTransport {
+  constructor(url, authHeader) {
+    this.url = url;
+    this.authHeader = authHeader;
+  }
+  onMessage = signal();
+  headers;
+  addHeadersToNextCall(headers) {
+    this.headers = headers;
+  }
+  async send(raw) {
+    try {
+      const response = await fetch(this.url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: this.authHeader,
+          ...this.headers
+        },
+        body: raw
+      });
+      this.headers = void 0;
+      this.onMessage.emit(await response.text());
+    } catch (error) {
+      this.onMessage.emit(JSON.stringify(rpcError(-32e3, error.message)));
+    }
+  }
+}
+export {
+  FetchTransport
+};

package/dist/net/index.d.ts

@@ -1,12 +1,26 @@
-export * from './PatchesSync.js';
-export * from './protocol/JSONRPCClient.js';
-export * from './protocol/JSONRPCServer.js';
-export type * from './protocol/types.js';
-export type * from './types.js';
-export * from './websocket/AuthorizationProvider.js';
-export * from './websocket/onlineState.js';
-export * from './websocket/PatchesWebSocket.js';
-export * from './websocket/RPCServer.js';
-export * from './websocket/SignalingService.js';
-export * from './websocket/WebSocketServer.js';
-export * from './websocket/WebSocketTransport.js';
+export { FetchTransport } from './http/FetchTransport.js';
+export { PatchesClient } from './PatchesClient.js';
+export { PatchesSync, PatchesSyncOptions, PatchesSyncState } from './PatchesSync.js';
+export { JSONRPCClient } from './protocol/JSONRPCClient.js';
+export { ConnectionSignalSubscriber, JSONRPCServer, MessageHandler } from './protocol/JSONRPCServer.js';
+export { AwarenessUpdateNotificationParams, ClientTransport, ConnectionState, JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, ListOptions, Message, PatchesAPI, PatchesNotificationParams, ServerTransport, SignalNotificationParams } from './protocol/types.js';
+export { PatchesState, SyncingState } from './types.js';
+export { Access, AuthContext, AuthorizationProvider, allowAll, denyAll } from './websocket/AuthorizationProvider.js';
+export { onlineState } from './websocket/onlineState.js';
+export { PatchesWebSocket } from './websocket/PatchesWebSocket.js';
+export { RPCServer, RPCServerOptions } from './websocket/RPCServer.js';
+export { JsonRpcMessage, SendFn, SignalingService } from './websocket/SignalingService.js';
+export { WebSocketServer } from './websocket/WebSocketServer.js';
+export { WebSocketOptions, WebSocketTransport } from './websocket/WebSocketTransport.js';
+import '../event-signal.js';
+import '../types.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../json-patch/types.js';
+import '../client/Patches.js';
+import '../client/PatchesDoc.js';
+import '../client/PatchesStore.js';
+import '../server/PatchesBranchManager.js';
+import '../server/PatchesServer.js';
+import '../server/types.js';
+import '../server/PatchesHistoryManager.js';

package/dist/net/index.js

@@ -1,10 +1,12 @@
-export * from './PatchesSync.js';
-export * from './protocol/JSONRPCClient.js';
-export * from './protocol/JSONRPCServer.js';
-export * from './websocket/AuthorizationProvider.js';
-export * from './websocket/onlineState.js';
-export * from './websocket/PatchesWebSocket.js';
-export * from './websocket/RPCServer.js';
-export * from './websocket/SignalingService.js';
-export * from './websocket/WebSocketServer.js';
-export * from './websocket/WebSocketTransport.js';
+export * from "./http/FetchTransport.js";
+export * from "./PatchesClient.js";
+export * from "./PatchesSync.js";
+export * from "./protocol/JSONRPCClient.js";
+export * from "./protocol/JSONRPCServer.js";
+export * from "./websocket/AuthorizationProvider.js";
+export * from "./websocket/onlineState.js";
+export * from "./websocket/PatchesWebSocket.js";
+export * from "./websocket/RPCServer.js";
+export * from "./websocket/SignalingService.js";
+export * from "./websocket/WebSocketServer.js";
+export * from "./websocket/WebSocketTransport.js";

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

@@ -1,11 +1,16 @@
-import { type SignalSubscriber, type Unsubscriber } from '../../event-signal.js';
-import type { ClientTransport } from './types.js';
+import { SignalSubscriber, Unsubscriber } from '../../event-signal.js';
+import { ClientTransport } from './types.js';
+import '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+
 /**
  * Implementation of a JSON-RPC 2.0 client that communicates over a provided transport layer.
  * This client handles sending requests, notifications, and processing responses from a server.
  * It also supports subscription to server-sent notifications.
  */
-export declare class JSONRPCClient {
+declare class JSONRPCClient {
     private transport;
     private nextId;
     private pending;
@@ -24,7 +29,7 @@ export declare class JSONRPCClient {
      * @returns A promise that resolves with the result of the procedure call or rejects with an error
      * @template T - The expected return type of the remote procedure
      */
-    request<T = any>(method: string, params?: any): Promise<T>;
+    call<T = any>(method: string, params?: any): Promise<T>;
     /**
      * Sends a JSON-RPC notification to the server (no response expected).
      *
@@ -53,3 +58,5 @@ export declare class JSONRPCClient {
      */
     private handleMessage;
 }
+
+export { JSONRPCClient };

package/dist/net/protocol/JSONRPCClient.js

@@ -1,107 +1,99 @@
-import { signal } from '../../event-signal.js';
-/**
- * Implementation of a JSON-RPC 2.0 client that communicates over a provided transport layer.
- * This client handles sending requests, notifications, and processing responses from a server.
- * It also supports subscription to server-sent notifications.
- */
-export class JSONRPCClient {
-    transport;
-    nextId = 1;
-    pending = new Map();
-    notificationSignals = new Map();
-    /**
-     * Creates a new JSON-RPC client instance.
-     *
-     * @param transport - The transport layer implementation that will be used for sending/receiving messages
-     */
-    constructor(transport) {
-        this.transport = transport;
-        transport.onMessage(this.handleMessage.bind(this));
+import "../../chunk-IZ2YBCUP.js";
+import { signal } from "../../event-signal.js";
+class JSONRPCClient {
+  /**
+   * Creates a new JSON-RPC client instance.
+   *
+   * @param transport - The transport layer implementation that will be used for sending/receiving messages
+   */
+  constructor(transport) {
+    this.transport = transport;
+    transport.onMessage(this.handleMessage.bind(this));
+  }
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  notificationSignals = /* @__PURE__ */ new Map();
+  /**
+   * Sends a JSON-RPC request to the server and returns a promise for the response.
+   *
+   * @param method - The name of the remote procedure to call
+   * @param params - The parameters to pass to the remote procedure (optional)
+   * @returns A promise that resolves with the result of the procedure call or rejects with an error
+   * @template T - The expected return type of the remote procedure
+   */
+  async call(method, params) {
+    const id = this.nextId++;
+    const message = { jsonrpc: "2.0", id, method, params };
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      this.transport.send(JSON.stringify(message));
+    });
+  }
+  /**
+   * Sends a JSON-RPC notification to the server (no response expected).
+   *
+   * @param method - The name of the remote procedure to call
+   * @param params - The parameters to pass to the remote procedure (optional)
+   */
+  notify(method, params) {
+    const message = { jsonrpc: "2.0", method, params };
+    this.transport.send(JSON.stringify(message));
+  }
+  /**
+   * 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 request to the server and returns a promise for the response.
-     *
-     * @param method - The name of the remote procedure to call
-     * @param params - The parameters to pass to the remote procedure (optional)
-     * @returns A promise that resolves with the result of the procedure call or rejects with an error
-     * @template T - The expected return type of the remote procedure
-     */
-    async request(method, params) {
-        const id = this.nextId++;
-        const message = { jsonrpc: '2.0', id, method, params };
-        return new Promise((resolve, reject) => {
-            this.pending.set(id, { resolve, reject });
-            this.transport.send(JSON.stringify(message));
-        });
-    }
-    /**
-     * Sends a JSON-RPC notification to the server (no response expected).
-     *
-     * @param method - The name of the remote procedure to call
-     * @param params - The parameters to pass to the remote procedure (optional)
-     */
-    notify(method, params) {
-        const message = { jsonrpc: '2.0', method, params };
-        this.transport.send(JSON.stringify(message));
-    }
-    /**
-     * 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);
-    }
-    /**
-     * Processes incoming messages from the transport layer.
-     * Handles three types of messages:
-     * - Notifications: Emitted to registered subscribers
-     * - Responses: Resolved/rejected to the corresponding pending promise
-     * - Invalid messages: Logged as warnings
-     *
-     * @private
-     * @param data - The raw message data received from the transport
-     */
-    handleMessage(data) {
-        try {
-            const message = JSON.parse(data);
-            // Check if it's a notification (has method but no id)
-            if (typeof message === 'object' && message !== null && 'method' in message && !('id' in message)) {
-                const thisSignal = this.notificationSignals.get(message.method);
-                if (thisSignal)
-                    thisSignal.emit(message.params);
-                return;
-            }
-            // Must be a response (has id)
-            if (typeof message === 'object' && message !== null && 'id' in message) {
-                const response = message;
-                const pending = this.pending.get(response.id);
-                if (pending) {
-                    this.pending.delete(response.id);
-                    if ('error' in response) {
-                        pending.reject(response.error);
-                    }
-                    else {
-                        pending.resolve(response.result);
-                    }
-                }
-                else {
-                    console.warn(`Received response for unknown id: ${response.id}`);
-                }
-                return;
-            }
-            console.warn('Received unexpected message format:', message);
-        }
-        catch (error) {
-            console.error('Failed to parse incoming message:', data, error);
+    return thisSignal(handler);
+  }
+  /**
+   * Processes incoming messages from the transport layer.
+   * Handles three types of messages:
+   * - Notifications: Emitted to registered subscribers
+   * - Responses: Resolved/rejected to the corresponding pending promise
+   * - Invalid messages: Logged as warnings
+   *
+   * @private
+   * @param data - The raw message data received from the transport
+   */
+  handleMessage(data) {
+    try {
+      const message = JSON.parse(data);
+      if (typeof message === "object" && message !== null && "method" in message && !("id" in message)) {
+        const thisSignal = this.notificationSignals.get(message.method);
+        if (thisSignal) thisSignal.emit(message.params);
+        return;
+      }
+      if (typeof message === "object" && message !== null && "id" in message) {
+        const response = message;
+        const pending = this.pending.get(response.id);
+        if (pending) {
+          this.pending.delete(response.id);
+          if ("error" in response) {
+            pending.reject(response.error);
+          } else {
+            pending.resolve(response.result);
+          }
+        } else {
+          console.warn(`Received response for unknown id: ${response.id}`);
         }
+        return;
+      }
+      console.warn("Received unexpected message format:", message);
+    } catch (error) {
+      console.error("Failed to parse incoming message:", data, error);
     }
+  }
 }
+export {
+  JSONRPCClient
+};

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

@@ -1,8 +1,13 @@
-import { type Signal, type Unsubscriber } from '../../event-signal.js';
-import type { AuthContext } from '../websocket/AuthorizationProvider.js';
-import type { Message, Notification, Response } from './types.js';
-export type ConnectionSignalSubscriber = (params: any, clientId?: string) => any;
-export type MessageHandler<P = any, R = any> = (params: P, ctx?: AuthContext) => Promise<R> | R;
+import { Signal, Unsubscriber } from '../../event-signal.js';
+import { AuthContext } from '../websocket/AuthorizationProvider.js';
+import { JsonRpcNotification, Message, JsonRpcResponse } from './types.js';
+import '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+
+type ConnectionSignalSubscriber = (params: any, clientId?: string) => any;
+type MessageHandler<P = any, R = any> = (params: P, ctx?: AuthContext) => Promise<R> | R;
 /**
  * Lightweight JSON-RPC 2.0 server adapter for {@link PatchesServer}.
  *
@@ -19,13 +24,13 @@ export type MessageHandler<P = any, R = any> = (params: P, ctx?: AuthContext) =>
  *     calls.  How you generate that ID (auth token, random GUID, etc.) is left
  *     to the host application.
  */
-export declare class JSONRPCServer {
+declare class JSONRPCServer {
     /** Map of fully-qualified JSON-RPC method → handler function */
     private readonly handlers;
     /** Allow external callers to emit server-initiated notifications. */
     private readonly notificationSignals;
     /** Allow external callers to emit server-initiated notifications. */
-    readonly onNotify: Signal<(msg: Notification, exceptConnectionId?: string) => void>;
+    readonly onNotify: Signal<(msg: JsonRpcNotification, exceptConnectionId?: string) => void>;
     /**
      * Registers a JSON-RPC method.
      *
@@ -60,7 +65,7 @@ export declare class JSONRPCServer {
      * internally; the returned string is forwarded over the socket.
      */
     processMessage(raw: string, ctx?: AuthContext): Promise<string | undefined>;
-    processMessage(message: Message, ctx?: AuthContext): Promise<Response | undefined>;
+    processMessage(message: Message, ctx?: AuthContext): Promise<JsonRpcResponse | undefined>;
     /**
      * Maps JSON-RPC method names to {@link PatchesServer} calls.
      * @param connectionId - The WebSocket transport object.
@@ -70,3 +75,5 @@ export declare class JSONRPCServer {
      */
     protected _dispatch(method: string, params: any, ctx?: AuthContext): Promise<any>;
 }
+
+export { type ConnectionSignalSubscriber, JSONRPCServer, type MessageHandler };