@yorkie-js/react 0.6.49 → 0.7.0

package/dist/yorkie-js-react.js

@@ -12499,7 +12499,7 @@
           }
         }
       }
-      return [changes, pairs, diff];
+      return [changes, pairs, diff, nodesToBeRemoved, fromIdx];
     }
     /**
      * `editT` edits the given range with the given value.
@@ -12937,29 +12937,46 @@
       return [prev, prev.isText ? TokenType.Text : TokenType.End];
     }
   }
+  function clearRemovedAt(node) {
+    traverseAll(node, (n) => {
+      n.removedAt = void 0;
+      n.visibleSize = n.totalSize;
+    });
+  }
   class TreeEditOperation extends Operation {
     fromPos;
     toPos;
     contents;
     splitLevel;
-    constructor(parentCreatedAt, fromPos, toPos, contents, splitLevel, executedAt) {
+    isUndoOp;
+    fromIdx;
+    toIdx;
+    lastFromIdx;
+    lastToIdx;
+    constructor(parentCreatedAt, fromPos, toPos, contents, splitLevel, executedAt, isUndoOp, fromIdx, toIdx) {
       super(parentCreatedAt, executedAt);
       this.fromPos = fromPos;
       this.toPos = toPos;
       this.contents = contents;
       this.splitLevel = splitLevel;
+      this.isUndoOp = isUndoOp;
+      this.fromIdx = fromIdx;
+      this.toIdx = toIdx;
     }
     /**
      * `create` creates a new instance of EditOperation.
      */
-    static create(parentCreatedAt, fromPos, toPos, contents, splitLevel, executedAt) {
+    static create(parentCreatedAt, fromPos, toPos, contents, splitLevel, executedAt, isUndoOp, fromIdx, toIdx) {
       return new TreeEditOperation(
         parentCreatedAt,
         fromPos,
         toPos,
         contents,
         splitLevel,
-        executedAt
+        executedAt,
+        isUndoOp,
+        fromIdx,
+        toIdx
       );
     }
     /**
@@ -12981,7 +12998,15 @@
       }
       const editedAt = this.getExecutedAt();
       const tree = parentObject;
-      const [changes, pairs, diff] = tree.edit(
+      if (this.isUndoOp && this.fromIdx !== void 0 && this.toIdx !== void 0) {
+        this.fromPos = tree.findPos(this.fromIdx);
+        if (this.fromIdx === this.toIdx) {
+          this.toPos = this.fromPos;
+        } else {
+          this.toPos = tree.findPos(this.toIdx);
+        }
+      }
+      const [changes, pairs, diff, removedNodes, preEditFromIdx] = tree.edit(
         [this.fromPos, this.toPos],
         this.contents?.map((content) => content.deepcopy()),
         this.splitLevel,
@@ -13007,6 +13032,13 @@
         })(),
         versionVector
       );
+      this.lastFromIdx = preEditFromIdx;
+      const removedSize = removedNodes.reduce(
+        (sum, node) => sum + node.paddedSize(),
+        0
+      );
+      this.lastToIdx = preEditFromIdx + removedSize;
+      const reverseOp = this.splitLevel === 0 ? this.toReverseOperation(tree, removedNodes, preEditFromIdx) : void 0;
       root.acc(diff);
       for (const pair of pairs) {
         root.registerGCPair(pair);
@@ -13025,9 +13057,131 @@
               toPath
             };
           }
-        )
+        ),
+        reverseOp
       };
     }
+    /**
+     * `toReverseOperation` creates the reverse operation for undo.
+     *
+     * The reverse op stores both CRDTTreePos (for initial use) and integer
+     * indices (for reconciliation adjustment when remote edits arrive).
+     * At undo execution time, the integer indices take precedence and are
+     * converted to CRDTTreePos via tree.findPos().
+     *
+     * @param tree - The CRDTTree after the edit has been applied
+     * @param removedNodes - Nodes that were removed by this edit
+     * @param preEditFromIdx - The from index captured BEFORE the edit
+     */
+    toReverseOperation(tree, removedNodes, preEditFromIdx) {
+      const insertedContentSize = this.contents ? this.contents.reduce((sum, node) => sum + node.paddedSize(), 0) : 0;
+      const maxNeededIdx = preEditFromIdx + insertedContentSize;
+      if (maxNeededIdx > tree.getSize()) {
+        return void 0;
+      }
+      const topLevelRemoved = removedNodes.filter(
+        (node) => !node.parent || !removedNodes.includes(node.parent)
+      );
+      const reverseContents = topLevelRemoved.length > 0 ? topLevelRemoved.map((n) => {
+        const clone = n.deepcopy();
+        clearRemovedAt(clone);
+        return clone;
+      }) : void 0;
+      const reverseFromPos = tree.findPos(preEditFromIdx);
+      let reverseToPos;
+      if (insertedContentSize > 0) {
+        reverseToPos = tree.findPos(preEditFromIdx + insertedContentSize);
+      } else {
+        reverseToPos = reverseFromPos;
+      }
+      const reverseFromIdx = preEditFromIdx;
+      const reverseToIdx = preEditFromIdx + insertedContentSize;
+      return TreeEditOperation.create(
+        this.getParentCreatedAt(),
+        reverseFromPos,
+        reverseToPos,
+        reverseContents,
+        0,
+        // splitLevel always 0
+        void 0,
+        // executedAt set during undo
+        true,
+        // isUndoOp
+        reverseFromIdx,
+        reverseToIdx
+      );
+    }
+    /**
+     * `normalizePos` returns the visible-index range of this operation.
+     * For undo ops, returns the stored (possibly reconciled) indices.
+     * For forward ops, returns the pre-edit indices captured during execute().
+     */
+    normalizePos() {
+      if (this.isUndoOp && this.fromIdx !== void 0 && this.toIdx !== void 0) {
+        return [this.fromIdx, this.toIdx];
+      }
+      if (this.lastFromIdx !== void 0 && this.lastToIdx !== void 0) {
+        return [this.lastFromIdx, this.lastToIdx];
+      }
+      return [0, 0];
+    }
+    /**
+     * `reconcileOperation` adjusts this undo operation's integer indices
+     * when a remote edit modifies the same tree. Uses the same 6-case
+     * overlap logic as EditOperation.reconcileOperation for Text.
+     */
+    reconcileOperation(remoteFrom, remoteTo, contentLen) {
+      if (!this.isUndoOp) {
+        return;
+      }
+      if (this.fromIdx === void 0 || this.toIdx === void 0) {
+        return;
+      }
+      if (remoteFrom > remoteTo) {
+        return;
+      }
+      const remoteRangeLen = remoteTo - remoteFrom;
+      const localFrom = this.fromIdx;
+      const localTo = this.toIdx;
+      const apply = (na, nb) => {
+        this.fromIdx = Math.max(0, na);
+        this.toIdx = Math.max(0, nb);
+      };
+      if (remoteTo <= localFrom) {
+        apply(
+          localFrom - remoteRangeLen + contentLen,
+          localTo - remoteRangeLen + contentLen
+        );
+        return;
+      }
+      if (localTo <= remoteFrom) {
+        return;
+      }
+      if (remoteFrom <= localFrom && localTo <= remoteTo && remoteFrom !== remoteTo) {
+        apply(remoteFrom, remoteFrom);
+        return;
+      }
+      if (localFrom <= remoteFrom && remoteTo <= localTo && localFrom !== localTo) {
+        apply(localFrom, localTo - remoteRangeLen + contentLen);
+        return;
+      }
+      if (remoteFrom < localFrom && localFrom < remoteTo && remoteTo < localTo) {
+        apply(remoteFrom, remoteFrom + (localTo - remoteTo));
+        return;
+      }
+      if (localFrom < remoteFrom && remoteFrom < localTo && localTo < remoteTo) {
+        apply(localFrom, remoteFrom);
+        return;
+      }
+    }
+    /**
+     * `getContentSize` returns the total visible size of this operation's
+     * content (for reconciliation).
+     */
+    getContentSize() {
+      if (!this.contents) return 0;
+      return this.contents.reduce((sum, node) => sum + node.paddedSize(), 0);
+    }
     /**
      * `getEffectedCreatedAt` returns the creation time of the effected element.
      */
@@ -17955,6 +18109,24 @@
       replace(this.undoStack);
       replace(this.redoStack);
     }
