@sovereignbase/convergent-replicated-list 1.3.5 → 1.3.6

package/dist/index.cjs

@@ -436,6 +436,7 @@ function __update(listIndex, listValues, crListReplica, mode) {
   if (listValues.length === 0) return false;
   const change = {};
   const delta = { values: [], tombstones: [] };
+  let displacedEntry;
   for (const listValue of listValues) {
     const v7 = _uuid.v7.call(void 0, );
     const linkedListEntry = {
@@ -484,25 +485,37 @@ 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 (_optionalChain([entryToOverwrite, 'access', _48 => _48.next, 'optionalAccess', _49 => _49.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
+            ]);
+          _optionalChain([delta, 'access', _50 => _50.values, 'optionalAccess', _51 => _51.push, 'call', _52 => _52({
+            uuidv7: overwriteNext.uuidv7,
+            value: overwriteNext.value,
+            predecessor: overwriteNext.predecessor
+          })]);
         }
         void attachEntryToIndexes(crListReplica, linkedListEntry, delta);
         void crListReplica.tombstones.add(entryToOverwrite.uuidv7);
-        void _optionalChain([delta, 'access', _48 => _48.tombstones, 'optionalAccess', _49 => _49.push, 'call', _50 => _50(entryToOverwrite.uuidv7)]);
+        void _optionalChain([delta, 'access', _53 => _53.tombstones, 'optionalAccess', _54 => _54.push, 'call', _55 => _55(entryToOverwrite.uuidv7)]);
         void detachEntryFromIndexes(crListReplica, entryToOverwrite);
         entryToOverwrite.next = void 0;
         entryToOverwrite.prev = void 0;
         crListReplica.cursor = linkedListEntry;
         crListReplica.cursorIndex = actualIndex;
-        void _optionalChain([crListReplica, 'access', _51 => _51.index, 'optionalAccess', _52 => _52.set, 'call', _53 => _53(linkedListEntry.index, linkedListEntry)]);
+        void _optionalChain([crListReplica, 'access', _56 => _56.index, 'optionalAccess', _57 => _57.set, 'call', _58 => _58(linkedListEntry.index, linkedListEntry)]);
         change[actualIndex] = linkedListEntry.value;
         break;
       }
@@ -511,7 +524,7 @@ function __update(listIndex, listValues, crListReplica, mode) {
           crListReplica.cursor = linkedListEntry;
           crListReplica.cursorIndex = linkedListEntry.index;
           void attachEntryToIndexes(crListReplica, linkedListEntry, delta);
-          void _optionalChain([crListReplica, 'access', _54 => _54.index, 'optionalAccess', _55 => _55.set, 'call', _56 => _56(linkedListEntry.index, linkedListEntry)]);
+          void _optionalChain([crListReplica, 'access', _59 => _59.index, 'optionalAccess', _60 => _60.set, 'call', _61 => _61(linkedListEntry.index, linkedListEntry)]);
           change[linkedListEntry.index] = linkedListEntry.value;
           break;
         }
@@ -526,21 +539,25 @@ 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();
-        void _optionalChain([crListReplica, 'access', _57 => _57.index, 'optionalAccess', _58 => _58.set, 'call', _59 => _59(linkedListEntry.index, linkedListEntry)]);
+        if (next) {
+          if (crListReplica.index) crListReplica.index.clear();
+          else crListReplica.index = /* @__PURE__ */ new Map();
+        }
+        void _optionalChain([crListReplica, 'access', _62 => _62.index, 'optionalAccess', _63 => _63.set, 'call', _64 => _64(linkedListEntry.index, linkedListEntry)]);
         change[linkedListEntry.index] = linkedListEntry.value;
         break;
       }
@@ -549,7 +566,7 @@ function __update(listIndex, listValues, crListReplica, mode) {
           crListReplica.cursor = linkedListEntry;
           crListReplica.cursorIndex = linkedListEntry.index;
           void attachEntryToIndexes(crListReplica, linkedListEntry, delta);
-          void _optionalChain([crListReplica, 'access', _60 => _60.index, 'optionalAccess', _61 => _61.set, 'call', _62 => _62(linkedListEntry.index, linkedListEntry)]);
+          void _optionalChain([crListReplica, 'access', _65 => _65.index, 'optionalAccess', _66 => _66.set, 'call', _67 => _67(linkedListEntry.index, linkedListEntry)]);
           change[linkedListEntry.index] = linkedListEntry.value;
           mode = "after";
           listIndex = linkedListEntry.index - 1;
@@ -560,21 +577,27 @@ function __update(listIndex, listValues, crListReplica, mode) {
         const actualIndex = _nullishCoalesce(crListReplica.cursorIndex, () => ( listIndex));
         const prev = crListReplica.cursor.prev;
         linkedListEntry.index = actualIndex;
-        linkedListEntry.predecessor = _nullishCoalesce(_optionalChain([prev, 'optionalAccess', _63 => _63.uuidv7]), () => ( "\0"));
+        linkedListEntry.predecessor = _nullishCoalesce(_optionalChain([prev, 'optionalAccess', _68 => _68.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();
-        void _optionalChain([crListReplica, 'access', _64 => _64.index, 'optionalAccess', _65 => _65.set, 'call', _66 => _66(linkedListEntry.index, linkedListEntry)]);
+        if (crListReplica.index) crListReplica.index.clear();
+        else crListReplica.index = /* @__PURE__ */ new Map();
+        void _optionalChain([crListReplica, 'access', _69 => _69.index, 'optionalAccess', _70 => _70.set, 'call', _71 => _71(linkedListEntry.index, linkedListEntry)]);
         change[actualIndex] = linkedListEntry.value;
         mode = "after";
         listIndex = linkedListEntry.index - 1;
@@ -584,6 +607,19 @@ function __update(listIndex, listValues, crListReplica, mode) {
     crListReplica.size = crListReplica.parentMap.size;
     listIndex++;
   }
+  if (displacedEntry) {
+    const sibs = crListReplica.childrenMap.get(displacedEntry.predecessor);
+    if (sibs) sibs.push(displacedEntry);
+    else
+      crListReplica.childrenMap.set(displacedEntry.predecessor, [
+        displacedEntry
+      ]);
+    _optionalChain([delta, 'access', _72 => _72.values, 'optionalAccess', _73 => _73.push, 'call', _74 => _74({
+      uuidv7: displacedEntry.uuidv7,
+      value: displacedEntry.value,
+      predecessor: displacedEntry.predecessor
+    })]);
+  }
   return { change, delta };
 }
 
@@ -601,7 +637,7 @@ function __delete(crListReplica, startIndex, endIndex) {
   void seekCursorToIndex(listIndex, crListReplica);
   if (!crListReplica.cursor) return false;
   let current = crListReplica.cursor;
-  const predecessor = _nullishCoalesce(_optionalChain([current, 'access', _67 => _67.prev, 'optionalAccess', _68 => _68.uuidv7]), () => ( "\0"));
+  const predecessor = _nullishCoalesce(_optionalChain([current, 'access', _75 => _75.prev, 'optionalAccess', _76 => _76.uuidv7]), () => ( "\0"));
   const deletedIds = /* @__PURE__ */ new Set();
   let deleted = 0;
   let currentIndex = _nullishCoalesce(crListReplica.cursorIndex, () => ( listIndex));
@@ -609,7 +645,7 @@ function __delete(crListReplica, startIndex, endIndex) {
     const next = current.next;
     change[currentIndex] = void 0;
     void deletedIds.add(current.uuidv7);
-    void _optionalChain([crListReplica, 'access', _69 => _69.index, 'optionalAccess', _70 => _70.delete, 'call', _71 => _71(currentIndex)]);
+    void _optionalChain([crListReplica, 'access', _77 => _77.index, 'optionalAccess', _78 => _78.delete, 'call', _79 => _79(currentIndex)]);
     void deleteLiveEntry(crListReplica, current, delta);
     current = next;
     currentIndex++;
@@ -629,7 +665,7 @@ function __delete(crListReplica, startIndex, endIndex) {
     void deleteLiveEntry(crListReplica, current, delta);
     void linkEntryBetween(prev, replacement, next);
     void attachEntryToIndexes(crListReplica, replacement, delta);
-    if (_optionalChain([next, 'optionalAccess', _72 => _72.predecessor]) === current.uuidv7)
+    if (_optionalChain([next, 'optionalAccess', _80 => _80.predecessor]) === current.uuidv7)
       void moveEntryToPredecessor(
         crListReplica,
         next,
@@ -675,7 +711,7 @@ function __merge(crListReplica, crListDelta) {
       crListReplica.cursorIndex = linkedListEntry.index;
       void attachEntryToIndexes(crListReplica, linkedListEntry);
       crListReplica.size = crListReplica.parentMap.size;
-      void _optionalChain([crListReplica, 'access', _73 => _73.index, 'optionalAccess', _74 => _74.set, 'call', _75 => _75(linkedListEntry.index, linkedListEntry)]);
+      void _optionalChain([crListReplica, 'access', _81 => _81.index, 'optionalAccess', _82 => _82.set, 'call', _83 => _83(linkedListEntry.index, linkedListEntry)]);
       return { [linkedListEntry.index]: linkedListEntry.value };
     }
   }
@@ -689,7 +725,7 @@ function __merge(crListReplica, crListDelta) {
         const wasTail = linkedListEntry.next === void 0;
         const wasCursor = crListReplica.cursor === linkedListEntry;
         void newTombsIndices.push(linkedListEntry.index);
-        void _optionalChain([crListReplica, 'access', _76 => _76.index, 'optionalAccess', _77 => _77.delete, 'call', _78 => _78(linkedListEntry.index)]);
+        void _optionalChain([crListReplica, 'access', _84 => _84.index, 'optionalAccess', _85 => _85.delete, 'call', _86 => _86(linkedListEntry.index)]);
         void deleteLiveEntry(crListReplica, linkedListEntry);
         tailTombstoneMovedCursor = wasTail && wasCursor;
         needsRelink = true;
@@ -701,7 +737,7 @@ function __merge(crListReplica, crListDelta) {
     if (newTombsIndices.length === 1 && tailTombstoneMovedCursor) {
       if (crListReplica.cursor) {
         crListReplica.cursorIndex = crListReplica.size - 1;
-        void _optionalChain([crListReplica, 'access', _79 => _79.index, 'optionalAccess', _80 => _80.set, 'call', _81 => _81(
+        void _optionalChain([crListReplica, 'access', _87 => _87.index, 'optionalAccess', _88 => _88.set, 'call', _89 => _89(
           crListReplica.cursorIndex,
           crListReplica.cursor
         )]);
@@ -748,7 +784,7 @@ function __merge(crListReplica, crListDelta) {
         crListReplica.cursor = linkedListEntry;
         crListReplica.cursorIndex = linkedListEntry.index;
         crListReplica.size = crListReplica.parentMap.size;
-        void _optionalChain([crListReplica, 'access', _82 => _82.index, 'optionalAccess', _83 => _83.set, 'call', _84 => _84(linkedListEntry.index, linkedListEntry)]);
+        void _optionalChain([crListReplica, 'access', _90 => _90.index, 'optionalAccess', _91 => _91.set, 'call', _92 => _92(linkedListEntry.index, linkedListEntry)]);
       } else {
         needsRelink = true;
       }
@@ -759,7 +795,7 @@ function __merge(crListReplica, crListDelta) {
       crListReplica.cursor = linkedListEntry;
       crListReplica.cursorIndex = linkedListEntry.index;
       crListReplica.size = crListReplica.parentMap.size;
-      void _optionalChain([crListReplica, 'access', _85 => _85.index, 'optionalAccess', _86 => _86.set, 'call', _87 => _87(linkedListEntry.index, linkedListEntry)]);
+      void _optionalChain([crListReplica, 'access', _93 => _93.index, 'optionalAccess', _94 => _94.set, 'call', _95 => _95(linkedListEntry.index, linkedListEntry)]);
     } else {
       needsRelink = true;
     }
@@ -924,32 +960,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(_nullishCoalesce(beforeIndex, () => ( 0)), [value], this.state, "before");
+  prepend(values, beforeIndex) {
+    const result = __update(_nullishCoalesce(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(
       _nullishCoalesce(afterIndex, () => ( this.state.size)),
-      [value],
+      values,
       this.state,
       "after"
     );
@@ -958,6 +994,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.
    *
@@ -981,8 +1030,8 @@ var CRList = class {
    * @param thisArg - Optional `this` value for the predicate.
    */
   find(predicate, thisArg) {
-    let linkedListEntry = _nullishCoalesce(_optionalChain([this, 'access', _88 => _88.state, 'access', _89 => _89.index, 'optionalAccess', _90 => _90.get, 'call', _91 => _91(0)]), () => ( this.state.cursor));
-    while (_optionalChain([linkedListEntry, 'optionalAccess', _92 => _92.prev])) linkedListEntry = linkedListEntry.prev;
+    let linkedListEntry = _nullishCoalesce(_optionalChain([this, 'access', _96 => _96.state, 'access', _97 => _97.index, 'optionalAccess', _98 => _98.get, 'call', _99 => _99(0)]), () => ( this.state.cursor));
+    while (_optionalChain([linkedListEntry, 'optionalAccess', _100 => _100.prev])) linkedListEntry = linkedListEntry.prev;
     let index = 0;
     while (linkedListEntry) {
       if (predicate.call(thisArg, linkedListEntry.value, index, this))
@@ -1092,8 +1141,8 @@ var CRList = class {
    * Iterates over current live values in index order.
    */
   *[Symbol.iterator]() {
-    let linkedListEntry = _nullishCoalesce(_optionalChain([this, 'access', _93 => _93.state, 'access', _94 => _94.index, 'optionalAccess', _95 => _95.get, 'call', _96 => _96(0)]), () => ( this.state.cursor));
-    while (_optionalChain([linkedListEntry, 'optionalAccess', _97 => _97.prev])) linkedListEntry = linkedListEntry.prev;
+    let linkedListEntry = _nullishCoalesce(_optionalChain([this, 'access', _101 => _101.state, 'access', _102 => _102.index, 'optionalAccess', _103 => _103.get, 'call', _104 => _104(0)]), () => ( this.state.cursor));
+    while (_optionalChain([linkedListEntry, 'optionalAccess', _105 => _105.prev])) linkedListEntry = linkedListEntry.prev;
     while (linkedListEntry) {
       yield linkedListEntry.value;
       linkedListEntry = linkedListEntry.next;
@@ -1109,8 +1158,8 @@ var CRList = class {
    * @param thisArg - Optional `this` value for the callback.
    */
   forEach(callback, thisArg) {
-    let linkedListEntry = _nullishCoalesce(_optionalChain([this, 'access', _98 => _98.state, 'access', _99 => _99.index, 'optionalAccess', _100 => _100.get, 'call', _101 => _101(0)]), () => ( this.state.cursor));
-    while (_optionalChain([linkedListEntry, 'optionalAccess', _102 => _102.prev])) linkedListEntry = linkedListEntry.prev;
+    let linkedListEntry = _nullishCoalesce(_optionalChain([this, 'access', _106 => _106.state, 'access', _107 => _107.index, 'optionalAccess', _108 => _108.get, 'call', _109 => _109(0)]), () => ( this.state.cursor));
+    while (_optionalChain([linkedListEntry, 'optionalAccess', _110 => _110.prev])) linkedListEntry = linkedListEntry.prev;
     let index = 0;
     while (linkedListEntry) {
       void callback.call(thisArg, linkedListEntry.value, index, this);