@dabble/patches 0.2.32 → 0.3.1

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

@@ -1,6 +1,5 @@
 import { getOpData } from './getOpData.js';
 export function get(state, path) {
-    // eslint-disable-next-line no-unused-vars
     const [, lastKey, target] = getOpData(state, path);
     return target ? target[lastKey] : undefined;
 }

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

@@ -1,2 +1,5 @@
+export declare let log: {
+    (...data: any[]): void;
+    (message?: any, ...optionalParams: any[]): void;
+};
 export declare function verbose(value: boolean): void;
-export declare function log(...rest: any[]): void;

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

@@ -1,7 +1,4 @@
-let displayLogs = false;
+export let log = console.log;
 export function verbose(value) {
-    displayLogs = value;
-}
-export function log(...rest) {
-    displayLogs && console.log(...rest);
+    log = value ? console.log : () => undefined;
 }

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

@@ -6,7 +6,7 @@ export declare function isAdd(state: State, op: JSONPatchOp, pathName: 'from' |
 /**
  * Transforms an array of ops, returning the original if there is no change, filtering out ops that are dropped.
  */
-export declare function mapAndFilterOps(ops: JSONPatchOp[], iterator: (op: JSONPatchOp, index: number, breakAfter: (keepRest?: boolean) => {}) => JSONPatchOp | JSONPatchOp[] | null): JSONPatchOp[];
+export declare function mapAndFilterOps(ops: JSONPatchOp[], iterator: (op: JSONPatchOp, index: number, breakAfter: (keepRest?: boolean) => void) => JSONPatchOp | JSONPatchOp[] | null): JSONPatchOp[];
 /**
  * Remove operations that apply to a value which was removed.
  */

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

@@ -17,7 +17,10 @@ export function mapAndFilterOps(ops, iterator) {
     const mapped = [];
     let shouldBreak = false;
     let keepRest;
-    const breakAfter = (keep) => (shouldBreak = true) && (keepRest = keep);
+    const breakAfter = (keep) => {
+        shouldBreak = true;
+        keepRest = keep;
+    };
     for (let i = 0; i < ops.length; i++) {
         const original = ops[i];
         // If an op was copied or moved to the same path, it is a no-op and should be removed

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

@@ -23,7 +23,7 @@ export function isArrayPath(path, state) {
     if (!state || !state.root || !state.root[''])
         return true;
     // Double-check if this is an array or not
-    const [_, __, target] = getOpData(state, path);
+    const [, , target] = getOpData(state, path);
     return Array.isArray(target) || target == null;
 }
 export function getArrayPrefixAndIndex(state, path, pathLength) {
@@ -31,7 +31,7 @@ export function getArrayPrefixAndIndex(state, path, pathLength) {
         path = path.slice(0, path.indexOf('/', pathLength));
     if (!arrayPathExp.test(path))
         return EMPTY;
-    const [_, __, target] = getOpData(state, path);
+    const [, , target] = getOpData(state, path);
     if (!Array.isArray(target))
         return EMPTY;
     const [prefix, indexStr] = getPrefixAndProp(path);

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

@@ -5,7 +5,7 @@ export function toArrayIndex(array, str) {
     for (let i = 0, imax = str.length; i < imax; i++) {
         const ch = str.charCodeAt(i);
         if (57 < ch || ch < 48) {
-            return Infinity;
+            return -1;
         }
     }
     return +str;

package/dist/net/PatchesSync.d.ts

@@ -1,18 +1,11 @@
 import { Patches } from '../client/Patches.js';
+import type { Change, SyncingState } from '../types.js';
+import type { ConnectionState } from './protocol/types.js';
 import type { WebSocketOptions } from './websocket/WebSocketTransport.js';
-export interface PatchesSyncOptions {
-    /** WebSocket connection options */
-    wsOptions?: WebSocketOptions;
-    /**
-     * Maximum size in bytes for a single payload (network message).
-     * Changes exceeding this will be automatically split.
-     */
-    maxPayloadBytes?: number;
-}
 export interface PatchesSyncState {
     online: boolean;
     connected: boolean;
-    syncing: 'initial' | 'updating' | null | Error;
+    syncing: SyncingState;
 }
 /**
  * Handles WebSocket connection, document subscriptions, and syncing logic between
@@ -22,31 +15,69 @@ export declare class PatchesSync {
     private ws;
     private patches;
     private store;
-    private options;
+    private maxPayloadBytes?;
     private trackedDocs;
-    private isFlushing;
-    private globalSyncTimeout;
     private _state;
+    /**
+     * Signal emitted when the sync state changes.
+     */
     readonly onStateChange: import("../event-signal.js").Signal<(state: PatchesSyncState) => void>;
+    /**
+     * Signal emitted when an error occurs.
+     */
     readonly onError: import("../event-signal.js").Signal<(error: Error, context?: {
         docId?: string;
     }) => void>;
-    constructor(url: string, patches: Patches, options?: PatchesSyncOptions);
+    constructor(patches: Patches, url: string, wsOptions?: WebSocketOptions);
+    /**
+     * Gets the current sync state.
+     */
     get state(): PatchesSyncState;
-    private setState;
+    /**
+     * Updates the sync state.
+     * @param update - The partial state to update.
+     */
+    protected updateState(update: Partial<PatchesSyncState>): void;
+    /**
+     * Connects to the WebSocket server and starts syncing if online. If not online, it will wait for online state.
+     */
     connect(): Promise<void>;
+    /**
+     * Disconnects from the WebSocket server and stops syncing.
+     */
     disconnect(): void;
-    private scheduleGlobalSync;
-    syncAllKnownDocs(): Promise<void>;
-    syncDoc(docId: string): Promise<void>;
-    flushDoc(docId: string): Promise<void>;
+    /**
+     * Syncs all known docs when initially connected.
+     */
+    protected syncAllKnownDocs(): Promise<void>;
+    /**
+     * Syncs a single document.
+     * @param docId The ID of the document to sync.
+     */
+    protected syncDoc(docId: string): Promise<void>;
+    /**
+     * Flushes a document to the server.
+     * @param docId The ID of the document to flush.
+     */
+    protected flushDoc(docId: string): Promise<void>;
+    /**
+     * Receives committed changes from the server and applies them to the document. This is a blockable function, so it
+     * is separate from applyServerChangesToDoc, which is called by other blockable functions. Ensuring this is blockable
+     * ensures that while a doc is sending changes to the server, it isn't receiving changes from the server which could
+     * cause a race condition.
+     */
+    protected _receiveCommittedChanges(docId: string, serverChanges: Change[]): Promise<void>;
+    /**
+     * Applies server changes to a document using the centralized sync algorithm.
+     * This ensures consistent OT behavior regardless of whether the doc is open in memory.
+     */
+    protected _applyServerChangesToDoc(docId: string, serverChanges: Change[], sentPendingRange?: [number, number]): Promise<void>;
     /**
      * Initiates the deletion process for a document both locally and on the server.
      * This now delegates the local tombstone marking to Patches.
      */
-    _handleDocDeleted(docId: string): Promise<void>;
-    private _handleOnlineChange;
-    private _handleConnectionChange;
-    private _handleDocsTracked;
-    private _handleDocsUntracked;
+    protected _handleDocDeleted(docId: string): Promise<void>;
+    protected _handleConnectionChange(connectionState: ConnectionState): void;
+    protected _handleDocsTracked(docIds: string[]): Promise<void>;
+    protected _handleDocsUntracked(docIds: string[]): Promise<void>;
 }