@dabble/patches 0.4.4 → 0.4.6

package/dist/algorithms/server/handleOfflineSessionsAndBatches.js

@@ -1,80 +1,63 @@
-import { createSortableId } from 'crypto-id';
-import { createVersionMetadata } from '../../data/version.js';
-import { applyChanges } from '../shared/applyChanges.js';
-import { getStateAtRevision } from './getStateAtRevision.js';
-/**
- * Handles offline/large batch versioning logic for multi-batch uploads.
- * Groups changes into sessions, merges with previous batch if needed, and creates/extends versions.
- * @param docId Document ID
- * @param changes The incoming changes (all with the same batchId)
- * @param baseRev The base revision for the batch
- * @param batchId The batch identifier
- * @returns The collapsed changes for transformation
- */
-export async function handleOfflineSessionsAndBatches(store, sessionTimeoutMillis, docId, changes, baseRev, batchId) {
-    // Use batchId as groupId for multi-batch uploads; default offline sessions have no groupId
-    const groupId = batchId ?? createSortableId();
-    // Find the last version for this groupId (if any)
-    const [lastVersion] = await store.listVersions(docId, {
-        groupId,
-        reverse: true,
-        limit: 1,
-    });
-    let offlineBaseState;
-    let parentId;
-    if (lastVersion) {
-        // Continue from the last version's state
-        // loadVersionState returns a PatchState ({state, rev}); extract the .state
-        const vs = await store.loadVersionState(docId, lastVersion.id);
-        offlineBaseState = vs.state ?? vs;
-        parentId = lastVersion.id;
-    }
-    else {
-        // First batch for this batchId: start at baseRev
-        offlineBaseState = (await getStateAtRevision(store, docId, baseRev)).state;
-    }
-    let sessionStartIndex = 0;
-    for (let i = 1; i <= changes.length; i++) {
-        const isLastChange = i === changes.length;
-        const timeDiff = isLastChange ? Infinity : changes[i].created - changes[i - 1].created;
-        // Session ends if timeout exceeded OR it's the last change in the batch
-        if (timeDiff > sessionTimeoutMillis || isLastChange) {
-            const sessionChanges = changes.slice(sessionStartIndex, i);
-            if (sessionChanges.length > 0) {
-                // Check if this is a continuation of the previous session (merge/extend)
-                const isContinuation = !!lastVersion && sessionChanges[0].created - lastVersion.endDate <= sessionTimeoutMillis;
-                if (isContinuation) {
-                    // Merge/extend the existing version
-                    const mergedState = applyChanges(offlineBaseState, sessionChanges);
-                    await store.saveChanges(docId, sessionChanges);
-                    await store.updateVersion(docId, lastVersion.id, {}); // metadata already updated above
-                    offlineBaseState = mergedState;
-                    parentId = lastVersion.parentId;
-                }
-                else {
-                    // Create a new version for this session
-                    offlineBaseState = applyChanges(offlineBaseState, sessionChanges);
-                    const sessionMetadata = createVersionMetadata({
-                        parentId,
-                        groupId,
-                        origin: 'offline',
-                        startDate: sessionChanges[0].created,
-                        endDate: sessionChanges[sessionChanges.length - 1].created,
-                        rev: sessionChanges[sessionChanges.length - 1].rev,
-                        baseRev,
-                    });
-                    await store.createVersion(docId, sessionMetadata, offlineBaseState, sessionChanges);
-                    parentId = sessionMetadata.id;
-                }
-                sessionStartIndex = i;
-            }
+import "../../chunk-IZ2YBCUP.js";
+import { createSortableId } from "crypto-id";
+import { createVersionMetadata } from "../../data/version.js";
+import { applyChanges } from "../shared/applyChanges.js";
+import { getStateAtRevision } from "./getStateAtRevision.js";
+async function handleOfflineSessionsAndBatches(store, sessionTimeoutMillis, docId, changes, baseRev, batchId) {
+  const groupId = batchId ?? createSortableId();
+  const [lastVersion] = await store.listVersions(docId, {
+    groupId,
+    reverse: true,
+    limit: 1
+  });
+  let offlineBaseState;
+  let parentId;
+  if (lastVersion) {
+    const vs = await store.loadVersionState(docId, lastVersion.id);
+    offlineBaseState = vs.state ?? vs;
+    parentId = lastVersion.id;
+  } else {
+    offlineBaseState = (await getStateAtRevision(store, docId, baseRev)).state;
+  }
+  let sessionStartIndex = 0;
+  for (let i = 1; i <= changes.length; i++) {
+    const isLastChange = i === changes.length;
+    const timeDiff = isLastChange ? Infinity : changes[i].created - changes[i - 1].created;
+    if (timeDiff > sessionTimeoutMillis || isLastChange) {
+      const sessionChanges = changes.slice(sessionStartIndex, i);
+      if (sessionChanges.length > 0) {
+        const isContinuation = !!lastVersion && sessionChanges[0].created - lastVersion.endDate <= sessionTimeoutMillis;
+        if (isContinuation) {
+          const mergedState = applyChanges(offlineBaseState, sessionChanges);
+          await store.saveChanges(docId, sessionChanges);
+          await store.updateVersion(docId, lastVersion.id, {});
+          offlineBaseState = mergedState;
+          parentId = lastVersion.parentId;
+        } else {
+          offlineBaseState = applyChanges(offlineBaseState, sessionChanges);
+          const sessionMetadata = createVersionMetadata({
+            parentId,
+            groupId,
+            origin: "offline",
+            startDate: sessionChanges[0].created,
+            endDate: sessionChanges[sessionChanges.length - 1].created,
+            rev: sessionChanges[sessionChanges.length - 1].rev,
+            baseRev
+          });
+          await store.createVersion(docId, sessionMetadata, offlineBaseState, sessionChanges);
+          parentId = sessionMetadata.id;
         }
+        sessionStartIndex = i;
+      }
     }
-    // Collapse all changes into one for transformation
-    return [
-        changes.reduce((firstChange, nextChange) => {
-            firstChange.ops = [...firstChange.ops, ...nextChange.ops];
-            return firstChange;
-        }),
-    ];
+  }
+  return [
+    changes.reduce((firstChange, nextChange) => {
+      firstChange.ops = [...firstChange.ops, ...nextChange.ops];
+      return firstChange;
+    })
+  ];
 }
+export {
+  handleOfflineSessionsAndBatches
+};

package/dist/algorithms/server/transformIncomingChanges.d.ts

@@ -1,4 +1,8 @@
-import type { Change } from '../../types.js';
+import { Change } from '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+
 /**
  * Transforms incoming changes against committed changes that happened *after* the client's baseRev.
  * The state used for transformation should be the server state *at the client's baseRev*.
@@ -8,4 +12,6 @@ import type { Change } from '../../types.js';
  * @param currentRev The current/latest revision number (these changes will have their `rev` set > `currentRev`).
  * @returns The transformed changes.
  */
-export declare function transformIncomingChanges(changes: Change[], stateAtBaseRev: any, committedChanges: Change[], currentRev: number): Change[];
+declare function transformIncomingChanges(changes: Change[], stateAtBaseRev: any, committedChanges: Change[], currentRev: number): Change[];
+
+export { transformIncomingChanges };

package/dist/algorithms/server/transformIncomingChanges.js

@@ -1,40 +1,28 @@
-import { applyPatch } from '../../json-patch/applyPatch.js';
-import { transformPatch } from '../../json-patch/transformPatch.js';
-/**
- * Transforms incoming changes against committed changes that happened *after* the client's baseRev.
- * The state used for transformation should be the server state *at the client's baseRev*.
- * @param changes The incoming changes.
- * @param stateAtBaseRev The server state *at the client's baseRev*.
- * @param committedChanges The committed changes that happened *after* the client's baseRev.
- * @param currentRev The current/latest revision number (these changes will have their `rev` set > `currentRev`).
- * @returns The transformed changes.
- */
-export function transformIncomingChanges(changes, stateAtBaseRev, committedChanges, currentRev) {
-    const committedOps = committedChanges.flatMap(c => c.ops);
-    let state = stateAtBaseRev;
-    let rev = currentRev + 1;
-    // Apply transformation based on state at baseRev
-    return changes
-        .map(change => {
-        // Transform the incoming change's ops against the ops committed since baseRev
-        const transformedOps = transformPatch(stateAtBaseRev, committedOps, change.ops);
-        if (transformedOps.length === 0) {
-            return null; // Change is obsolete after transformation
-        }
-        try {
-            const previous = state;
-            state = applyPatch(state, transformedOps, { strict: true });
-            if (previous === state) {
-                // Changes were no-ops, we can skip this change
-                return null;
-            }
-        }
-        catch (error) {
-            console.error(`Error applying change ${change.id} to state:`, error);
-            return null;
-        }
-        // Return a new change object with transformed ops and original metadata
-        return { ...change, rev: rev++, ops: transformedOps };
-    })
-        .filter(Boolean);
+import "../../chunk-IZ2YBCUP.js";
+import { applyPatch } from "../../json-patch/applyPatch.js";
+import { transformPatch } from "../../json-patch/transformPatch.js";
+function transformIncomingChanges(changes, stateAtBaseRev, committedChanges, currentRev) {
+  const committedOps = committedChanges.flatMap((c) => c.ops);
+  let state = stateAtBaseRev;
+  let rev = currentRev + 1;
+  return changes.map((change) => {
+    const transformedOps = transformPatch(stateAtBaseRev, committedOps, change.ops);
+    if (transformedOps.length === 0) {
+      return null;
+    }
+    try {
+      const previous = state;
+      state = applyPatch(state, transformedOps, { strict: true });
+      if (previous === state) {
+        return null;
+      }
+    } catch (error) {
+      console.error(`Error applying change ${change.id} to state:`, error);
+      return null;
+    }
+    return { ...change, rev: rev++, ops: transformedOps };
+  }).filter(Boolean);
 }
+export {
+  transformIncomingChanges
+};

package/dist/algorithms/shared/applyChanges.d.ts

@@ -1,4 +1,8 @@
-import type { Change } from '../../types.js';
+import { Change } from '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+
 /**
  * Applies a sequence of changes to a state object.
  * Each change is applied in sequence using the applyPatch function.
@@ -7,4 +11,6 @@ import type { Change } from '../../types.js';
  * @param changes - Array of changes to apply
  * @returns The state after all changes have been applied
  */
-export declare function applyChanges<T>(state: T, changes: Change[]): T;
+declare function applyChanges<T>(state: T, changes: Change[]): T;
+
+export { applyChanges };

package/dist/algorithms/shared/applyChanges.js

@@ -1,17 +1,12 @@
-import { applyPatch } from '../../json-patch/applyPatch.js';
-/**
- * Applies a sequence of changes to a state object.
- * Each change is applied in sequence using the applyPatch function.
- *
- * @param state - The initial state to apply changes to
- * @param changes - Array of changes to apply
- * @returns The state after all changes have been applied
- */
-export function applyChanges(state, changes) {
-    if (!changes.length)
-        return state;
-    for (const change of changes) {
-        state = applyPatch(state, change.ops, { strict: true });
-    }
-    return state;
+import "../../chunk-IZ2YBCUP.js";
+import { applyPatch } from "../../json-patch/applyPatch.js";
+function applyChanges(state, changes) {
+  if (!changes.length) return state;
+  for (const change of changes) {
+    state = applyPatch(state, change.ops, { strict: true });
+  }
+  return state;
 }
+export {
+  applyChanges
+};

package/dist/algorithms/shared/rebaseChanges.d.ts

@@ -1,4 +1,8 @@
-import type { Change } from '../../types.js';
+import { Change } from '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+
 /**
  * Rebases local changes against server changes using operational transformation.
  * This function handles the transformation of local changes to be compatible with server changes
@@ -14,4 +18,6 @@ import type { Change } from '../../types.js';
  * @param localChanges - Array of local changes that need to be rebased
  * @returns Array of rebased local changes with updated revision numbers
  */
-export declare function rebaseChanges(serverChanges: Change[], localChanges: Change[]): Change[];
+declare function rebaseChanges(serverChanges: Change[], localChanges: Change[]): Change[];
+
+export { rebaseChanges };

package/dist/algorithms/shared/rebaseChanges.js

@@ -1,51 +1,32 @@
-import { JSONPatch } from '../../json-patch/JSONPatch.js';
-/**
- * Rebases local changes against server changes using operational transformation.
- * This function handles the transformation of local changes to be compatible with server changes
- * that have been applied in the meantime.
- *
- * The process:
- * 1. Filters out local changes that are already in server changes
- * 2. Creates a patch from server changes that need to be transformed against
- * 3. Transforms each remaining local change against the server patch
- * 4. Updates revision numbers for the transformed changes
- *
- * @param serverChanges - Array of changes received from the server
- * @param localChanges - Array of local changes that need to be rebased
- * @returns Array of rebased local changes with updated revision numbers
- */
-export function rebaseChanges(serverChanges, localChanges) {
-    if (!serverChanges.length || !localChanges.length) {
-        return localChanges;
+import "../../chunk-IZ2YBCUP.js";
+import { JSONPatch } from "../../json-patch/JSONPatch.js";
+function rebaseChanges(serverChanges, localChanges) {
+  if (!serverChanges.length || !localChanges.length) {
+    return localChanges;
+  }
+  const lastChange = serverChanges[serverChanges.length - 1];
+  const receivedIds = new Set(serverChanges.map((change) => change.id));
+  const transformAgainstIds = new Set(receivedIds);
+  const filteredLocalChanges = [];
+  for (const change of localChanges) {
+    if (receivedIds.has(change.id)) {
+      transformAgainstIds.delete(change.id);
+    } else {
+      filteredLocalChanges.push(change);
     }
-    const lastChange = serverChanges[serverChanges.length - 1];
-    const receivedIds = new Set(serverChanges.map(change => change.id));
-    const transformAgainstIds = new Set(receivedIds);
-    // Filter out local changes that are already in server changes
-    const filteredLocalChanges = [];
-    for (const change of localChanges) {
-        if (receivedIds.has(change.id)) {
-            transformAgainstIds.delete(change.id);
-        }
-        else {
-            filteredLocalChanges.push(change);
-        }
-    }
-    // Create a patch from server changes that need to be transformed against
-    const transformPatch = new JSONPatch(serverChanges
-        .filter(change => transformAgainstIds.has(change.id))
-        .map(change => change.ops)
-        .flat());
-    // Rebase local changes against server changes
-    const baseRev = lastChange.rev;
-    let rev = lastChange.rev;
-    return filteredLocalChanges
-        .map(change => {
-        rev++;
-        const ops = transformPatch.transform(change.ops).ops;
-        if (!ops.length)
-            return null;
-        return { ...change, baseRev, rev, ops };
-    })
-        .filter(Boolean);
+  }
+  const transformPatch = new JSONPatch(
+    serverChanges.filter((change) => transformAgainstIds.has(change.id)).map((change) => change.ops).flat()
+  );
+  const baseRev = lastChange.rev;
+  let rev = lastChange.rev;
+  return filteredLocalChanges.map((change) => {
+    rev++;
+    const ops = transformPatch.transform(change.ops).ops;
+    if (!ops.length) return null;
+    return { ...change, baseRev, rev, ops };
+  }).filter(Boolean);
 }
+export {
+  rebaseChanges
+};

package/dist/chunk-IZ2YBCUP.js

@@ -0,0 +1,56 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+export {
+  __decoratorStart,
+  __decoratorMetadata,
+  __runInitializers,
+  __decorateElement,
+  __publicField
+};

package/dist/client/InMemoryStore.d.ts

@@ -1,11 +1,15 @@
-import type { Change, PatchesSnapshot, PatchesState } from '../types.js';
-import type { PatchesStore, TrackedDoc } from './PatchesStore.js';
+import { PatchesSnapshot, Change, PatchesState } from '../types.js';
+import { PatchesStore, TrackedDoc } from './PatchesStore.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../json-patch/types.js';
+
 /**
  * A trivial in‑memory implementation of OfflineStore (soon PatchesStore).
  * All data lives in JS objects – nothing survives a page reload.
  * Useful for unit tests or when you want the old 'stateless realtime' behaviour.
  */
-export declare class InMemoryStore implements PatchesStore {
+declare class InMemoryStore implements PatchesStore {
     private docs;
     getDoc(docId: string): Promise<PatchesSnapshot | undefined>;
     getPendingChanges(docId: string): Promise<Change[]>;
@@ -21,3 +25,5 @@ export declare class InMemoryStore implements PatchesStore {
     confirmDeleteDoc(docId: string): Promise<void>;
     close(): Promise<void>;
 }
+
+export { InMemoryStore };