@dabble/patches 0.4.5 → 0.4.6

package/dist/json-patch/utils/updateArrayIndexes.js

@@ -1,38 +1,34 @@
-import { getTypeLike } from './getType.js';
-import { log } from './log.js';
-import { isAdd, mapAndFilterOps, transformRemove } from './ops.js';
-import { getPrefixAndProp } from './paths.js';
-import { updateArrayPath } from './updateArrayPath.js';
-/**
- * Update array indexes to account for values being added or removed from an array.
- */
-export function updateArrayIndexes(state, thisPath, otherOps, modifier, isRemove) {
-    const [arrayPrefix, indexStr] = getPrefixAndProp(thisPath);
-    const index = parseInt(indexStr);
-    log('Shifting array indexes', thisPath, modifier);
-    // Check ops for any that need to be replaced
-    return mapAndFilterOps(otherOps, (op, i, breakAfter) => {
-        if (isRemove && thisPath === op.from) {
-            const opLike = getTypeLike(state, op);
-            if (opLike === 'move') {
-                // We need the rest of the otherOps to be adjusted against this "move"
-                breakAfter();
-                return transformRemove(state, op.path, otherOps.slice(i + 1));
-            }
-            else if (opLike === 'copy') {
-                // We need future ops on the copied object to be removed
-                breakAfter();
-                let rest = transformRemove(state, thisPath, otherOps.slice(i + 1));
-                rest = transformRemove(state, op.path, rest);
-                return rest;
-            }
-        }
-        if (op.soft && isAdd(state, op, 'path') && op.path === thisPath) {
-            breakAfter(true);
-            return null;
-        }
-        // check for items from the same array that will be affected
-        op = updateArrayPath(state, op, 'from', arrayPrefix, index, modifier);
-        return op && updateArrayPath(state, op, 'path', arrayPrefix, index, modifier);
-    });
+import "../../chunk-IZ2YBCUP.js";
+import { getTypeLike } from "./getType.js";
+import { log } from "./log.js";
+import { isAdd, mapAndFilterOps, transformRemove } from "./ops.js";
+import { getPrefixAndProp } from "./paths.js";
+import { updateArrayPath } from "./updateArrayPath.js";
+function updateArrayIndexes(state, thisPath, otherOps, modifier, isRemove) {
+  const [arrayPrefix, indexStr] = getPrefixAndProp(thisPath);
+  const index = parseInt(indexStr);
+  log("Shifting array indexes", thisPath, modifier);
+  return mapAndFilterOps(otherOps, (op, i, breakAfter) => {
+    if (isRemove && thisPath === op.from) {
+      const opLike = getTypeLike(state, op);
+      if (opLike === "move") {
+        breakAfter();
+        return transformRemove(state, op.path, otherOps.slice(i + 1));
+      } else if (opLike === "copy") {
+        breakAfter();
+        let rest = transformRemove(state, thisPath, otherOps.slice(i + 1));
+        rest = transformRemove(state, op.path, rest);
+        return rest;
+      }
+    }
+    if (op.soft && isAdd(state, op, "path") && op.path === thisPath) {
+      breakAfter(true);
+      return null;
+    }
+    op = updateArrayPath(state, op, "from", arrayPrefix, index, modifier);
+    return op && updateArrayPath(state, op, "path", arrayPrefix, index, modifier);
+  });
 }
+export {
+  updateArrayIndexes
+};

package/dist/json-patch/utils/updateArrayPath.d.ts

@@ -1,5 +1,8 @@
-import type { JSONPatchOp, State } from '../types.js';
+import { State, JSONPatchOp } from '../types.js';
+
 /**
  * Adjust ops within an array
  */
-export declare function updateArrayPath(state: State, otherOp: JSONPatchOp, pathName: 'from' | 'path', thisPrefix: string, thisIndex: number, modifier: 1 | -1): JSONPatchOp | [JSONPatchOp, JSONPatchOp] | null;
+declare function updateArrayPath(state: State, otherOp: JSONPatchOp, pathName: 'from' | 'path', thisPrefix: string, thisIndex: number, modifier: 1 | -1): JSONPatchOp | [JSONPatchOp, JSONPatchOp] | null;
+
+export { updateArrayPath };

package/dist/json-patch/utils/updateArrayPath.js

@@ -1,45 +1,32 @@
-import { getTypeLike } from './getType.js';
-import { isAdd } from './ops.js';
-import { getIndexAndEnd } from './paths.js';
-import { getValue } from './pluck.js';
-/**
- * Adjust ops within an array
- */
-export function updateArrayPath(state, otherOp, pathName, thisPrefix, thisIndex, modifier) {
-    const path = otherOp[pathName];
-    if (!path || !path.startsWith(thisPrefix))
-        return otherOp;
-    const [otherIndex, end] = getIndexAndEnd(state, path, thisPrefix.length);
-    const opLike = getTypeLike(state, otherOp);
-    // A bit of complex logic to handle moves upwards in an array. Since an item is removed earier in the array and added later, the other index is like it was one less (or this index was one more), so we correct it
-    if (opLike === 'move' &&
-        pathName === 'path' &&
-        otherOp.from?.startsWith(thisPrefix) &&
-        getIndexAndEnd(state, otherOp.from, thisPrefix.length)[0] < otherIndex) {
-        thisIndex -= 1;
+import "../../chunk-IZ2YBCUP.js";
+import { getTypeLike } from "./getType.js";
+import { isAdd } from "./ops.js";
+import { getIndexAndEnd } from "./paths.js";
+import { getValue } from "./pluck.js";
+function updateArrayPath(state, otherOp, pathName, thisPrefix, thisIndex, modifier) {
+  const path = otherOp[pathName];
+  if (!path || !path.startsWith(thisPrefix)) return otherOp;
+  const [otherIndex, end] = getIndexAndEnd(state, path, thisPrefix.length);
+  const opLike = getTypeLike(state, otherOp);
+  if (opLike === "move" && pathName === "path" && otherOp.from?.startsWith(thisPrefix) && getIndexAndEnd(state, otherOp.from, thisPrefix.length)[0] < otherIndex) {
+    thisIndex -= 1;
+  }
+  if (otherIndex < thisIndex) return otherOp;
+  if (otherIndex === thisIndex && modifier === -1) {
+    if (end === path.length) {
+      if (isAdd(state, otherOp, pathName)) return otherOp;
+      if (otherOp.op === "replace") return getValue(state, otherOp, "op", "add");
+      if (opLike === "replace") return [{ op: "add", path: otherOp.path, value: null }, otherOp];
     }
-    if (otherIndex < thisIndex)
-        return otherOp;
-    // When this is a removed item and the op is a subpath or a non-add, remove it.
-    if (otherIndex === thisIndex && modifier === -1) {
-        if (end === path.length) {
-            // If we are adding to the location something got removed, continue adding it.
-            if (isAdd(state, otherOp, pathName))
-                return otherOp;
-            if (otherOp.op === 'replace')
-                return getValue(state, otherOp, 'op', 'add');
-            // If we are replacing an item which was removed, add it (don't replace something else in the array)
-            if (opLike === 'replace')
-                return [{ op: 'add', path: otherOp.path, value: null }, otherOp];
-        }
-        return null;
-    }
-    else if (isAdd(state, otherOp, pathName) && otherIndex === thisIndex && end === path.length) {
-        if (otherOp.soft)
-            return null;
-        return otherOp;
-    }
-    const newPath = thisPrefix + (otherIndex + modifier) + path.slice(end);
-    otherOp = getValue(state, otherOp, pathName, newPath);
+    return null;
+  } else if (isAdd(state, otherOp, pathName) && otherIndex === thisIndex && end === path.length) {
+    if (otherOp.soft) return null;
     return otherOp;
+  }
+  const newPath = thisPrefix + (otherIndex + modifier) + path.slice(end);
+  otherOp = getValue(state, otherOp, pathName, newPath);
+  return otherOp;
 }
+export {
+  updateArrayPath
+};

package/dist/net/PatchesClient.d.ts

@@ -0,0 +1,128 @@
+import { Signal } from '../event-signal.js';
+import { Change, PatchesState, ChangeInput, EditableVersionMetadata, ListVersionsOptions, VersionMetadata, PatchesSnapshot } from '../types.js';
+import { JSONRPCClient } from './protocol/JSONRPCClient.js';
+import { PatchesAPI, ClientTransport } from './protocol/types.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../json-patch/types.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.
+ */
+declare class PatchesClient implements PatchesAPI {
+    rpc: JSONRPCClient;
+    transport: ClientTransport;
+    /** Signal emitted when the server pushes document changes. */
+    readonly onChangesCommitted: Signal<(docId: string, changes: Change[]) => void>;
+    /**
+     * Creates a new Patches WebSocket client instance.
+     * @param url - The WebSocket server URL to connect to
+     * @param wsOptions - Optional configuration for the underlying WebSocket connection
+     */
+    constructor(transport: ClientTransport);
+    /**
+     * Subscribes the client to one or more documents to receive real-time updates.
+     * @param ids - Document ID or IDs to subscribe to.
+     * @returns A promise resolving with the list of successfully subscribed document IDs.
+     */
+    subscribe(ids: string | string[]): Promise<string[]>;
+    /**
+     * Unsubscribes the client from one or more documents.
+     * @param ids - Document ID or IDs to unsubscribe from.
+     * @returns A promise resolving when the unsubscription is confirmed.
+     */
+    unsubscribe(ids: string | string[]): Promise<void>;
+    /**
+     * Gets the latest state (content and revision) of a document.
+     * @param docId - The ID of the document.
+     * @returns A promise resolving with the document snapshot.
+     */
+    getDoc<T = any>(docId: string, atRev?: number): Promise<PatchesState<T>>;
+    /**
+     * Gets changes that occurred for a document after a specific revision number.
+     * @param docId - The ID of the document.
+     * @param rev - The revision number after which to fetch changes.
+     * @returns A promise resolving with an array of changes.
+     */
+    getChangesSince(docId: string, rev: number): Promise<Change[]>;
+    /**
+     * Applies a set of client-generated changes to a document on the server.
+     * @param docId - The ID of the document.
+     * @param changes - An array of changes to apply.
+     * @returns A promise resolving with the changes as committed by the server (potentially transformed).
+     */
+    commitChanges(docId: string, changes: ChangeInput[]): Promise<Change[]>;
+    /**
+     * Deletes a document on the server.
+     * @param docId - The ID of the document to delete.
+     * @returns A promise resolving when the deletion is confirmed.
+     */
+    deleteDoc(docId: string): Promise<void>;
+    /**
+     * Creates a named version snapshot of a document's current state on the server.
+     * @param docId - The ID of the document.
+     * @param name - A descriptive name for the version.
+     * @returns A promise resolving with the unique ID of the newly created version.
+     */
+    createVersion(docId: string, metadata: EditableVersionMetadata): Promise<string>;
+    /**
+     * Lists metadata for saved versions of a document.
+     * @param docId - The ID of the document.
+     * @param options - Options for filtering or pagination (e.g., limit, offset).
+     * @returns A promise resolving with an array of version metadata objects.
+     */
+    listVersions(docId: string, options?: ListVersionsOptions): Promise<VersionMetadata[]>;
+    /**
+     * Gets the document state snapshot corresponding to a specific version ID.
+     * @param docId - The ID of the document.
+     * @param versionId - The ID of the version to retrieve.
+     * @returns A promise resolving with the document snapshot for that version.
+     */
+    getVersionState(docId: string, versionId: string): Promise<PatchesSnapshot>;
+    /**
+     * Gets the original changes associated with a specific version ID.
+     * @param docId - The ID of the document.
+     * @param versionId - The ID of the version.
+     * @returns A promise resolving with an array of changes that constitute that version.
+     */
+    getVersionChanges(docId: string, versionId: string): Promise<Change[]>;
+    /**
+     * Updates the name of a specific version.
+     * @param docId - The ID of the document.
+     * @param versionId - The ID of the version to update.
+     * @param name - The new name for the version.
+     * @returns A promise resolving when the update is confirmed.
+     */
+    updateVersion(docId: string, versionId: string, metadata: EditableVersionMetadata): Promise<void>;
+    /**
+     * Lists all branches for a document.
+     * @param docId - The ID of the document.
+     * @returns A promise resolving with an array of branch metadata objects.
+     */
+    listBranches(docId: string): Promise<VersionMetadata[]>;
+    /**
+     * Creates a new branch for a document.
+     * @param docId - The ID of the document.
+     * @param rev - The revision number to base the new branch on.
+     * @param metadata - Optional metadata for the new branch.
+     * @returns A promise resolving with the unique ID of the newly created branch.
+     */
+    createBranch(docId: string, rev: number, metadata?: EditableVersionMetadata): Promise<string>;
+    /**
+     * Closes a branch on the server.
+     * @param branchId - The ID of the branch to close.
+     * @returns A promise resolving when the branch is closed.
+     */
+    closeBranch(branchId: string): Promise<void>;
+    /**
+     * Merges a branch on the server.
+     * @param branchId - The ID of the branch to merge.
+     * @returns A promise resolving when the merge is confirmed.
+     */
+    mergeBranch(branchId: string): Promise<void>;
+}
+
+export { PatchesClient };

package/dist/net/PatchesClient.js

@@ -0,0 +1,161 @@
+import "../chunk-IZ2YBCUP.js";
+import { signal } from "../event-signal.js";
+import { JSONRPCClient } from "./protocol/JSONRPCClient.js";
+class PatchesClient {
+  rpc;
+  transport;
+  // --- Public Signals ---
+  /** Signal emitted when the server pushes document changes. */
+  onChangesCommitted = signal();
+  /**
+   * Creates a new Patches WebSocket client instance.
+   * @param url - The WebSocket server URL to connect to
+   * @param wsOptions - Optional configuration for the underlying WebSocket connection
+   */
+  constructor(transport) {
+    this.transport = transport;
+    this.rpc = new JSONRPCClient(transport);
+    this.rpc.on("changesCommitted", (params) => {
+      const { docId, changes } = params;
+      this.onChangesCommitted.emit(docId, changes);
+    });
+  }
+  // --- Patches API Methods ---
+  // === Subscription Operations ===
+  /**
+   * Subscribes the client to one or more documents to receive real-time updates.
+   * @param ids - Document ID or IDs to subscribe to.
+   * @returns A promise resolving with the list of successfully subscribed document IDs.
+   */
+  async subscribe(ids) {
+    return this.rpc.call("subscribe", { ids });
+  }
+  /**
+   * Unsubscribes the client from one or more documents.
+   * @param ids - Document ID or IDs to unsubscribe from.
+   * @returns A promise resolving when the unsubscription is confirmed.
+   */
+  async unsubscribe(ids) {
+    return this.rpc.call("unsubscribe", { ids });
+  }
+  // === Document Operations ===
+  /**
+   * Gets the latest state (content and revision) of a document.
+   * @param docId - The ID of the document.
+   * @returns A promise resolving with the document snapshot.
+   */
+  async getDoc(docId, atRev) {
+    return this.rpc.call("getDoc", { docId, atRev });
+  }
+  /**
+   * Gets changes that occurred for a document after a specific revision number.
+   * @param docId - The ID of the document.
+   * @param rev - The revision number after which to fetch changes.
+   * @returns A promise resolving with an array of changes.
+   */
+  async getChangesSince(docId, rev) {
+    return this.rpc.call("getChangesSince", { docId, rev });
+  }
+  /**
+   * Applies a set of client-generated changes to a document on the server.
+   * @param docId - The ID of the document.
+   * @param changes - An array of changes to apply.
+   * @returns A promise resolving with the changes as committed by the server (potentially transformed).
+   */
+  async commitChanges(docId, changes) {
+    return this.rpc.call("commitChanges", { docId, changes });
+  }
+  /**
+   * Deletes a document on the server.
+   * @param docId - The ID of the document to delete.
+   * @returns A promise resolving when the deletion is confirmed.
+   */
+  async deleteDoc(docId) {
+    return this.rpc.call("deleteDoc", { docId });
+  }
+  // === Version Operations ===
+  /**
+   * Creates a named version snapshot of a document's current state on the server.
+   * @param docId - The ID of the document.
+   * @param name - A descriptive name for the version.
+   * @returns A promise resolving with the unique ID of the newly created version.
+   */
+  async createVersion(docId, metadata) {
+    return this.rpc.call("createVersion", { docId, metadata });
+  }
+  /**
+   * Lists metadata for saved versions of a document.
+   * @param docId - The ID of the document.
+   * @param options - Options for filtering or pagination (e.g., limit, offset).
+   * @returns A promise resolving with an array of version metadata objects.
+   */
+  async listVersions(docId, options) {
+    return this.rpc.call("listVersions", { docId, options });
+  }
+  /**
+   * Gets the document state snapshot corresponding to a specific version ID.
+   * @param docId - The ID of the document.
+   * @param versionId - The ID of the version to retrieve.
+   * @returns A promise resolving with the document snapshot for that version.
+   */
+  async getVersionState(docId, versionId) {
+    return this.rpc.call("getVersionState", { docId, versionId });
+  }
+  /**
+   * Gets the original changes associated with a specific version ID.
+   * @param docId - The ID of the document.
+   * @param versionId - The ID of the version.
+   * @returns A promise resolving with an array of changes that constitute that version.
+   */
+  async getVersionChanges(docId, versionId) {
+    return this.rpc.call("getVersionChanges", { docId, versionId });
+  }
+  /**
+   * Updates the name of a specific version.
+   * @param docId - The ID of the document.
+   * @param versionId - The ID of the version to update.
+   * @param name - The new name for the version.
+   * @returns A promise resolving when the update is confirmed.
+   */
+  async updateVersion(docId, versionId, metadata) {
+    return this.rpc.call("updateVersion", { docId, versionId, metadata });
+  }
+  // === Branch Operations ===
+  /**
+   * Lists all branches for a document.
+   * @param docId - The ID of the document.
+   * @returns A promise resolving with an array of branch metadata objects.
+   */
+  async listBranches(docId) {
+    return this.rpc.call("listBranches", { docId });
+  }
+  /**
+   * Creates a new branch for a document.
+   * @param docId - The ID of the document.
+   * @param rev - The revision number to base the new branch on.
+   * @param metadata - Optional metadata for the new branch.
+   * @returns A promise resolving with the unique ID of the newly created branch.
+   */
+  async createBranch(docId, rev, metadata) {
+    return this.rpc.call("createBranch", { docId, rev, metadata });
+  }
+  /**
+   * Closes a branch on the server.
+   * @param branchId - The ID of the branch to close.
+   * @returns A promise resolving when the branch is closed.
+   */
+  async closeBranch(branchId) {
+    return this.rpc.call("closeBranch", { branchId });
+  }
+  /**
+   * Merges a branch on the server.
+   * @param branchId - The ID of the branch to merge.
+   * @returns A promise resolving when the merge is confirmed.
+   */
+  async mergeBranch(branchId) {
+    return this.rpc.call("mergeBranch", { branchId });
+  }
+}
+export {
+  PatchesClient
+};

package/dist/net/PatchesSync.d.ts

@@ -1,15 +1,23 @@
+import { Signal } from '../event-signal.js';
 import { Patches } from '../client/Patches.js';
-import type { PatchesStore } from '../client/PatchesStore.js';
-import type { Change, SyncingState } from '../types.js';
-import type { ConnectionState } from './protocol/types.js';
+import { PatchesStore } from '../client/PatchesStore.js';
+import { SyncingState, Change } from '../types.js';
+import { ConnectionState } from './protocol/types.js';
 import { PatchesWebSocket } from './websocket/PatchesWebSocket.js';
-import type { WebSocketOptions } from './websocket/WebSocketTransport.js';
-export interface PatchesSyncState {
+import { WebSocketOptions } from './websocket/WebSocketTransport.js';
+import '../client/PatchesDoc.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../json-patch/types.js';
+import './PatchesClient.js';
+import './protocol/JSONRPCClient.js';
+
+interface PatchesSyncState {
     online: boolean;
     connected: boolean;
     syncing: SyncingState;
 }
-export interface PatchesSyncOptions {
+interface PatchesSyncOptions {
     subscribeFilter?: (docIds: string[]) => string[];
     websocket?: WebSocketOptions;
 }
@@ -17,7 +25,7 @@ export interface PatchesSyncOptions {
  * Handles WebSocket connection, document subscriptions, and syncing logic between
  * the Patches instance and the server.
  */
-export declare class PatchesSync {
+declare class PatchesSync {
     protected options?: PatchesSyncOptions | undefined;
     protected ws: PatchesWebSocket;
     protected patches: Patches;
@@ -28,11 +36,11 @@ export declare class PatchesSync {
     /**
      * Signal emitted when the sync state changes.
      */
-    readonly onStateChange: import("../event-signal.js").Signal<(state: PatchesSyncState) => void>;
+    readonly onStateChange: Signal<(state: PatchesSyncState) => void>;
     /**
      * Signal emitted when an error occurs.
      */
-    readonly onError: import("../event-signal.js").Signal<(error: Error, context?: {
+    readonly onError: Signal<(error: Error, context?: {
         docId?: string;
     }) => void>;
     constructor(patches: Patches, url: string, options?: PatchesSyncOptions | undefined);
@@ -88,3 +96,5 @@ export declare class PatchesSync {
     protected _handleDocsTracked(docIds: string[]): Promise<void>;
     protected _handleDocsUntracked(docIds: string[]): Promise<void>;
 }
+
+export { PatchesSync, type PatchesSyncOptions, type PatchesSyncState };