@fluidframework/merge-tree 2.3.1 → 2.4.0-297027

package/dist/mergeTree.js

@@ -765,13 +765,15 @@ class MergeTree {
                     segment: pendingSegment,
                 });
             });
-            if (opArgs.op.type === ops_js_1.MergeTreeDeltaType.OBLITERATE) {
+            if (opArgs.op.type === ops_js_1.MergeTreeDeltaType.OBLITERATE ||
+                opArgs.op.type === ops_js_1.MergeTreeDeltaType.OBLITERATE_SIDED) {
                 this.obliterates.addOrUpdate(pendingSegmentGroup.obliterateInfo);
             }
             // Perform slides after all segments have been acked, so that
             // positions after slide are final
             if (opArgs.op.type === ops_js_1.MergeTreeDeltaType.REMOVE ||
-                opArgs.op.type === ops_js_1.MergeTreeDeltaType.OBLITERATE) {
+                opArgs.op.type === ops_js_1.MergeTreeDeltaType.OBLITERATE ||
+                opArgs.op.type === ops_js_1.MergeTreeDeltaType.OBLITERATE_SIDED) {
                 this.slideAckedRemovedSegmentReferences(pendingSegmentGroup.segments);
             }
             this.mergeTreeMaintenanceCallback?.({
@@ -971,9 +973,9 @@ class MergeTree {
                     });
                 }
                 this.updateRoot(splitNode);
-                saveIfLocal(newSegment);
                 insertPos += newSegment.cachedLength;
                 if (!this.options?.mergeTreeEnableObliterate || this.obliterates.empty()) {
+                    saveIfLocal(newSegment);
                     continue;
                 }
                 // eslint-disable-next-line import/no-deprecated
@@ -1000,13 +1002,13 @@ class MergeTree {
                             movedSeqs.unshift(ob.seq);
                         }
                         else {
-                            if (newest === undefined || normalizedNewestSeq < normalizedObSeq) {
-                                normalizedNewestSeq = normalizedObSeq;
-                                newest = ob;
-                            }
                             movedClientIds.push(ob.clientId);
                             movedSeqs.push(ob.seq);
                         }
+                        if (newest === undefined || normalizedNewestSeq < normalizedObSeq) {
+                            normalizedNewestSeq = normalizedObSeq;
+                            newest = ob;
+                        }
                     }
                 }
                 if (oldest && newest?.clientId !== clientId) {
@@ -1026,6 +1028,10 @@ class MergeTree {
                         this.blockUpdatePathLengths(newSegment.parent, seq, clientId);
                     }
                 }
+                else if (oldest && newest?.clientId === clientId) {
+                    newSegment.prevObliterateByInserter = newest;
+                }
+                saveIfLocal(newSegment);
             }
         }
     }
@@ -1059,16 +1065,7 @@ class MergeTree {
         }
     }
     insertingWalk(block, pos, refSeq, clientId, seq, context, isLastChildBlock = true) {
-        let _pos;
-        if (pos === "start") {
-            _pos = 0;
-        }
-        else if (pos === "end") {
-            _pos = this.root.mergeTree?.getLength(refSeq, clientId) ?? 0;
-        }
-        else {
-            _pos = pos;
-        }
+        let _pos = pos;
         const children = block.children;
         let childIndex;
         let child;
@@ -1241,15 +1238,9 @@ class MergeTree {
             (0, zamboni_js_1.zamboniSegments)(this);
         }
     }
