@fluidframework/merge-tree 2.41.0 → 2.43.0-343119

package/lib/client.js

@@ -10,14 +10,14 @@ import { toDeltaManagerInternal } from "@fluidframework/runtime-utils/internal";
 import { LoggingError, UsageError, } from "@fluidframework/telemetry-utils/internal";
 import { MergeTreeTextHelper } from "./MergeTreeTextHelper.js";
 import { RedBlackTree } from "./collections/index.js";
-import { NonCollabClient, UniversalSequenceNumber } from "./constants.js";
+import { NonCollabClient, SquashClient, UniversalSequenceNumber } from "./constants.js";
 import { SlidingPreference } from "./localReference.js";
 import { MergeTree, errorIfOptionNotTrue, getSlideToSegoff, isRemovedAndAcked, } from "./mergeTree.js";
 import { walkAllChildSegments } from "./mergeTreeNodeWalk.js";
 import { compareStrings, isSegmentLeaf, } from "./mergeTreeNodes.js";
 import { createAdjustRangeOp, createAnnotateMarkerOp, createAnnotateRangeOp, createGroupOp, createInsertSegmentOp, createObliterateRangeOp, createObliterateRangeOpSided, createRemoveRangeOp, } from "./opBuilder.js";
 import { MergeTreeDeltaType, ReferenceType, } from "./ops.js";
-import { LocalReconnectingPerspective, PriorPerspective, } from "./perspective.js";
+import { LocalReconnectingPerspective, LocalSquashPerspective, PriorPerspective, } from "./perspective.js";
 import { DetachedReferencePosition } from "./referencePositions.js";
 import { isInserted, isRemoved, overwriteInfo, toRemovalInfo, } from "./segmentInfos.js";
 import { Side } from "./sequencePlace.js";
@@ -186,8 +186,10 @@ export class Client extends TypedEventEmitter {
         }
         return this.insertSegmentLocal(pos, segment);
     }
