@fluidframework/sequence 2.43.0 → 2.50.0

package/lib/intervalCollection.js

@@ -4,8 +4,8 @@
  */
 /* eslint-disable no-bitwise */
 import { TypedEventEmitter } from "@fluid-internal/client-utils";
-import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
-import { ReferenceType, getSlideToSegoff, refTypeIncludesFlag, reservedRangeLabelsKey, Side, endpointPosAndSide, createLocalReconnectingPerspective, DoublyLinkedList, SlidingPreference, } from "@fluidframework/merge-tree/internal";
+import { assert, DoublyLinkedList, unreachableCase, } from "@fluidframework/core-utils/internal";
+import { ReferenceType, getSlideToSegoff, refTypeIncludesFlag, reservedRangeLabelsKey, Side, endpointPosAndSide, createLocalReconnectingPerspective, 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";
@@ -99,7 +99,7 @@ export class LocalIntervalCollection {
         this.removeIntervalFromIndexes(interval);
         this.removeIntervalListeners(interval);
     }
-    addInterval(id, start, end, props, op, rollback) {
+    addInterval(id, start, end, props, op) {
         // This check is intended to prevent scenarios where a random interval is created and then
         // inserted into a collection. The aim is to ensure that the collection is created first
         // then the user can create/add intervals based on the collection
@@ -107,7 +107,7 @@ export class LocalIntervalCollection {
             props[reservedRangeLabelsKey][0] !== this.label) {
             throw new LoggingError("Adding an interval that belongs to another interval collection is not permitted");
         }
-        const interval = createSequenceInterval(this.label, id, start, end, this.client, IntervalType.SlideOnRemove, op, undefined, this.options.mergeTreeReferencesCanSlideToEndpoint, props, rollback);
+        const interval = createSequenceInterval(this.label, id, start, end, this.client, IntervalType.SlideOnRemove, op, undefined, this.options.mergeTreeReferencesCanSlideToEndpoint, props, false);
         this.add(interval);
         return interval;
     }
@@ -207,12 +207,12 @@ function removeMetadataFromPendingChanges(localOpMetadataNode) {
 }
 function clearEmptyPendingEntry(pendingChanges, id) {
     const pending = pendingChanges[id];
-    assert(pending !== undefined, 0xbbf /* pending must exist for local process */);
-    if (pending.local.empty) {
+    if (pending !== undefined && pending.local.empty) {
         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];
     }
+    return pending;
 }
 function hasEndpointChanges(serialized) {
     return serialized.start !== undefined && serialized.end !== undefined;
@@ -228,15 +228,15 @@ export class IntervalCollection extends TypedEventEmitter {
         super();
         this.options = options;
         this.pending = {};
-        this.submitDelta = (op, md) => {
+        this.submitDelta = (op, md, consensus) => {
             const { id } = getSerializedProperties(op.value);
             const pending = (this.pending[id] ??= {
                 local: new DoublyLinkedList(),
+                consensus,
             });
             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);
         };
@@ -276,57 +276,57 @@ export class IntervalCollection extends TypedEventEmitter {
         const localOpMetadata = removeMetadataFromPendingChanges(maybeMetadata);
         const { value } = op;
         const { id, properties } = getSerializedProperties(value);
-        const { type } = localOpMetadata;
+        const pending = clearEmptyPendingEntry(this.pending, id);
+        const previous = pending?.local.empty
+            ? pending.consensus
+            : pending?.local.last?.data.interval;
+        const { type, interval } = localOpMetadata;
         switch (type) {
             case "add": {
-                const interval = this.getIntervalById(id);
-                if (interval) {
-                    this.deleteExistingInterval({ interval, local: true, rollback: true });
-                }
+                this.deleteExistingInterval({ interval, local: true, rollback: true });
+                interval.dispose();
                 break;
             }
             case "change": {
-                const { previous } = localOpMetadata;
-                const endpointsChanged = hasEndpointChanges(value);
-                const start = endpointsChanged
-                    ? toOptionalSequencePlace(previous.start, previous.startSide)
-                    : undefined;
-                const end = endpointsChanged
-                    ? toOptionalSequencePlace(previous.end, previous.endSide)
+                const changeProperties = Object.keys(properties).length > 0;
+                const deltaProps = changeProperties
+                    ? interval.changeProperties(properties, undefined, true)
                     : undefined;
-                this.change(id, {
-                    start,
-                    end,
-                    props: Object.keys(properties).length > 0 ? properties : undefined,
-                    rollback: true,
-                });
+                if (localOpMetadata.endpointChangesNode !== undefined) {
+                    this.localCollection?.removeExistingInterval(interval);
+                    assert(previous !== undefined, 0xbd2 /* must have existed to change */);
+                    this.localCollection?.add(previous);
+                    this.emitChange(previous, interval, true, true);
+                }
+                if (previous !== interval) {
+                    interval.dispose();
+                }
+                if (changeProperties) {
+                    this.emit("propertyChanged", previous, deltaProps, true, undefined);
+                }
                 break;
             }
             case "delete": {
-                const { previous } = localOpMetadata;
-                this.add({
-                    id,
-                    start: toSequencePlace(previous.start, previous.startSide),
-                    end: toSequencePlace(previous.end, previous.endSide),
-                    props: Object.keys(properties).length > 0 ? properties : undefined,
-                    rollback: true,
-                });
+                assert(previous !== undefined, 0xbd3 /* must have existed to delete */);
+                this.localCollection?.add(previous);
+                this.emit("addInterval", previous, true, undefined);
                 break;
             }
             default:
                 unreachableCase(type);
         }
-        clearEmptyPendingEntry(this.pending, id);
     }
     process(op, local, message, maybeMetadata) {
         const localOpMetadata = local
             ? removeMetadataFromPendingChanges(maybeMetadata)
             : undefined;
         const { opName, value } = op;
+        const { id } = getSerializedProperties(value);
         assert((local === false && localOpMetadata === undefined) || opName === localOpMetadata?.type, 0xbc1 /* must be same type */);
+        let newConsensus = localOpMetadata?.interval;
         switch (opName) {
             case "add": {
-                this.ackAdd(value, local, message, 
+                newConsensus = this.ackAdd(value, local, message, 
                 // this cast is safe because of the above assert which
                 // validates the op and metadata types match for local changes
                 localOpMetadata);
@@ -337,15 +337,17 @@ export class IntervalCollection extends TypedEventEmitter {
                 break;
             }
             case "change": {
-                this.ackChange(value, local, message);
+                newConsensus = this.ackChange(value, local, message, // this cast is safe because of the above assert which
+                // validates the op and metadata types match for local changes
+                localOpMetadata);
                 break;
             }
             default:
                 unreachableCase(opName);
         }
-        if (local) {
-            const { id } = getSerializedProperties(value);
-            clearEmptyPendingEntry(this.pending, id);
+        const pending = clearEmptyPendingEntry(this.pending, id);
+        if (pending !== undefined) {
+            pending.consensus = newConsensus;
         }
     }
     resubmitMessage(op, maybeMetadata, squash) {
@@ -443,7 +445,7 @@ export class IntervalCollection extends TypedEventEmitter {
                 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, squash);
+                            this.rebaseLocalInterval(local.data.interval.serialize(), local.data, squash);
                         }
                     }
                 }
@@ -506,7 +508,7 @@ export class IntervalCollection extends TypedEventEmitter {
     /**
      * {@inheritdoc IIntervalCollection.add}
      */
-    add({ id, start, end, props, rollback, }) {
+    add({ id, start, end, props, }) {
         if (!this.localCollection) {
             throw new LoggingError("attach must be called prior to adding intervals");
         }
@@ -517,7 +519,7 @@ export class IntervalCollection extends TypedEventEmitter {
             endSide !== undefined, 0x793 /* start and end cannot be undefined because they were not passed in as undefined */);
         this.assertStickinessEnabled(start, end);
         const intervalId = id ?? uuid();
-        const interval = this.localCollection.addInterval(intervalId, toSequencePlace(startPos, startSide), toSequencePlace(endPos, endSide), props, undefined, rollback);
+        const interval = this.localCollection.addInterval(intervalId, toSequencePlace(startPos, startSide), toSequencePlace(endPos, endSide), props, undefined);
         if (interval) {
             if (!this.isCollaborating) {
                 setSlideOnRemove(interval.start);
@@ -525,7 +527,7 @@ export class IntervalCollection extends TypedEventEmitter {
             }
             const serializedInterval = interval.serialize();
             const localSeq = this.getNextLocalSeq();
-            if (this.isCollaborating && rollback !== true) {
+            if (this.isCollaborating) {
                 this.submitDelta({
                     opName: "add",
                     value: serializedInterval,
@@ -555,8 +557,7 @@ export class IntervalCollection extends TypedEventEmitter {
                 }, {
                     type: "delete",
                     localSeq: this.getNextLocalSeq(),
-                    previous: value,
-                });
+                }, interval);
             }
             else {
                 if (this.onDeserialize) {
@@ -573,7 +574,7 @@ export class IntervalCollection extends TypedEventEmitter {
         if (!this.localCollection) {
             throw new LoggingError("Attach must be called before accessing intervals");
         }
-        const interval = this.localCollection.idIntervalIndex.getIntervalById(id);
+        const interval = this.getIntervalById(id);
         if (interval) {
             this.deleteExistingInterval({ interval, local: true });
         }
@@ -621,13 +622,12 @@ export class IntervalCollection extends TypedEventEmitter {
                 const metadata = {
                     type: "change",
                     localSeq,
-                    previous: interval.serialize(),
                     interval: newInterval ?? interval,
                 };
                 this.submitDelta({
                     opName: "change",
                     value: serializedInterval,
-                }, metadata);
+                }, metadata, interval);
             }
             if (deltaProps !== undefined) {
                 this.emit("propertyChanged", interval, deltaProps, true, undefined);
@@ -651,7 +651,7 @@ export class IntervalCollection extends TypedEventEmitter {
     hasPendingEndpointChanges(id) {
         return this.pending[id]?.endpointChanges?.empty === false;
     }
-    ackChange(serializedInterval, local, op) {
+    ackChange(serializedInterval, local, op, localOpMetadata) {
         if (!this.localCollection) {
             throw new LoggingError("Attach must be called before accessing intervals");
         }
@@ -660,44 +660,39 @@ export class IntervalCollection extends TypedEventEmitter {
         // strip it out of the properties here.
         const { id, properties } = getSerializedProperties(serializedInterval);
         assert(id !== undefined, 0x3fe /* id must exist on the interval */);
-        const interval = this.getIntervalById(id);
-        if (!interval) {
-            // The interval has been removed locally; no-op.
-            return;
-        }
         if (local) {
+            assert(localOpMetadata !== undefined, 0xbd4 /* local must have metadata */);
+            const { interval } = localOpMetadata;
             interval.ackPropertiesChange(properties, op);
             this.ackInterval(interval, op);
+            return interval;
         }
         else {
-            // If there are pending changes with this ID, don't apply the remote start/end change, as the local ack
-            // should be the winning change.
-            let start;
-            let end;
-            // Track pending start/end independently of one another.
-            if (!this.hasPendingEndpointChanges(id)) {
-                start = serializedInterval.start;
-                end = serializedInterval.end;
-            }
-            let newInterval = interval;
-            if (start !== undefined || end !== undefined) {
-                // If changeInterval gives us a new interval, work with that one. Otherwise keep working with
-                // the one we originally found in the tree.
-                newInterval =
-                    this.localCollection.changeInterval(interval, toOptionalSequencePlace(start, serializedInterval.startSide ?? Side.Before), toOptionalSequencePlace(end, serializedInterval.endSide ?? Side.Before), op) ?? interval;
-            }
-            const deltaProps = newInterval.changeProperties(properties, op);
-            if (this.onDeserialize) {
-                this.onDeserialize(newInterval);
-            }
-            if (newInterval !== interval) {
-                this.emitChange(newInterval, interval, local, false, op);
+            const latestInterval = this.getIntervalById(id);
+            const intervalToChange = this.pending[id]?.consensus ?? latestInterval;
+            const isLatestInterval = intervalToChange === latestInterval;
+            if (!intervalToChange) {
+                return intervalToChange;
+            }
+            const deltaProps = intervalToChange.changeProperties(properties, op);
+            let newInterval = intervalToChange;
+            if (hasEndpointChanges(serializedInterval)) {
+                const { start, end, startSide, endSide } = serializedInterval;
+                newInterval = intervalToChange.modify("", toOptionalSequencePlace(start, startSide ?? Side.Before), toOptionalSequencePlace(end, endSide ?? Side.Before), op);
+                if (isLatestInterval) {
+                    this.localCollection.removeExistingInterval(intervalToChange);
+                    this.localCollection.add(newInterval);
+                    this.emitChange(newInterval, intervalToChange, local, false, op);
+                    if (this.onDeserialize) {
+                        this.onDeserialize(newInterval);
+                    }
+                }
             }
-            const changedProperties = Object.keys(properties).length > 0;
-            if (changedProperties) {
-                this.emit("propertyChanged", interval, deltaProps, local, op);
-                this.emit("changed", interval, deltaProps, undefined, local, false);
+            if (deltaProps !== undefined && Object.keys(deltaProps).length > 0) {
+                this.emit("propertyChanged", latestInterval, deltaProps, local, op);
+                this.emit("changed", latestInterval, deltaProps, undefined, local, false);
             }
+            return newInterval;
         }
     }
     /**
@@ -731,8 +726,8 @@ export class IntervalCollection extends TypedEventEmitter {
         }
         const { localSeq, interval } = localOpMetadata;
         const { id } = getSerializedProperties(original);
-        const rebasedEndpoint = (localOpMetadata.rebased ??= this.computeRebasedPositions(localOpMetadata, squash));
-        const localInterval = this.localCollection.idIntervalIndex.getIntervalById(id);
+        const rebasedEndpoint = this.computeRebasedPositions(localOpMetadata, squash);
+        const localInterval = this.getIntervalById(id);
         // if the interval slid off the string, rebase the op to be a noop and delete the interval.
         if (rebasedEndpoint === "detached") {
             if (localInterval !== undefined &&
@@ -755,8 +750,7 @@ export class IntervalCollection extends TypedEventEmitter {
                 this.localCollection.add(interval);
                 this.emitChange(interval, old, true, true);
             }
-            this.client.removeLocalReferencePosition(old.start);
-            this.client.removeLocalReferencePosition(old.end);
+            old.dispose();
         }
         return {
             ...original,
@@ -805,10 +799,13 @@ export class IntervalCollection extends TypedEventEmitter {
             }
             // `interval`'s endpoints will get modified in-place, so clone it prior to doing so for event emission.
             const oldInterval = interval.clone();
-            // In this case, where we change the start or end of an interval,
-            // it is necessary to remove and re-add the interval listeners.
-            // This ensures that the correct listeners are added to the LocalReferencePosition.
-            this.localCollection.removeExistingInterval(interval);
+            const isLatestInterval = this.getIntervalById(id) === interval;
+            if (isLatestInterval) {
+                // In this case, where we change the start or end of an interval,
+                // it is necessary to remove and re-add the interval listeners.
+                // This ensures that the correct listeners are added to the LocalReferencePosition.
+                this.localCollection.removeExistingInterval(interval);
+            }
             if (!this.client) {
                 throw new LoggingError("client does not exist");
             }
@@ -850,19 +847,18 @@ export class IntervalCollection extends TypedEventEmitter {
                 oldInterval.end.refType = ReferenceType.Transient;
                 oldSeg?.localRefs?.addLocalRef(oldInterval.end, oldInterval.end.getOffset());
             }
-            this.localCollection.add(interval);
-            this.emitChange(interval, oldInterval, true, true, op);
+            if (isLatestInterval) {
+                this.localCollection.add(interval);
+                this.emitChange(interval, oldInterval, true, true, op);
+            }
         }
     }
     ackAdd(serializedInterval, local, op, localOpMetadata) {
         const { id, properties } = getSerializedProperties(serializedInterval);
         if (local) {
             assert(localOpMetadata !== undefined, 0x553 /* op metadata should be defined for local op */);
-            const localInterval = this.getIntervalById(id);
-            if (localInterval) {
-                this.ackInterval(localInterval, op);
-            }
-            return;
+            this.ackInterval(localOpMetadata.interval, op);
+            return localOpMetadata.interval;
         }
         if (!this.localCollection) {
             throw new LoggingError("attachSequence must be called");
@@ -887,7 +883,7 @@ export class IntervalCollection extends TypedEventEmitter {
             throw new LoggingError("attach must be called prior to deleting intervals");
         }
         const { id } = getSerializedProperties(serializedInterval);
-        const interval = this.localCollection.idIntervalIndex.getIntervalById(id);
+        const interval = this.getIntervalById(id);
         if (interval) {
             this.deleteExistingInterval({ interval, local, op });
         }