-    obliterateRange(start, end, refSeq, clientId, seq, overwrite = false, opArgs) {
-        errorIfOptionNotTrue(this.options, "mergeTreeEnableObliterate");
-        const { startPos, startSide, endPos, endSide } = (0, sequencePlace_js_1.endpointPosAndSide)(start, end);
-        (0, internal_1.assert)(startPos !== undefined &&
-            endPos !== undefined &&
-            startSide !== undefined &&
-            endSide !== undefined &&
-            startPos !== "end" &&
-            endPos !== "start", 0x9e2 /* start and end cannot be undefined because they were not passed in as undefined */);
+    obliterateRangeSided(start, end, refSeq, clientId, seq, overwrite = false, opArgs) {
+        const startPos = start.side === sequencePlace_js_1.Side.Before ? start.pos : start.pos + 1;
+        const endPos = end.side === sequencePlace_js_1.Side.Before ? end.pos : end.pos + 1;
         this.ensureIntervalBoundary(startPos, refSeq, clientId);
         this.ensureIntervalBoundary(endPos, refSeq, clientId);
         let _overwrite = overwrite;
@@ -1266,20 +1257,46 @@ class MergeTree {
             localSeq,
             segmentGroup: undefined,
         };
-        const normalizedStartPos = startPos === "start" || startPos === undefined ? 0 : startPos;
-        const normalizedEndPos = endPos === "end" || endPos === undefined ? this.getLength(refSeq, clientId) : endPos;
-        const { segment: startSeg } = this.getContainingSegment(normalizedStartPos, refSeq, clientId);
-        const { segment: endSeg } = this.getContainingSegment(normalizedEndPos - 1, refSeq, clientId);
+        const { segment: startSeg } = this.getContainingSegment(start.pos, refSeq, clientId);
+        const { segment: endSeg } = this.getContainingSegment(end.pos, refSeq, clientId);
         (0, internal_1.assert)(startSeg !== undefined && endSeg !== undefined, 0xa3f /* segments cannot be undefined */);
-        obliterate.start = this.createLocalReferencePosition(startSeg, 0, ops_js_1.ReferenceType.StayOnRemove, {
+        obliterate.start = this.createLocalReferencePosition(startSeg, start.side === sequencePlace_js_1.Side.Before ? 0 : Math.max(startSeg.cachedLength - 1, 0), ops_js_1.ReferenceType.StayOnRemove, {
             obliterate,
         });
-        obliterate.end = this.createLocalReferencePosition(endSeg, endSeg.cachedLength - 1, ops_js_1.ReferenceType.StayOnRemove, {
+        obliterate.end = this.createLocalReferencePosition(endSeg, end.side === sequencePlace_js_1.Side.Before ? 0 : Math.max(endSeg.cachedLength - 1, 0), ops_js_1.ReferenceType.StayOnRemove, {
             obliterate,
         });
+        // Always create a segment group for obliterate,
+        // even if there are no segments currently in the obliteration range.
+        // Segments may be concurrently inserted into the obliteration range,
+        // at which point they are added to the segment group.
+        obliterate.segmentGroup = {
+            segments: [],
+            localSeq,
+            refSeq: this.collabWindow.currentSeq,
+            obliterateInfo: obliterate,
+        };
+        if (this.collabWindow.collaborating && clientId === this.collabWindow.clientId) {
+            this.pendingSegments.push(obliterate.segmentGroup);
+        }
+        this.obliterates.addOrUpdate(obliterate);
         const markMoved = (segment, pos, _start, _end) => {
-            var _a;
+            if ((start.side === sequencePlace_js_1.Side.After && startPos === pos + segment.cachedLength) || // exclusive start segment
+                (end.side === sequencePlace_js_1.Side.Before &&
+                    endPos === pos &&
+                    (0, perspective_js_1.isSegmentPresent)(segment, { refSeq, localSeq })) // exclusive end segment
+            ) {
+                // We walk these segments because we want to also walk any concurrently inserted segments between here and the obliterated segments.
+                // These segments are outside of the obliteration range though, so return true to keep walking.
+                return true;
+            }
             const existingMoveInfo = (0, mergeTreeNodes_js_1.toMoveInfo)(segment);
+            if (segment.prevObliterateByInserter?.seq === constants_js_1.UnassignedSequenceNumber) {
+                // We chose to not obliterate this segment because we are aware of an unacked local obliteration.
+                // The local obliterate has not been sequenced yet, so it is still the newest obliterate we are aware of.
+                // Other clients will also choose not to obliterate this segment because the most recent obliteration has the same clientId
+                return true;
+            }
             if (clientId !== segment.clientId &&
                 segment.seq !== undefined &&
                 seq !== constants_js_1.UnassignedSequenceNumber &&
@@ -1320,7 +1337,6 @@ class MergeTree {
                 if (segment.movedSeq === constants_js_1.UnassignedSequenceNumber &&
                     clientId === this.collabWindow.clientId) {
                     obliterate.segmentGroup = this.addToPendingList(segment, obliterate.segmentGroup, localSeq);
-                    (_a = obliterate.segmentGroup).obliterateInfo ?? (_a.obliterateInfo = obliterate);
                 }
                 else {
                     if (MergeTree.options.zamboniSegments) {
@@ -1339,8 +1355,8 @@ class MergeTree {
             }
             return true;
         };
-        this.nodeMap(refSeq, clientId, markMoved, undefined, afterMarkMoved, start, end, undefined, seq === constants_js_1.UnassignedSequenceNumber ? undefined : seq);
-        this.obliterates.addOrUpdate(obliterate);
+        this.nodeMap(refSeq, clientId, markMoved, undefined, afterMarkMoved, start.pos, end.pos + 1, // include the segment containing the end reference
+        undefined, seq === constants_js_1.UnassignedSequenceNumber ? undefined : seq);
         this.slideAckedRemovedSegmentReferences(localOverlapWithRefs);
         // opArgs == undefined => test code
         if (movedSegments.length > 0) {
@@ -1361,6 +1377,17 @@ class MergeTree {
             (0, zamboni_js_1.zamboniSegments)(this);
         }
     }
+    obliterateRange(start, end, refSeq, clientId, seq, overwrite = false, opArgs) {
+        errorIfOptionNotTrue(this.options, "mergeTreeEnableObliterate");
+        if (this.options?.mergeTreeEnableSidedObliterate) {
+            (0, internal_1.assert)(typeof start === "object" && typeof end === "object", "Start and end must be of type InteriorSequencePlace if mergeTreeEnableSidedObliterate is enabled.");
+            this.obliterateRangeSided(start, end, refSeq, clientId, seq, overwrite, opArgs);
+        }
+        else {
+            (0, internal_1.assert)(typeof start === "number" && typeof end === "number", "Start and end must be numbers if mergeTreeEnableSidedObliterate is not enabled.");
+            this.obliterateRangeSided({ pos: start, side: sequencePlace_js_1.Side.Before }, { pos: end - 1, side: sequencePlace_js_1.Side.After }, refSeq, clientId, seq, overwrite, opArgs);
+        }
+    }
     markRangeRemoved(start, end, refSeq, clientId, seq, overwrite = false, opArgs) {
         let _overwrite = overwrite;
         this.ensureIntervalBoundary(start, refSeq, clientId);
@@ -1809,18 +1836,11 @@ class MergeTree {
      * ignored for the purposes of tracking when traversal should end.
      */
     nodeMap(refSeq, clientId, leaf, accum, post, start = 0, end, localSeq, visibilitySeq = refSeq) {
-        const maybeEndPos = end ?? this.nodeLength(this.root, refSeq, clientId, localSeq) ?? 0;
-        if (maybeEndPos === start) {
+        const endPos = end ?? this.nodeLength(this.root, refSeq, clientId, localSeq) ?? 0;
+        if (endPos === start) {
             return;
         }
         let pos = 0;
-        let { startPos, endPos } = (0, sequencePlace_js_1.endpointPosAndSide)(start, end);
-        startPos = startPos === "start" || startPos === undefined ? 0 : startPos;
-        endPos =
-            endPos === "end" || endPos === undefined
-                ? this.root.mergeTree?.getLength(refSeq, clientId) ?? 0
-                : endPos;
-        (0, internal_1.assert)(startPos !== "end" && endPos !== "start", 0x9e3 /* start cannot be 'end' and end cannot be 'start' */);
         (0, mergeTreeNodeWalk_js_1.depthFirstNodeWalk)(this.root, this.root.children[0], (node) => {
             if (endPos <= pos) {
                 return mergeTreeNodeWalk_js_1.NodeAction.Exit;
@@ -1837,19 +1857,19 @@ class MergeTree {
             }
             const nextPos = pos + lenAtRefSeq;
             // start is beyond the current node, so we can skip it
-            if (typeof startPos === "number" && startPos >= nextPos) {
+            if (start >= nextPos) {
                 pos = nextPos;
                 return mergeTreeNodeWalk_js_1.NodeAction.Skip;
             }
             if (node.isLeaf()) {
-                if (leaf(node, pos, refSeq, clientId, startPos - pos, endPos - pos, accum) === false) {
+                if (leaf(node, pos, refSeq, clientId, start - pos, endPos - pos, accum) === false) {
                     return mergeTreeNodeWalk_js_1.NodeAction.Exit;
                 }
                 pos = nextPos;
             }
         }, undefined, post === undefined
             ? undefined
-            : (block) => post(block, pos, refSeq, clientId, startPos - pos, endPos - pos, accum));
+            : (block) => post(block, pos, refSeq, clientId, start - pos, endPos - pos, accum));
     }
 }
 exports.MergeTree = MergeTree;