-    walkSegments(handler, start, end, accum, splitRange = false) {
-        this._mergeTree.mapRange(handler, this._mergeTree.localPerspective, accum, start, end, splitRange);
+    walkSegments(handler, start, end, accum, splitRange = false, perspective) {
+        this._mergeTree.mapRange(handler, perspective === undefined
+            ? this.getCollabWindow().localPerspective
+            : this.getOperationPerspective(perspective), accum, start, end, splitRange);
     }
     walkAllSegments(action, accum) {
         return walkAllChildSegments(this._mergeTree.root, accum === undefined ? action : (seg) => action(seg, accum));
@@ -551,11 +553,13 @@ export class Client extends TypedEventEmitter {
         const useNewSlidingBehavior = true;
         // Destructuring segment + offset is convenient and segment is reassigned
         // eslint-disable-next-line prefer-const
-        let { segment: newSegment, offset: newOffset } = getSlideToSegoff({ segment: oldSegment, offset: oldOffset }, slidePreference, reconnectingPerspective, useNewSlidingBehavior);
-        newSegment ??=
-            slidePreference === SlidingPreference.FORWARD
+        const segOff = getSlideToSegoff({ segment: oldSegment, offset: oldOffset }, slidePreference, reconnectingPerspective, useNewSlidingBehavior);
+        const { segment: newSegment, offset: newOffset } = segOff ?? {
+            segment: slidePreference === SlidingPreference.FORWARD
                 ? this._mergeTree.endOfTree
-                : this._mergeTree.startOfTree;
+                : this._mergeTree.startOfTree,
+            offset: 0,
+        };
         assert(isSegmentLeaf(newSegment) && newOffset !== undefined, 0xb62 /* Invalid new segment on rebase */);
         const newSide = newSegment === oldSegment
             ? side
@@ -566,9 +570,9 @@ export class Client extends TypedEventEmitter {
                     : Side.After;
         return { segment: newSegment, offset: newOffset, side: newSide };
     }
-    computeNewObliterateEndpoints(obliterateInfo) {
+    computeNewObliterateEndpoints(obliterateInfo, squash) {
         const { currentSeq, clientId } = this.getCollabWindow();
-        const reconnectingPerspective = new LocalReconnectingPerspective(currentSeq, clientId, obliterateInfo.stamp.localSeq - 1);
+        const reconnectingPerspective = new (squash ? LocalSquashPerspective : LocalReconnectingPerspective)(currentSeq, clientId, obliterateInfo.stamp.localSeq - 1);
         const newStart = this.rebaseSidedLocalReference(obliterateInfo.start, obliterateInfo.startSide, reconnectingPerspective, SlidingPreference.FORWARD);
         const newEnd = this.rebaseSidedLocalReference(obliterateInfo.end, obliterateInfo.endSide, reconnectingPerspective, SlidingPreference.BACKWARD);
         return {
@@ -576,7 +580,7 @@ export class Client extends TypedEventEmitter {
             end: newEnd,
         };
     }
-    resetPendingDeltaToOps(resetOp, segmentGroup) {
+    resetPendingDeltaToOps(resetOp, segmentGroup, squash) {
         assert(!!segmentGroup, 0x033 /* "Segment group undefined" */);
         const NACKedSegmentGroup = this.pendingRebase?.shift()?.data;
         assert(segmentGroup === NACKedSegmentGroup, 0x034 /* "Segment group not at head of pending rebase queue" */);
@@ -603,11 +607,17 @@ export class Client extends TypedEventEmitter {
                 for (const segment of segmentGroup.segments) {
                     assert(isRemovedAndAcked(segment), 0xb66 /* On reconnect, obliterate applied to new segments even though original ones were not removed. */);
                     const lastRemove = segment.removes[segment.removes.length - 1];
-                    assert(lastRemove.type === "sliceRemove" && lastRemove.localSeq === segmentGroup.localSeq, 0xb67 /* Last remove should be the obliterate that is being resubmitted. */);
-                    // The original obliterate affected this segment, but it has since been removed and overlapping removes
-                    // are only possible when they are concurrent. We adjust the metadata on that segment now to reflect
-                    // the fact that the obliterate no longer affects it.
-                    segment.removes.pop();
+                    assert((lastRemove.type === "sliceRemove" &&
+                        lastRemove.localSeq === segmentGroup.localSeq) ||
+                        opstampUtils.isSquashedOp(lastRemove), 0xbad /* Last remove should be the obliterate that is being resubmitted. */);
+                    // The original obliterate affected this segment, but it has since been removed.
+                    // This can happen when a concurrent obliterate also removed the segment, as well as when the segment was
+                    // only locally inserted and its insertion was squashed upon reconnecting.
+                    // In the concurrent removal case (where we didn't avoid sending the segment's insertion in the first place due
+                    // to squashing), we adjust the metadata on that segment to reflect the fact that this obliterate no longer removes it.
+                    if (!opstampUtils.isSquashedOp(lastRemove)) {
+                        segment.removes.pop();
+                    }
                 }
                 this._mergeTree.rebaseObliterateTo(obliterateInfo, undefined);
                 return [];
@@ -636,19 +646,24 @@ export class Client extends TypedEventEmitter {
             };
             for (const segment of segmentGroup.segments) {
                 assert(segment.segmentGroups?.remove(segmentGroup) === true, 0x035 /* "Segment group not in segment pending queue" */);
-                if ((segment.ordinal > newStartSegment.ordinal &&
-                    segment.ordinal < newEndSegment.ordinal) ||
-                    (segment === newStartSegment && newStartSide === Side.Before) ||
-                    (segment === newEndSegment && newEndSide === Side.After)) {
+                if (!isRemovedAndAcked(segment) &&
+                    ((segment.ordinal > newStartSegment.ordinal &&
+                        segment.ordinal < newEndSegment.ordinal) ||
+                        (segment === newStartSegment && newStartSide === Side.Before) ||
+                        (segment === newEndSegment && newEndSide === Side.After))) {
                     segment.segmentGroups.enqueue(newObliterate.segmentGroup);
                 }
                 else {
                     assert(isRemovedAndAcked(segment), 0xb69 /* On reconnect, obliterate applied to new segments even though original ones were not removed. */);
                     const lastRemove = segment.removes[segment.removes.length - 1];
-                    assert(lastRemove.type === "sliceRemove" && lastRemove.localSeq === segmentGroup.localSeq, 0xb6a /* Last remove should be the obliterate that is being resubmitted. */);
-                    // The original obliterate affected this segment, but it has since been removed and it's impossible to apply the
-                    // local obliterate so that is so. We adjust the metadata on that segment now.
-                    segment.removes.pop();
+                    assert((lastRemove.type === "sliceRemove" &&
+                        lastRemove.localSeq === segmentGroup.localSeq) ||
+                        opstampUtils.isSquashedOp(lastRemove), 0xbae /* Last remove should be the obliterate that is being resubmitted. */);
+                    if (!opstampUtils.isSquashedOp(lastRemove)) {
+                        // The original obliterate affected this segment, but it has since been removed and it's impossible to apply the
+                        // local obliterate so that is so. We adjust the metadata on that segment now.
+                        segment.removes.pop();
+                    }
                 }
             }
             this._mergeTree.rebaseObliterateTo(obliterateInfo, newObliterate);
@@ -701,9 +716,19 @@ export class Client extends TypedEventEmitter {
                     break;
                 }
                 case MergeTreeDeltaType.INSERT: {
+                    if (isInserted(segment) && opstampUtils.isSquashedOp(segment.insert)) {
+                        break;
+                    }
                     assert(isInserted(segment) && opstampUtils.isLocal(segment.insert), 0x037 /* "Segment already has assigned sequence number" */);
                     const removeInfo = toRemovalInfo(segment);
-                    if (removeInfo !== undefined && opstampUtils.isAcked(removeInfo.removes[0])) {
+                    const unusedStamp = { seq: 0, clientId: 0 };
+                    if (removeInfo !== undefined && squash) {
+                        assert(removeInfo.removes.length === 1 ||
+                            opstampUtils.isAcked(removeInfo.removes[removeInfo.removes.length - 2]), 0xbaf /* Expected only one local remove */);
+                        this.squashInsertion(segment);
+                        break;
+                    }
+                    else if (removeInfo !== undefined && opstampUtils.isAcked(removeInfo.removes[0])) {
                         assert(removeInfo.removes[0].type === "sliceRemove", 0xb5c /* Remove on insertion must be caused by obliterate. */);
                         errorIfOptionNotTrue(this._mergeTree.options, "mergeTreeEnableObliterateReconnect");
                         // the segment was remotely obliterated, so is considered removed
@@ -718,6 +743,7 @@ export class Client extends TypedEventEmitter {
                                 clientId: NonCollabClient,
                             },
                         });
+                        this._mergeTree.blockUpdatePathLengths(segment.parent, unusedStamp, true);
                         break;
                     }
                     const segInsertOp = segment.clone();
@@ -857,13 +883,34 @@ export class Client extends TypedEventEmitter {
         const shortRemoteClientId = this.getOrAddShortClientId(remoteClientId);
         return this._mergeTree.resolveRemoteClientPosition(remoteClientPosition, remoteClientRefSeq, shortRemoteClientId);
     }
+    squashInsertion(segment) {
+        overwriteInfo(segment, {
+            insert: {
+                type: "insert",
+                seq: UniversalSequenceNumber,
+                localSeq: undefined,
+                clientId: SquashClient,
+            },
+            removes: [
+                {
+                    type: "setRemove",
+                    seq: UniversalSequenceNumber,
+                    localSeq: undefined,
+                    clientId: SquashClient,
+                },
+            ],
+        });
+        this._mergeTree.blockUpdatePathLengths(segment.parent, { seq: 0, clientId: 0 }, true);
+    }
     /**
      * Given a pending operation and segment group, regenerate the op, so it
      * can be resubmitted
      * @param resetOp - The op to reset
      * @param segmentGroup - The segment group associated with the op
+     * @param squash - whether intermediate states should be squashed. See `IDeltaHandler.reSubmit`'s squash parameter
+     * documentation for more details.
      */
-    regeneratePendingOp(resetOp, localOpMetadata) {
+    regeneratePendingOp(resetOp, localOpMetadata, squash) {
         const segmentGroup = localOpMetadata;
         if (this.pendingRebase === undefined || this.pendingRebase.empty) {
             let firstGroup;
@@ -885,13 +932,14 @@ export class Client extends TypedEventEmitter {
         if (this.lastNormalization === undefined ||
             collabWindow.currentSeq !== this.lastNormalization.refSeq ||
             collabWindow.localSeq !== this.lastNormalization.localRefSeq) {
+            const allPendingSegments = [...this._mergeTree.pendingSegments, ...this.pendingRebase];
             // Compute obliterate endpoint destinations before segments are normalized.
             // Segment normalization can affect what should be the semantically correct segments for the endpoints to be placed on.
             this.cachedObliterateRebases.clear();
-            for (const group of [...this._mergeTree.pendingSegments, ...this.pendingRebase]) {
+            for (const group of allPendingSegments) {
                 const { obliterateInfo } = group.data;
                 if (obliterateInfo !== undefined) {
-                    const { start, end } = this.computeNewObliterateEndpoints(obliterateInfo);
+                    const { start, end } = this.computeNewObliterateEndpoints(obliterateInfo, squash);
                     const { localSeq } = obliterateInfo.stamp;
                     assert(localSeq !== undefined, 0xb6d /* Local seq must be defined */);
                     this.cachedObliterateRebases.set(localSeq, { start, end });
@@ -909,20 +957,20 @@ export class Client extends TypedEventEmitter {
             if (Array.isArray(segmentGroup)) {
                 assert(resetOp.ops.length === segmentGroup.length, 0x03a /* "Number of ops in 'resetOp' must match the number of segment groups provided." */);
                 for (let i = 0; i < resetOp.ops.length; i++) {
-                    opList.push(...this.resetPendingDeltaToOps(resetOp.ops[i], segmentGroup[i]));
+                    opList.push(...this.resetPendingDeltaToOps(resetOp.ops[i], segmentGroup[i], squash));
                 }
             }
             else {
                 // A group op containing a single op will pass a direct reference to 'segmentGroup'
                 // rather than an array of segment groups.  (See 'peekPendingSegmentGroups()')
                 assert(resetOp.ops.length === 1, 0x03b /* "Number of ops in 'resetOp' must match the number of segment groups provided." */);
-                opList.push(...this.resetPendingDeltaToOps(resetOp.ops[0], segmentGroup));
+                opList.push(...this.resetPendingDeltaToOps(resetOp.ops[0], segmentGroup, squash));
             }
         }
         else {
             assert(resetOp.type !== MergeTreeDeltaType.GROUP, 0x03c /* "Reset op has 'group' delta type!" */);
             assert(!Array.isArray(segmentGroup), 0x03d /* "segmentGroup is array rather than singleton!" */);
-            opList.push(...this.resetPendingDeltaToOps(resetOp, segmentGroup));
+            opList.push(...this.resetPendingDeltaToOps(resetOp, segmentGroup, squash));
         }
         return opList.length === 1 ? opList[0] : createGroupOp(...opList);
     }
@@ -1009,19 +1057,14 @@ export class Client extends TypedEventEmitter {
         return this._mergeTree.getContainingSegment(pos, perspective);
     }
     getPropertiesAtPosition(pos) {
-        let propertiesAtPosition;
         const segoff = this.getContainingSegment(pos);
-        const seg = segoff.segment;
-        if (seg) {
-            propertiesAtPosition = seg.properties;
-        }
-        return propertiesAtPosition;
+        return segoff?.segment?.properties;
     }
     getRangeExtentsOfPosition(pos) {
         let posStart;
         let posAfterEnd;
         const segoff = this.getContainingSegment(pos);
-        const seg = segoff.segment;
+        const seg = segoff?.segment;
         if (seg) {
             posStart = this.getPosition(seg);
             posAfterEnd = posStart + seg.cachedLength;