reptree 1.0.0 → 1.0.2

package/dist/index.d.ts

@@ -322,12 +322,17 @@ declare class RepTree {
     printTree(): string;
     merge(ops: ReadonlyArray<NodeOperation>): void;
     private applyOps;
-    /** Applies operations in an optimized way, sorting move ops by OpId to avoid undo-do-redo cycles */
-    private applyOpsOptimizedForLotsOfMoves;
     compareStructure(other: RepTree): boolean;
     compareMoveOps(other: RepTree): boolean;
-    /** Checks if the given `ancestorId` is an ancestor of `childId` in the tree */
+    /** Checks whether moving `targetId` under `parentId` would create a cycle. */
+    wouldMoveCreateCycle(move: Pick<MoveNode, 'targetId' | 'parentId'>): boolean;
+    /**
+     * Checks if the given `ancestorId` is an ancestor of `childId` in the tree.
+     *
+     * @deprecated Use `wouldMoveCreateCycle` for move validation.
+     */
     isAncestor(childId: string, ancestorId: string | null): boolean;
+    private hasAncestor;
     observeNode(nodeId: string, callback: (updatedNode: Node) => void): () => void;
     observeNodeMove(callback: (movedNode: Node, isNew: boolean) => void): () => void;
     observe(nodeId: string, callback: (events: NodeChangeEvent[]) => void): () => void;
@@ -347,12 +352,14 @@ declare class RepTree {
     private applyLLWProperty;
     private applyOperation;
     private markOpSeen;
+    private reportMoveOpAsApplied;
+    private reportPropertyOpAsApplied;
     private reportOpAsApplied;
     private tryToMove;
     private undoMove;
     /**
      * Returns the current state vectors for move and property streams.
-     * Returns readonly references to the internal state vectors.
+     * Returns copies of the internal state vectors.
      */
     getStateVectors(): {
         move: Readonly<StateVectors["move"]>;
@@ -382,8 +389,9 @@ declare class RepTree {
         parse: (data: unknown) => T;
     }): T;
     private getPropertyOps;
-    private refreshPropStateVector;
+    private recordRetainedPropertyOpInStateVector;
     private getOpKey;
+    private getPropertyKey;
     private filterOpsByRanges;
 }
 
@@ -438,9 +446,25 @@ declare class StateVector {
      * @param op The operation that was just applied
      */
     updateFromOp(op: NodeOperation): void;
+    /**
+     * Removes a single operation ID from the state vector.
+     * Assumes ranges are sorted and non-overlapping.
+     *
+     * @param peerId The peer ID of the operation
+     * @param counter The counter value of the operation
+     * @returns true if a counter was removed, false if it was absent
+     */
+    remove(peerId: string, counter: number): boolean;
+    /**
+     * Removes the operation ID from the state vector.
+     *
+     * @param op The operation to remove
+     * @returns true if the operation ID was removed, false if it was absent
+     */
+    removeFromOp(op: NodeOperation): boolean;
     /**
      * Returns the current state vector.
-     * Returns a readonly reference to the internal state.
+     * Returns a deep copy so callers cannot mutate internal state.
      */
     getState(): Readonly<Record<string, number[][]>>;
     /**

package/dist/index.js

@@ -750,12 +750,63 @@ var StateVector = class _StateVector {
   updateFromOp(op) {
     this.update(op.id.peerId, op.id.counter);
   }
+  /**
+   * Removes a single operation ID from the state vector.
+   * Assumes ranges are sorted and non-overlapping.
+   *
+   * @param peerId The peer ID of the operation
+   * @param counter The counter value of the operation
+   * @returns true if a counter was removed, false if it was absent
+   */
+  remove(peerId, counter) {
+    const ranges = this.ranges[peerId];
+    if (!ranges) {
+      return false;
+    }
+    for (let i = 0; i < ranges.length; i++) {
+      const range = ranges[i];
+      const [start, end] = range;
+      if (counter < start) {
+        return false;
+      }
+      if (counter > end) {
+        continue;
+      }
+      if (start === end) {
+        ranges.splice(i, 1);
+      } else if (counter === start) {
+        range[0] = start + 1;
+      } else if (counter === end) {
+        range[1] = end - 1;
+      } else {
+        ranges.splice(i, 1, [start, counter - 1], [counter + 1, end]);
+      }
+      if (ranges.length === 0) {
+        delete this.ranges[peerId];
+      }
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Removes the operation ID from the state vector.
+   *
+   * @param op The operation to remove
+   * @returns true if the operation ID was removed, false if it was absent
+   */
+  removeFromOp(op) {
+    return this.remove(op.id.peerId, op.id.counter);
+  }
   /**
    * Returns the current state vector.
-   * Returns a readonly reference to the internal state.
+   * Returns a deep copy so callers cannot mutate internal state.
    */
   getState() {
-    return this.ranges;
+    const state = {};
+    for (const [peerId, peerRanges] of Object.entries(this.ranges)) {
+      state[peerId] = peerRanges.map((range) => [...range]);
+    }
+    return state;
   }
   /**
    * Calculates which operation ranges we have that the other state vector is missing
@@ -766,9 +817,8 @@ var StateVector = class _StateVector {
    */
   diff(other) {
     const missingRanges = [];
-    const theirState = other.getState();
     for (const [peerId, ourRanges] of Object.entries(this.ranges)) {
-      const theirRanges = theirState[peerId] || [];
+      const theirRanges = other.ranges[peerId] || [];
       const missing = subtractRanges(ourRanges, theirRanges);
       for (const [start, end] of missing) {
         if (start <= end) {
@@ -1138,23 +1188,6 @@ var _RepTree = class _RepTree {
       this.applyOperation(op);
     }
   }
-  /** Applies operations in an optimized way, sorting move ops by OpId to avoid undo-do-redo cycles */
-  applyOpsOptimizedForLotsOfMoves(ops) {
-    const newMoveOps = ops.filter((op) => isMoveNodeOp(op) && !this.knownOps.has(this.getOpKey(op)));
-    if (newMoveOps.length > 0) {
-      const allMoveOps = [...this.moveOps, ...newMoveOps];
-      allMoveOps.sort((a, b) => compareOpId(a.id, b.id));
-      for (let i = 0, len = allMoveOps.length; i < len; i++) {
-        const op = allMoveOps[i];
-        this.applyMove(op);
-      }
-    }
-    const propertyOps = ops.filter((op) => isAnyPropertyOp(op) && !this.knownOps.has(this.getOpKey(op)));
-    for (let i = 0, len = propertyOps.length; i < len; i++) {
-      const op = propertyOps[i];
-      this.applyProperty(op);
-    }
-  }
   compareStructure(other) {
     if (this.root?.id !== other.root?.id) {
       return false;
@@ -1177,16 +1210,29 @@ var _RepTree = class _RepTree {
     }
     return true;
   }
-  /** Checks if the given `ancestorId` is an ancestor of `childId` in the tree */
+  /** Checks whether moving `targetId` under `parentId` would create a cycle. */
+  wouldMoveCreateCycle(move) {
+    if (move.targetId === move.parentId) return true;
+    if (move.parentId === null) return false;
+    return this.hasAncestor(move.parentId, move.targetId);
+  }
+  /**
+   * Checks if the given `ancestorId` is an ancestor of `childId` in the tree.
+   *
+   * @deprecated Use `wouldMoveCreateCycle` for move validation.
+   */
   isAncestor(childId, ancestorId) {
-    let targetId = childId;
+    return this.hasAncestor(childId, ancestorId);
+  }
+  hasAncestor(nodeId, ancestorId) {
+    let targetId = nodeId;
     let node;
     const visitedNodes = /* @__PURE__ */ new Set();
     while (node = this.state.getNode(targetId)) {
       if (node.parentId === ancestorId) return true;
       if (!node.parentId) return false;
       if (visitedNodes.has(targetId)) {
-        console.error(`isAncestor: cycle detected in the tree structure.`);
+        console.error(`hasAncestor: cycle detected in the tree structure.`);
         return false;
       }
       visitedNodes.add(targetId);
@@ -1307,14 +1353,14 @@ var _RepTree = class _RepTree {
         this.pendingMovesWithMissingParent.set(op.parentId, []);
       }
       this.pendingMovesWithMissingParent.get(op.parentId).push(op);
-      this.markOpSeen(op, true);
+      this.markOpSeen(op);
       return;
     }
     this.updateMoveClock(op);
     const lastOp = this.moveOps.length > 0 ? this.moveOps[this.moveOps.length - 1] : null;
     if (lastOp === null || isOpIdGreaterThan(op.id, lastOp.id)) {
       this.moveOps.push(op);
-      this.reportOpAsApplied(op);
+      this.reportMoveOpAsApplied(op);
       this.tryToMove(op);
     } else {
       let targetIndex = this.moveOps.length;
@@ -1328,7 +1374,7 @@ var _RepTree = class _RepTree {
         }
       }
       this.moveOps.splice(targetIndex + 1, 0, op);
-      this.reportOpAsApplied(op);
+      this.reportMoveOpAsApplied(op);
       this.tryToMove(op);
       for (let i = targetIndex + 2; i < this.moveOps.length; i++) {
         this.tryToMove(this.moveOps[i]);
@@ -1336,16 +1382,16 @@ var _RepTree = class _RepTree {
     }
     this.applyPendingMovesForParent(op.targetId);
   }
-  setLLWPropertyAndItsOpId(op) {
-    this.propertyOpsByKey.set(`${op.key}@${op.targetId}`, op);
+  setLLWPropertyAndItsOpId(op, previousOp) {
+    this.propertyOpsByKey.set(this.getPropertyKey(op), op);
     this.state.setProperty(op.targetId, op.key, op.value);
-    this.reportOpAsApplied(op, false);
-    this.refreshPropStateVector();
+    this.recordRetainedPropertyOpInStateVector(op, previousOp);
+    this.reportPropertyOpAsApplied(op);
   }
   setTransientPropertyAndItsOpId(op) {
-    this.transientPropertiesAndTheirOpIds.set(`${op.key}@${op.targetId}`, op.id);
+    this.transientPropertiesAndTheirOpIds.set(this.getPropertyKey(op), op.id);
     this.state.setTransientProperty(op.targetId, op.key, op.value);
-    this.reportOpAsApplied(op, false);
+    this.reportPropertyOpAsApplied(op);
   }
   applyProperty(op) {
     const targetNode = this.state.getNode(op.targetId);
@@ -1357,30 +1403,31 @@ var _RepTree = class _RepTree {
         this.pendingPropertiesWithMissingNode.set(op.targetId, []);
       }
       this.pendingPropertiesWithMissingNode.get(op.targetId).push(op);
-      this.markOpSeen(op, false);
+      this.markOpSeen(op);
       return;
     }
     this.updatePropClock(op);
     this.applyLLWProperty(op, targetNode);
   }
   applyLLWProperty(op, targetNode) {
-    const prevTransientOpId = this.transientPropertiesAndTheirOpIds.get(`${op.key}@${op.targetId}`);
-    const prevOpId = this.propertyOpsByKey.get(`${op.key}@${op.targetId}`)?.id;
+    const propertyKey = this.getPropertyKey(op);
+    const prevTransientOpId = this.transientPropertiesAndTheirOpIds.get(propertyKey);
+    const previousOp = this.propertyOpsByKey.get(propertyKey);
     if (!op.transient) {
-      if (!prevOpId || isOpIdGreaterThan(op.id, prevOpId)) {
-        this.setLLWPropertyAndItsOpId(op);
+      if (!previousOp || isOpIdGreaterThan(op.id, previousOp.id)) {
+        this.setLLWPropertyAndItsOpId(op, previousOp);
       } else {
-        this.markOpSeen(op, false);
+        this.markOpSeen(op);
       }
       if (prevTransientOpId && isOpIdGreaterThan(op.id, prevTransientOpId)) {
-        this.transientPropertiesAndTheirOpIds.delete(`${op.key}@${op.targetId}`);
+        this.transientPropertiesAndTheirOpIds.delete(propertyKey);
         targetNode.removeTransientProperty(op.key);
       }
     } else {
       if (!prevTransientOpId || isOpIdGreaterThan(op.id, prevTransientOpId)) {
         this.setTransientPropertyAndItsOpId(op);
       } else {
-        this.markOpSeen(op, false);
+        this.markOpSeen(op);
       }
     }
   }
@@ -1391,18 +1438,21 @@ var _RepTree = class _RepTree {
       this.applyProperty(op);
     }
   }
-  markOpSeen(op, includeInStateVector) {
+  markOpSeen(op) {
     this.knownOps.add(this.getOpKey(op));
-    if (includeInStateVector && this._stateVectorEnabled) {
-      if (isMoveNodeOp(op)) {
-        this.moveStateVector.updateFromOp(op);
-      } else if (isAnyPropertyOp(op)) {
-        this.propStateVector.updateFromOp(op);
-      }
+  }
+  reportMoveOpAsApplied(op) {
+    this.markOpSeen(op);
+    if (this._stateVectorEnabled) {
+      this.moveStateVector.updateFromOp(op);
     }
+    this.reportOpAsApplied(op);
+  }
+  reportPropertyOpAsApplied(op) {
+    this.markOpSeen(op);
+    this.reportOpAsApplied(op);
   }
-  reportOpAsApplied(op, includeInStateVector = true) {
-    this.markOpSeen(op, includeInStateVector);
+  reportOpAsApplied(op) {
     for (const callback of this.opAppliedCallbacks) {
       callback(op);
     }
@@ -1412,8 +1462,7 @@ var _RepTree = class _RepTree {
     if (targetNode) {
       this.parentIdBeforeMove.set(op.id, targetNode.parentId);
     }
-    if (op.targetId === op.parentId) return;
-    if (op.parentId && this.isAncestor(op.parentId, op.targetId)) return;
+    if (this.wouldMoveCreateCycle(op)) return;
     this.state.moveNode(op.targetId, op.parentId);
     if (!targetNode) {
       const pendingProperties = this.pendingPropertiesWithMissingNode.get(op.targetId) || [];
@@ -1438,7 +1487,7 @@ var _RepTree = class _RepTree {
   // --- Range-Based State Vector Methods ---
   /**
    * Returns the current state vectors for move and property streams.
-   * Returns readonly references to the internal state vectors.
+   * Returns copies of the internal state vectors.
    */
   getStateVectors() {
     if (!this._stateVectorEnabled) {
@@ -1506,16 +1555,22 @@ var _RepTree = class _RepTree {
   getPropertyOps() {
     return Array.from(this.propertyOpsByKey.values());
   }
-  refreshPropStateVector() {
+  recordRetainedPropertyOpInStateVector(op, previousOp) {
     if (!this._stateVectorEnabled) {
       return;
     }
-    this.propStateVector = StateVector.fromOperations(this.getPropertyOps());
+    if (previousOp) {
+      this.propStateVector.removeFromOp(previousOp);
+    }
+    this.propStateVector.updateFromOp(op);
   }
   getOpKey(op) {
     const stream = isMoveNodeOp(op) ? "move" : "prop";
     return `${stream}:${opIdToString(op.id)}`;
   }
+  getPropertyKey(op) {
+    return `${op.key}@${op.targetId}`;
+  }
   filterOpsByRanges(ops, ranges) {
     const missingOps = [];
     for (const op of ops) {