+    /**
+     * `reconcileTreeEdit` reconciles the tree edit operation.
+     * Scan both undo/redo stacks and adjust tree edit operations
+     * when a remote edit modifies the same tree.
+     */
+    reconcileTreeEdit(parentCreatedAt, rangeFrom, rangeTo, contentSize) {
+      const replace = (stack) => {
+        for (const ops of stack) {
+          for (const op of ops) {
+            if (op instanceof TreeEditOperation && op.getParentCreatedAt().compare(parentCreatedAt) === 0) {
+              op.reconcileOperation(rangeFrom, rangeTo, contentSize);
+            }
+          }
+        }
+      };
+      replace(this.undoStack);
+      replace(this.redoStack);
+    }
   }
   function validateYorkieRuleset(data, ruleset) {
     const errors = [];
@@ -18908,6 +19080,15 @@
             op.getContent()?.length ?? 0
           );
         }
+        if (op instanceof TreeEditOperation) {
+          const [from, to] = op.normalizePos();
+          this.internalHistory.reconcileTreeEdit(
+            op.getParentCreatedAt(),
+            from,
+            to,
+            op.getContentSize()
+          );
+        }
       }
       this.changeID = this.changeID.syncClocks(change.getID());
       if (opInfos.length) {
@@ -19453,7 +19634,7 @@
     };
   }
   const name$1 = "@yorkie-js/sdk";
-  const version$1 = "0.6.49";
+  const version$1 = "0.7.0";
   const pkg$1 = {
     name: name$1,
     version: version$1
@@ -21308,7 +21489,7 @@
     };
   }
   const name = "@yorkie-js/react";
-  const version = "0.6.49";
+  const version = "0.7.0";
   const pkg = {
     name,
     version