@fluidframework/sequence 2.43.0-343119 → 2.43.0

package/lib/intervalCollection.js

@@ -5,12 +5,12 @@
 /* eslint-disable no-bitwise */
 import { TypedEventEmitter } from "@fluid-internal/client-utils";
 import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
-import { DetachedReferencePosition, ReferenceType, SlidingPreference, getSlideToSegoff, refTypeIncludesFlag, reservedRangeLabelsKey, Side, endpointPosAndSide, createLocalReconnectingPerspective, DoublyLinkedList, } from "@fluidframework/merge-tree/internal";
+import { ReferenceType, getSlideToSegoff, refTypeIncludesFlag, reservedRangeLabelsKey, Side, endpointPosAndSide, createLocalReconnectingPerspective, DoublyLinkedList, SlidingPreference, } from "@fluidframework/merge-tree/internal";
 import { LoggingError, UsageError } from "@fluidframework/telemetry-utils/internal";
 import { v4 as uuid } from "uuid";
 import { createIdIntervalIndex, EndpointIndex, OverlappingIntervalsIndex, } from "./intervalIndex/index.js";
-import { IntervalStickiness, IntervalType, createPositionReferenceFromSegoff, createSequenceInterval, endReferenceSlidingPreference, getSerializedProperties, startReferenceSlidingPreference, } from "./intervals/index.js";
-export function sidesFromStickiness(stickiness) {
+import { IntervalStickiness, IntervalType, createPositionReferenceFromSegoff, createSequenceInterval, getSerializedProperties, } from "./intervals/index.js";
+function sidesFromStickiness(stickiness) {
     const startSide = (stickiness & IntervalStickiness.START) !== 0 ? Side.After : Side.Before;
     const endSide = (stickiness & IntervalStickiness.END) !== 0 ? Side.Before : Side.After;
     return { startSide, endSide };
@@ -60,16 +60,6 @@ export function toSequencePlace(pos, side) {
 export function toOptionalSequencePlace(pos, side) {
     return typeof pos === "number" && side !== undefined ? { pos, side } : pos;
 }
-export function computeStickinessFromSide(startPos = -1, startSide = Side.Before, endPos = -1, endSide = Side.Before) {
-    let stickiness = IntervalStickiness.NONE;
-    if (startSide === Side.After || startPos === "start") {
-        stickiness |= IntervalStickiness.START;
-    }
-    if (endSide === Side.Before || endPos === "end") {
-        stickiness |= IntervalStickiness.END;
-    }
-    return stickiness;
-}
 export class LocalIntervalCollection {
     constructor(client, label, options, 
     /** Callback invoked each time one of the endpoints of an interval slides. */
@@ -211,15 +201,15 @@ class IntervalCollectionIterator {
 function removeMetadataFromPendingChanges(localOpMetadataNode) {
     const acked = localOpMetadataNode?.remove()
         ?.data;
-    assert(acked !== undefined, "local change must exist");
+    assert(acked !== undefined, 0xbbe /* local change must exist */);
     acked.endpointChangesNode?.remove();
     return acked;
 }
 function clearEmptyPendingEntry(pendingChanges, id) {
     const pending = pendingChanges[id];
-    assert(pending !== undefined, "pending must exist for local process");
+    assert(pending !== undefined, 0xbbf /* pending must exist for local process */);
     if (pending.local.empty) {
-        assert(pending.endpointChanges?.empty !== false, "endpointChanges must be empty if not pending changes");
+        assert(pending.endpointChanges?.empty !== false, 0xbc0 /* endpointChanges must be empty if not pending changes */);
         // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
         delete pendingChanges[id];
     }
@@ -246,6 +236,7 @@ export class IntervalCollection extends TypedEventEmitter {
             if (md.type === "add" || (md.type === "change" && hasEndpointChanges(op.value))) {
                 const endpointChanges = (pending.endpointChanges ??= new DoublyLinkedList());
                 md.endpointChangesNode = endpointChanges.push(md).last;
+                md.rebased = undefined;
             }
             submitDelta(op, pending.local.push(md).last);
         };
@@ -332,7 +323,7 @@ export class IntervalCollection extends TypedEventEmitter {
             ? removeMetadataFromPendingChanges(maybeMetadata)
             : undefined;
         const { opName, value } = op;
-        assert((local === false && localOpMetadata === undefined) || opName === localOpMetadata?.type, "must be same type");
+        assert((local === false && localOpMetadata === undefined) || opName === localOpMetadata?.type, 0xbc1 /* must be same type */);
         switch (opName) {
             case "add": {
                 this.ackAdd(value, local, message, 
@@ -357,12 +348,12 @@ export class IntervalCollection extends TypedEventEmitter {
             clearEmptyPendingEntry(this.pending, id);
         }
     }
-    resubmitMessage(op, maybeMetadata) {
+    resubmitMessage(op, maybeMetadata, squash) {
         const { opName, value } = op;
         const localOpMetadata = removeMetadataFromPendingChanges(maybeMetadata);
         const rebasedValue = localOpMetadata.endpointChangesNode === undefined
             ? value
-            : this.rebaseLocalInterval(localOpMetadata);
+            : this.rebaseLocalInterval(value, localOpMetadata, squash);
         if (rebasedValue === undefined) {
             const { id } = getSerializedProperties(value);
             clearEmptyPendingEntry(this.pending, id);
@@ -400,40 +391,43 @@ export class IntervalCollection extends TypedEventEmitter {
                 throw new Error("unknown ops should not be stashed");
         }
     }
-    rebasePositionWithSegmentSlide(pos, seqNumberFrom, localSeq) {
+    rebaseReferenceWithSegmentSlide(ref, localSeq, squash) {
         if (!this.client) {
             throw new LoggingError("mergeTree client must exist");
         }
-        if (pos === "start" || pos === "end") {
-            return pos;
-        }
         const { clientId } = this.client.getCollabWindow();
-        const { segment, offset } = this.client.getContainingSegment(pos, {
-            referenceSequenceNumber: seqNumberFrom,
-            clientId: this.client.getLongClientId(clientId),
-        }, localSeq) ?? {};
-        // if segment is undefined, it slid off the string
-        assert(segment !== undefined && offset !== undefined, 0x54e /* No segment found */);
-        const segoff = getSlideToSegoff({ segment, offset }, undefined, createLocalReconnectingPerspective(this.client.getCurrentSeq(), clientId, localSeq), this.options.mergeTreeReferencesCanSlideToEndpoint);
+        const segment = ref.getSegment();
+        if (segment?.endpointType) {
+            return { segment, offset: 0 };
+        }
+        const offset = ref.getOffset();
+        const segoff = getSlideToSegoff(segment === undefined ? undefined : { segment, offset }, ref.slidingPreference, createLocalReconnectingPerspective(this.client.getCurrentSeq(), clientId, localSeq, squash), ref.canSlideToEndpoint);
         // case happens when rebasing op, but concurrently entire string has been deleted
-        if (segoff?.segment === undefined || segoff.offset === undefined) {
-            return DetachedReferencePosition;
+        if (segoff === undefined) {
+            if (ref.canSlideToEndpoint !== true) {
+                return undefined;
+            }
+            return {
+                segment: ref.slidingPreference === SlidingPreference.FORWARD
+                    ? this.client.endOfTree
+                    : this.client.startOfTree,
+                offset: 0,
+            };
         }
-        assert(offset !== undefined && 0 <= offset && offset < segment.cachedLength, 0x54f /* Invalid offset */);
-        return this.client.findReconnectionPosition(segoff.segment, localSeq) + segoff.offset;
+        return segoff;
     }
-    computeRebasedPositions(localOpMetadata) {
+    computeRebasedPositions(localOpMetadata, squash) {
         assert(this.client !== undefined, 0x550 /* Client should be defined when computing rebased position */);
-        const { localSeq, original } = localOpMetadata;
-        const rebased = { ...original };
-        const { start, end, sequenceNumber } = original;
-        if (start !== undefined) {
-            rebased.start = this.rebasePositionWithSegmentSlide(start, sequenceNumber, localSeq);
+        const { localSeq, interval } = localOpMetadata;
+        const start = this.rebaseReferenceWithSegmentSlide(interval.start, localSeq, squash);
+        if (start === undefined) {
+            return "detached";
         }
-        if (end !== undefined) {
-            rebased.end = this.rebasePositionWithSegmentSlide(end, sequenceNumber, localSeq);
+        const end = this.rebaseReferenceWithSegmentSlide(interval.end, localSeq, squash);
+        if (end === undefined) {
+            return "detached";
         }
-        return rebased;
+        return { start, end };
     }
     attachGraph(client, label) {
         if (this.attached) {
@@ -445,11 +439,11 @@ export class IntervalCollection extends TypedEventEmitter {
         // Instantiate the local interval collection based on the saved intervals
         this.client = client;
         if (client) {
-            client.on("normalize", () => {
+            client.on("normalize", (squash) => {
                 for (const pending of Object.values(this.pending)) {
                     if (pending?.endpointChanges !== undefined) {
                         for (const local of pending.endpointChanges) {
-                            local.data.rebased = this.computeRebasedPositions(local.data);
+                            local.data.rebased = this.computeRebasedPositions(local.data, squash);
                         }
                     }
                 }
@@ -538,7 +532,7 @@ export class IntervalCollection extends TypedEventEmitter {
                 }, {
                     type: "add",
                     localSeq,
-                    original: serializedInterval,
+                    interval,
                 });
             }
         }
@@ -628,7 +622,7 @@ export class IntervalCollection extends TypedEventEmitter {
                     type: "change",
                     localSeq,
                     previous: interval.serialize(),
-                    original: serializedInterval,
+                    interval: newInterval ?? interval,
                 };
                 this.submitDelta({
                     opName: "change",
@@ -641,8 +635,10 @@ export class IntervalCollection extends TypedEventEmitter {
             }
             if (newInterval) {
                 this.emitChange(newInterval, interval, true, false);
-                this.client?.removeLocalReferencePosition(interval.start);
-                this.client?.removeLocalReferencePosition(interval.end);
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                interval.start.properties.interval = undefined;
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                interval.end.properties.interval = undefined;
             }
             return newInterval;
         }
@@ -725,47 +721,53 @@ export class IntervalCollection extends TypedEventEmitter {
      * to a range that no longer exists, and the interval was unable to slide.
      *
      */
-    rebaseLocalInterval(localOpMetadata) {
-        const original = localOpMetadata.original;
-        if (!this.client) {
+    rebaseLocalInterval(original, localOpMetadata, squash) {
+        if (!this.client || !hasEndpointChanges(original)) {
             // If there's no associated mergeTree client, the originally submitted op is still correct.
             return original;
         }
-        if (!this.attached) {
+        if (!this.attached || this.localCollection === undefined) {
             throw new LoggingError("attachSequence must be called");
         }
-        const { localSeq } = localOpMetadata;
-        const { intervalType, properties, stickiness, startSide, endSide } = original;
+        const { localSeq, interval } = localOpMetadata;
         const { id } = getSerializedProperties(original);
-        const { start: startRebased, end: endRebased } = (localOpMetadata.rebased ??=
-            this.computeRebasedPositions(localOpMetadata));
-        const localInterval = this.localCollection?.idIntervalIndex.getIntervalById(id);
-        const rebased = {
-            start: startRebased,
-            end: endRebased,
-            intervalType,
-            sequenceNumber: this.client?.getCurrentSeq() ?? 0,
-            properties,
-            stickiness,
-            startSide,
-            endSide,
-        };
+        const rebasedEndpoint = (localOpMetadata.rebased ??= this.computeRebasedPositions(localOpMetadata, squash));
+        const localInterval = this.localCollection.idIntervalIndex.getIntervalById(id);
         // if the interval slid off the string, rebase the op to be a noop and delete the interval.
-        if (!this.options.mergeTreeReferencesCanSlideToEndpoint &&
-            (startRebased === DetachedReferencePosition || endRebased === DetachedReferencePosition)) {
-            if (localInterval) {
+        if (rebasedEndpoint === "detached") {
+            if (localInterval !== undefined &&
+                (localInterval === interval || localOpMetadata.type === "add")) {
                 this.localCollection?.removeExistingInterval(localInterval);
             }
             return undefined;
         }
-        if (localInterval !== undefined) {
-            // The rebased op may place this interval's endpoints on different segments. Calling `changeInterval` here
-            // updates the local client's state to be consistent with the emitted op.
-            this.localCollection?.changeInterval(localInterval, toOptionalSequencePlace(startRebased, startSide ?? Side.Before), toOptionalSequencePlace(endRebased, endSide ?? Side.Before), undefined, localSeq);
+        const { start, end } = rebasedEndpoint;
+        if (interval.start.getSegment() !== start.segment ||
+            interval.start.getOffset() !== start.offset ||
+            interval.end.getSegment() !== end.segment ||
+            interval.end.getOffset() !== end.offset) {
+            if (localInterval === interval) {
+                this.localCollection.removeExistingInterval(localInterval);
+            }
+            const old = interval.clone();
+            interval.moveEndpointReferences(rebasedEndpoint);
+            if (localInterval === interval) {
+                this.localCollection.add(interval);
+                this.emitChange(interval, old, true, true);
+            }
+            this.client.removeLocalReferencePosition(old.start);
+            this.client.removeLocalReferencePosition(old.end);
         }
-        return rebased;
+        return {
+            ...original,
+            start: start.segment.endpointType ??
+                this.client.findReconnectionPosition(start.segment, localSeq) + start.offset,
+            end: end.segment.endpointType ??
+                this.client.findReconnectionPosition(end.segment, localSeq) + end.offset,
+            sequenceNumber: this.client?.getCurrentSeq() ?? 0,
+        };
     }
-    getSlideToSegment(lref, slidingPreference) {
+    getSlideToSegment(lref) {
         if (!this.client) {
             throw new LoggingError("client does not exist");
         }
@@ -780,15 +782,15 @@ export class IntervalCollection extends TypedEventEmitter {
         if (segoff.segment.localRefs?.has(lref) !== true) {
             return undefined;
         }
-        return getSlideToSegoff(segoff, slidingPreference, undefined, this.options.mergeTreeReferencesCanSlideToEndpoint);
+        return getSlideToSegoff(segoff, lref.slidingPreference, undefined, lref.canSlideToEndpoint);
     }
     ackInterval(interval, op) {
         if (!refTypeIncludesFlag(interval.start, ReferenceType.StayOnRemove) &&
             !refTypeIncludesFlag(interval.end, ReferenceType.StayOnRemove)) {
             return;
         }
-        const newStart = this.getSlideToSegment(interval.start, startReferenceSlidingPreference(interval.stickiness));
-        const newEnd = this.getSlideToSegment(interval.end, endReferenceSlidingPreference(interval.stickiness));
+        const newStart = this.getSlideToSegment(interval.start);
+        const newEnd = this.getSlideToSegment(interval.end);
         const id = interval.getIntervalId();
         const hasPendingChange = this.hasPendingEndpointChanges(id);
         if (!hasPendingChange) {
@@ -812,7 +814,14 @@ export class IntervalCollection extends TypedEventEmitter {
             }
             if (needsStartUpdate) {
                 const props = interval.start.properties;
-                interval.start = createPositionReferenceFromSegoff(this.client, newStart, interval.start.refType, op, undefined, undefined, startReferenceSlidingPreference(interval.stickiness), startReferenceSlidingPreference(interval.stickiness) === SlidingPreference.BACKWARD);
+                interval.start = createPositionReferenceFromSegoff({
+                    client: this.client,
+                    segoff: newStart,
+                    refType: interval.start.refType,
+                    op,
+                    slidingPreference: interval.start.slidingPreference,
+                    canSlideToEndpoint: interval.start.canSlideToEndpoint,
+                });
                 if (props) {
                     interval.start.addProperties(props);
                 }
@@ -824,7 +833,14 @@ export class IntervalCollection extends TypedEventEmitter {
             }
             if (needsEndUpdate) {
                 const props = interval.end.properties;
-                interval.end = createPositionReferenceFromSegoff(this.client, newEnd, interval.end.refType, op, undefined, undefined, endReferenceSlidingPreference(interval.stickiness), endReferenceSlidingPreference(interval.stickiness) === SlidingPreference.FORWARD);
+                interval.end = createPositionReferenceFromSegoff({
+                    client: this.client,
+                    segoff: newEnd,
+                    refType: interval.end.refType,
+                    op,
+                    slidingPreference: interval.end.slidingPreference,
+                    canSlideToEndpoint: interval.end.canSlideToEndpoint,
+                });
                 if (props) {
                     interval.end.addProperties(props);
                 }