@sovereignbase/convergent-replicated-list 1.3.5 → 1.3.7

package/dist/index.js

@@ -112,9 +112,19 @@ function rebuildLiveProjection(crListReplica) {
     while (stack.length > 0) {
       const frame = stack[stack.length - 1];
       if (!frame.siblings) {
-        frame.siblings = crListReplica.childrenMap.get(
+        const childrenMapSibs = crListReplica.childrenMap.get(
           frame.predecessorIdentifier
         );
+        const runNextEntry = crListReplica.runNext?.get(
+          frame.predecessorIdentifier
+        );
+        if (childrenMapSibs && runNextEntry) {
+          frame.siblings = [...childrenMapSibs, runNextEntry];
+        } else if (runNextEntry) {
+          frame.siblings = [runNextEntry];
+        } else {
+          frame.siblings = childrenMapSibs;
+        }
         if (!frame.siblings) {
           void stack.pop();
           continue;
@@ -198,9 +208,21 @@ function attachEntryToIndexes(crListReplica, linkedListEntry, deltaBuf) {
 function detachEntryFromIndexes(crListReplica, linkedListEntry) {
   void crListReplica.parentMap.delete(linkedListEntry.uuidv7);
   const siblings = crListReplica.childrenMap.get(linkedListEntry.predecessor);
-  if (!siblings) return;
-  const index = siblings.indexOf(linkedListEntry);
-  if (index !== -1) void siblings.splice(index, 1);
+  if (siblings) {
+    const index = siblings.indexOf(linkedListEntry);
+    if (index !== -1) void siblings.splice(index, 1);
+  }
+  if (crListReplica.runNext) {
+    if (crListReplica.runNext.get(linkedListEntry.predecessor) === linkedListEntry)
+      crListReplica.runNext.delete(linkedListEntry.predecessor);
+    const runSuccessor = crListReplica.runNext.get(linkedListEntry.uuidv7);
+    if (runSuccessor) {
+      crListReplica.runNext.delete(linkedListEntry.uuidv7);
+      const sibs = crListReplica.childrenMap.get(linkedListEntry.uuidv7);
+      if (sibs) sibs.push(runSuccessor);
+      else crListReplica.childrenMap.set(linkedListEntry.uuidv7, [runSuccessor]);
+    }
+  }
 }
 
 // src/.helpers/deleteLiveEntry/index.ts
@@ -363,6 +385,13 @@ function trySpliceSiblingInsert(crListReplica, insertedEntries, reparentedEntrie
   return true;
 }
 
+// src/.helpers/deriveRunUuid/index.ts
+function deriveRunUuid(startUuid, offset) {
+  const randA = parseInt(startUuid.slice(15, 18), 16);
+  const newRandA = randA + offset & 4095;
+  return startUuid.slice(0, 15) + newRandA.toString(16).padStart(3, "0") + startUuid.slice(18);
+}
+
 // src/core/crud/create/index.ts
 import { isUuidV7 as isUuidV72, prototype } from "@sovereignbase/utils";
 function __create(snapshot) {
@@ -436,6 +465,8 @@ function __update(listIndex, listValues, crListReplica, mode) {
   if (listValues.length === 0) return false;
   const change = {};
   const delta = { values: [], tombstones: [] };
+  let displacedEntry;
+  const batchEntries = [];
   for (const listValue of listValues) {
     const v7 = uuidv7();
     const linkedListEntry = {
@@ -484,15 +515,27 @@ function __update(listIndex, listValues, crListReplica, mode) {
           linkedListEntry,
           entryToOverwrite.next
         );
-        if (entryToOverwrite.next) {
-          if (entryToOverwrite.next.predecessor === entryToOverwrite.uuidv7) {
-            void moveEntryToPredecessor(
-              crListReplica,
-              entryToOverwrite.next,
-              linkedListEntry.uuidv7,
-              delta
-            );
+        if (entryToOverwrite.next?.predecessor === entryToOverwrite.uuidv7) {
+          const overwriteNext = entryToOverwrite.next;
+          const owSibs = crListReplica.childrenMap.get(
+            overwriteNext.predecessor
+          );
+          if (owSibs) {
+            const i = owSibs.indexOf(overwriteNext);
+            if (i !== -1) owSibs.splice(i, 1);
           }
+          overwriteNext.predecessor = linkedListEntry.uuidv7;
+          const newSibs = crListReplica.childrenMap.get(linkedListEntry.uuidv7);
+          if (newSibs) newSibs.push(overwriteNext);
+          else
+            crListReplica.childrenMap.set(linkedListEntry.uuidv7, [
+              overwriteNext
+            ]);
+          delta.values?.push({
+            uuidv7: overwriteNext.uuidv7,
+            value: overwriteNext.value,
+            predecessor: overwriteNext.predecessor
+          });
         }
         void attachEntryToIndexes(crListReplica, linkedListEntry, delta);
         void crListReplica.tombstones.add(entryToOverwrite.uuidv7);
@@ -526,20 +569,24 @@ function __update(listIndex, listValues, crListReplica, mode) {
         linkedListEntry.index = actualIndex + 1;
         linkedListEntry.predecessor = crListReplica.cursor.uuidv7;
         void linkEntryBetween(crListReplica.cursor, linkedListEntry, next);
-        if (next) {
-          if (next.predecessor === crListReplica.cursor.uuidv7) {
-            void moveEntryToPredecessor(
-              crListReplica,
-              next,
-              linkedListEntry.uuidv7,
-              delta
-            );
+        if (next && next.predecessor === crListReplica.cursor.uuidv7) {
+          if (!displacedEntry) {
+            displacedEntry = next;
+            const sibs = crListReplica.childrenMap.get(next.predecessor);
+            if (sibs) {
+              const i = sibs.indexOf(next);
+              if (i !== -1) sibs.splice(i, 1);
+            }
           }
+          displacedEntry.predecessor = linkedListEntry.uuidv7;
         }
         void attachEntryToIndexes(crListReplica, linkedListEntry, delta);
         crListReplica.cursor = linkedListEntry;
         crListReplica.cursorIndex = linkedListEntry.index;
-        if (next) crListReplica.index = /* @__PURE__ */ new Map();
+        if (next) {
+          if (crListReplica.index) crListReplica.index.clear();
+          else crListReplica.index = /* @__PURE__ */ new Map();
+        }
         void crListReplica.index?.set(linkedListEntry.index, linkedListEntry);
         change[linkedListEntry.index] = linkedListEntry.value;
         break;
@@ -563,17 +610,23 @@ function __update(listIndex, listValues, crListReplica, mode) {
         linkedListEntry.predecessor = prev?.uuidv7 ?? "\0";
         void linkEntryBetween(prev, linkedListEntry, crListReplica.cursor);
         if (crListReplica.cursor.predecessor === linkedListEntry.predecessor) {
-          void moveEntryToPredecessor(
-            crListReplica,
-            crListReplica.cursor,
-            linkedListEntry.uuidv7,
-            delta
-          );
+          if (!displacedEntry) {
+            displacedEntry = crListReplica.cursor;
+            const sibs = crListReplica.childrenMap.get(
+              crListReplica.cursor.predecessor
+            );
+            if (sibs) {
+              const i = sibs.indexOf(crListReplica.cursor);
+              if (i !== -1) sibs.splice(i, 1);
+            }
+          }
+          displacedEntry.predecessor = linkedListEntry.uuidv7;
         }
         void attachEntryToIndexes(crListReplica, linkedListEntry, delta);
         crListReplica.cursor = linkedListEntry;
         crListReplica.cursorIndex = actualIndex;
-        crListReplica.index = /* @__PURE__ */ new Map();
+        if (crListReplica.index) crListReplica.index.clear();
+        else crListReplica.index = /* @__PURE__ */ new Map();
         void crListReplica.index?.set(linkedListEntry.index, linkedListEntry);
         change[actualIndex] = linkedListEntry.value;
         mode = "after";
@@ -581,9 +634,49 @@ function __update(listIndex, listValues, crListReplica, mode) {
         break;
       }
     }
+    batchEntries.push(linkedListEntry);
     crListReplica.size = crListReplica.parentMap.size;
     listIndex++;
   }
+  if (batchEntries.length > 1) {
+    for (let k = 0; k + 1 < batchEntries.length; k++) {
+      const curr = batchEntries[k];
+      const next = batchEntries[k + 1];
+      if (next.predecessor !== curr.uuidv7) continue;
+      crListReplica.childrenMap.delete(curr.uuidv7);
+      if (!crListReplica.runNext) crListReplica.runNext = /* @__PURE__ */ new Map();
+      crListReplica.runNext.set(curr.uuidv7, next);
+    }
+  }
+  if (batchEntries.length > 1 && delta.values && delta.values.length >= batchEntries.length) {
+    const first = batchEntries[0];
+    const last = batchEntries[batchEntries.length - 1];
+    if (deriveRunUuid(first.uuidv7, batchEntries.length - 1) === last.uuidv7) {
+      delta.values.splice(
+        delta.values.length - batchEntries.length,
+        batchEntries.length,
+        {
+          uuidv7: first.uuidv7,
+          value: first.value,
+          predecessor: first.predecessor,
+          tail: batchEntries.slice(1).map((e) => e.value)
+        }
+      );
+    }
+  }
+  if (displacedEntry) {
+    const sibs = crListReplica.childrenMap.get(displacedEntry.predecessor);
+    if (sibs) sibs.push(displacedEntry);
+    else
+      crListReplica.childrenMap.set(displacedEntry.predecessor, [
+        displacedEntry
+      ]);
+    delta.values?.push({
+      uuidv7: displacedEntry.uuidv7,
+      value: displacedEntry.value,
+      predecessor: displacedEntry.predecessor
+    });
+  }
   return { change, delta };
 }
 
@@ -660,9 +753,20 @@ function __merge(crListReplica, crListDelta) {
   const change = {};
   let tailTombstoneMovedCursor = false;
   let needsRelink = false;
-  if (Object.hasOwn(crListDelta, "values") && Array.isArray(crListDelta.values) && crListDelta.values.length === 1 && (!Object.hasOwn(crListDelta, "tombstones") || Array.isArray(crListDelta.tombstones) && crListDelta.tombstones.length === 0)) {
+  const expandedValues = Object.hasOwn(crListDelta, "values") && Array.isArray(crListDelta.values) ? crListDelta.values.flatMap((entry) => {
+    if (!entry || !entry.tail || entry.tail.length === 0) return [entry];
+    return [
+      entry,
+      ...entry.tail.map((value, i) => ({
+        uuidv7: deriveRunUuid(entry.uuidv7, i + 1),
+        value,
+        predecessor: deriveRunUuid(entry.uuidv7, i)
+      }))
+    ];
+  }) : void 0;
+  if (expandedValues?.length === 1 && (!Object.hasOwn(crListDelta, "tombstones") || Array.isArray(crListDelta.tombstones) && crListDelta.tombstones.length === 0)) {
     const linkedListEntry = materializeSnapshotEntry(
-      crListDelta.values[0],
+      expandedValues[0],
       crListReplica
     );
     if (!linkedListEntry) return false;
@@ -696,7 +800,7 @@ function __merge(crListReplica, crListDelta) {
       }
     }
   }
-  if (!Object.hasOwn(crListDelta, "values") || !Array.isArray(crListDelta.values) || crListDelta.values.length === 0 && tailTombstoneMovedCursor) {
+  if (!expandedValues || expandedValues.length === 0 && tailTombstoneMovedCursor) {
     if (newTombsIndices.length === 0) return false;
     if (newTombsIndices.length === 1 && tailTombstoneMovedCursor) {
       if (crListReplica.cursor) {
@@ -717,7 +821,7 @@ function __merge(crListReplica, crListDelta) {
     }
     return change;
   }
-  for (const valueEntry of crListDelta.values) {
+  for (const valueEntry of expandedValues) {
     if (valueEntry === null || valueEntry === void 0) continue;
     const existingEntry = crListReplica.parentMap.get(valueEntry.uuidv7);
     if (existingEntry) {
@@ -924,32 +1028,32 @@ var CRList = class {
     return this.state.size;
   }
   /**
-   * Inserts a value before an index.
+   * Inserts values before an index.
    *
-   * If `beforeIndex` is omitted, the value is inserted at the start of the list.
+   * If `beforeIndex` is omitted, values are inserted at the start of the list.
    *
-   * @param value - The value to insert.
+   * @param values - Values to insert.
    * @param beforeIndex - The index to insert before.
    */
-  prepend(value, beforeIndex) {
-    const result = __update(beforeIndex ?? 0, [value], this.state, "before");
+  prepend(values, beforeIndex) {
+    const result = __update(beforeIndex ?? 0, values, this.state, "before");
     if (!result) return;
     const { delta, change } = result;
     if (delta) void dispatchCRListEvent(this.eventTarget, "delta", delta);
     if (change) void dispatchCRListEvent(this.eventTarget, "change", change);
   }
   /**
-   * Inserts a value after an index.
+   * Inserts values after an index.
    *
-   * If `afterIndex` is omitted, the value is appended at the end of the list.
+   * If `afterIndex` is omitted, values are appended at the end of the list.
    *
-   * @param value - The value to insert.
+   * @param values - Values to insert.
    * @param afterIndex - The index to insert after.
    */
-  append(value, afterIndex) {
+  append(values, afterIndex) {
     const result = __update(
       afterIndex ?? this.state.size,
-      [value],
+      values,
       this.state,
       "after"
     );
@@ -958,6 +1062,19 @@ var CRList = class {
     if (delta) void dispatchCRListEvent(this.eventTarget, "delta", delta);
     if (change) void dispatchCRListEvent(this.eventTarget, "change", change);
   }
+  /**
+   * Overwrites entries starting at an index.
+   *
+   * @param index - The index to start overwriting at.
+   * @param values - Values to write.
+   */
+  update(index, values) {
+    const result = __update(index, values, this.state, "overwrite");
+    if (!result) return;
+    const { delta, change } = result;
+    if (delta) void dispatchCRListEvent(this.eventTarget, "delta", delta);
+    if (change) void dispatchCRListEvent(this.eventTarget, "change", change);
+  }
   /**
    * Removes one or more entries starting at an index.
    *