@yorkie-js/sdk 0.6.49 → 0.7.0

package/dist/yorkie-js-sdk.d.ts

@@ -1920,12 +1920,12 @@ declare class CRDTTree extends CRDTElement implements GCParent {
      * `edit` edits the tree with the given range and content.
      * If the content is undefined, the range will be removed.
      */
-    edit(range: [CRDTTreePos, CRDTTreePos], contents: Array<CRDTTreeNode> | undefined, splitLevel: number, editedAt: TimeTicket, issueTimeTicket: (() => TimeTicket) | undefined, versionVector?: VersionVector): [Array<TreeChange>, Array<GCPair>, DataSize];
+    edit(range: [CRDTTreePos, CRDTTreePos], contents: Array<CRDTTreeNode> | undefined, splitLevel: number, editedAt: TimeTicket, issueTimeTicket: (() => TimeTicket) | undefined, versionVector?: VersionVector): [Array<TreeChange>, Array<GCPair>, DataSize, Array<CRDTTreeNode>, number];
     /**
      * `editT` edits the given range with the given value.
      * This method uses indexes instead of a pair of TreePos for testing.
      */
-    editT(range: [number, number], contents: Array<CRDTTreeNode> | undefined, splitLevel: number, editedAt: TimeTicket, issueTimeTicket: () => TimeTicket): [Array<TreeChange>, Array<GCPair>, DataSize];
+    editT(range: [number, number], contents: Array<CRDTTreeNode> | undefined, splitLevel: number, editedAt: TimeTicket, issueTimeTicket: () => TimeTicket): [Array<TreeChange>, Array<GCPair>, DataSize, Array<CRDTTreeNode>, number];
     /**
      * `move` move the given source range to the given target range.
      */

package/dist/yorkie-js-sdk.es.js

@@ -12495,7 +12495,7 @@ class CRDTTree extends CRDTElement {
         }
       }
     }
-    return [changes, pairs, diff];
+    return [changes, pairs, diff, nodesToBeRemoved, fromIdx];
   }
   /**
    * `editT` edits the given range with the given value.
@@ -12933,29 +12933,46 @@ class CRDTTree extends CRDTElement {
     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
     );
   }
   /**
@@ -12977,7 +12994,15 @@ class TreeEditOperation extends Operation {
     }
     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,
@@ -13003,6 +13028,13 @@ class TreeEditOperation extends Operation {
       })(),
       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);
@@ -13021,9 +13053,131 @@ class TreeEditOperation extends Operation {
             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.
    */
@@ -17951,6 +18105,24 @@ class History {
     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 = [];
@@ -18909,6 +19081,15 @@ class Document {
           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) {
@@ -19454,7 +19635,7 @@ function createAuthInterceptor(apiKey, token) {
   };
 }
 const name = "@yorkie-js/sdk";
-const version = "0.6.49";
+const version = "0.7.0";
 const pkg = {
   name,
   version