@yorkie-js/sdk 0.7.6 → 0.7.7

package/dist/yorkie-js-sdk.js

@@ -11134,6 +11134,32 @@
         }
         actualRight.push(child);
       }
+      if (versionVector) {
+        const movedToLeft = [];
+        const remaining = [];
+        let boundaryReached = false;
+        for (const child of actualRight) {
+          if (!boundaryReached) {
+            if (child.insPrevID !== void 0 && !child.isText) {
+              remaining.push(child);
+              continue;
+            }
+            const actorID = child.id.getCreatedAt().getActorID();
+            const knownLamport = versionVector.get(actorID);
+            if (knownLamport === void 0 || knownLamport < child.id.getCreatedAt().getLamport()) {
+              movedToLeft.push(child);
+              continue;
+            }
+          }
+          boundaryReached = true;
+          remaining.push(child);
+        }
+        if (movedToLeft.length > 0) {
+          left.push(...movedToLeft);
+          actualRight.length = 0;
+          actualRight.push(...remaining);
+        }
+      }
       this._children = left;
       clone._children = actualRight;
       this.visibleSize = this._children.reduce(
@@ -11910,8 +11936,14 @@
         split.insPrevID = this.id;
         if (this.insNextID) {
           const insNext = tree.findFloorNode(this.insNextID);
-          insNext.insPrevID = split.id;
           split.insNextID = this.insNextID;
+          if (insNext) {
+            insNext.insPrevID = split.id;
+            if (!this.isText && insNext.parent && !insNext.isRemoved && insNext.parent !== split.parent && split.allChildren.length === 0) {
+              split.parent.detachChild(split);
+              insNext.parent.insertBefore(split, insNext);
+            }
+          }
         }
         this.insNextID = split.id;
         tree.registerNode(split);
@@ -12135,7 +12167,7 @@
      * given node, advancing past element-type split siblings that the editing
      * client did not know about (not in versionVector).
      */
-    advancePastUnknownSplitSiblings(node, versionVector) {
+    advancePastUnknownSplitSiblings(node, versionVector, relaxParentCheck = false, skipActorID) {
       if (!versionVector || !node) {
         return node;
       }
@@ -12145,10 +12177,13 @@
         if (!next || next.isText) {
           break;
         }
-        if (next.parent !== current.parent) {
+        if (!relaxParentCheck && next.parent !== current.parent) {
           break;
         }
         const actorID = next.id.getCreatedAt().getActorID();
+        if (skipActorID !== void 0 && actorID === skipActorID) {
+          break;
+        }
         const knownLamport = versionVector.get(actorID);
         if (knownLamport !== void 0 && knownLamport >= next.id.getCreatedAt().getLamport()) {
           break;
@@ -12489,6 +12524,23 @@
       addDataSizes(diff, diffTo, diffFrom);
       const fromLeft = fromLeftRaw !== fromParent ? this.advancePastUnknownSplitSiblings(fromLeftRaw, versionVector) : fromLeftRaw;
       const toLeft = toLeftRaw !== toParent ? this.advancePastUnknownSplitSiblings(toLeftRaw, versionVector) : toLeftRaw;
+      let collectFromParent = fromParent;
+      let collectFromLeft = fromLeft;
+      if (fromLeft !== fromParent && fromParent !== toParent) {
+        let current = fromLeft;
+        while (current.insNextID) {
+          const next = this.findFloorNode(current.insNextID);
+          if (!next || next.isText) {
+            break;
+          }
+          if (next.parent && next.parent === toParent) {
+            collectFromLeft = next;
+            collectFromParent = toParent;
+            break;
+          }
+          current = next;
+        }
+      }
       const fromIdx = this.toIndex(fromParent, fromLeft);
       const fromPath = this.toPath(fromParent, fromLeft);
       const nodesToBeRemoved = [];
@@ -12497,8 +12549,8 @@
       const toBeMergedNodes = [];
       const preTombstoned = /* @__PURE__ */ new Set();
       this.traverseInPosRange(
-        fromParent,
-        fromLeft,
+        collectFromParent,
+        collectFromLeft,
         toParent,
         toLeft,
         ([node, tokenType], ended) => {
@@ -12602,9 +12654,20 @@
         let parent = fromParent;
         let left = fromLeft;
         while (splitCount < splitLevel) {
+          if (left !== parent) {
+            left = this.advancePastUnknownSplitSiblings(
+              left,
+              versionVector,
+              true,
+              editedAt.getActorID()
+            );
+            if (left.parent && left.parent !== parent) {
+              parent = left.parent;
+            }
+          }
           parent.split(
             this,
-            parent.findOffset(left, true) + 1,
+            left !== parent ? parent.findOffset(left, true) + 1 : 0,
             issueTimeTicket,
             versionVector
           );
@@ -13211,10 +13274,10 @@
       );
       this.lastToIdx = preEditFromIdx + removedSize;
       let reverseOp;
-      const isPureL1Split = this.splitLevel === 1 && !this.contents?.length && removedNodes.length === 0;
+      const isPureSplit = this.splitLevel > 0 && !this.contents?.length && removedNodes.length === 0;
       if (this.splitLevel === 0) {
         reverseOp = this.toReverseOperation(tree, removedNodes, preEditFromIdx);
-      } else if (isPureL1Split) {
+      } else if (isPureSplit) {
         reverseOp = this.toSplitReverseOperation(tree, preEditFromIdx);
       }
       root.acc(diff);
@@ -20815,7 +20878,7 @@
     };
   }
   const name = "@yorkie-js/sdk";
-  const version = "0.7.6";
+  const version = "0.7.7";
   const pkg = {
     name,
     version
@@ -22531,8 +22594,11 @@
   function isCounter(value) {
     return typeof value === "object" && value !== null && value.type === "Counter" && typeof value.value === "object";
   }
+  function isDedupCounter(value) {
+    return typeof value === "object" && value !== null && value.type === "DedupCounter" && typeof value.value === "object" && typeof value.registers === "string";
+  }
   function isObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value) && !isText(value) && !isTree(value) && !isInt(value) && !isLong(value) && !isDate(value) && !isBinData(value) && !isCounter(value);
+    return typeof value === "object" && value !== null && !Array.isArray(value) && !isText(value) && !isTree(value) && !isInt(value) && !isLong(value) && !isDate(value) && !isBinData(value) && !isCounter(value) && !isDedupCounter(value);
   }
   function parse(yson) {
     try {
@@ -22548,6 +22614,12 @@
   }
   function preprocessYSON(yson) {
     let result = yson;
+    result = result.replace(
+      /DedupCounter\(Int\((-?\d+)\),"([^"]+)"\)/g,
+      (_, value, registers) => {
+        return `{"__yson_type":"DedupCounter","__yson_data":{"__yson_type":"Int","__yson_data":${value}},"__yson_registers":"${registers}"}`;
+      }
+    );
     result = result.replace(
       /Counter\((Int|Long)\((-?\d+)\)\)/g,
       (_, type, value) => {
@@ -22608,6 +22680,20 @@
         value: value.__yson_data
       };
     }
+    if (value.__yson_type === "DedupCounter" && typeof value.__yson_data === "object" && typeof value.__yson_registers === "string") {
+      const counterValue = postprocessValue(value.__yson_data);
+      if (typeof counterValue === "object" && counterValue !== null && "type" in counterValue && counterValue.type === "Int") {
+        return {
+          type: "DedupCounter",
+          value: counterValue,
+          registers: value.__yson_registers
+        };
+      }
+      throw new YorkieError(
+        Code.ErrInvalidArgument,
+        "DedupCounter must contain Int"
+      );
+    }
     if (value.__yson_type === "Counter" && typeof value.__yson_data === "object") {
       const counterValue = postprocessValue(value.__yson_data);
       if (typeof counterValue === "object" && counterValue !== null && "type" in counterValue && (counterValue.type === "Int" || counterValue.type === "Long")) {
@@ -22696,6 +22782,7 @@
     isBinData,
     isCounter,
     isDate,
+    isDedupCounter,
     isInt,
     isLong,
     isObject,