@fluidframework/sequence 2.31.1 → 2.33.0-333010

package/lib/intervalCollection.js

@@ -4,13 +4,12 @@
  */
 /* eslint-disable no-bitwise */
 import { TypedEventEmitter } from "@fluid-internal/client-utils";
-import { assert } from "@fluidframework/core-utils/internal";
-import { DetachedReferencePosition, ReferenceType, SlidingPreference, UnassignedSequenceNumber, UniversalSequenceNumber, addProperties, getSlideToSegoff, refTypeIncludesFlag, reservedRangeLabelsKey, Side, endpointPosAndSide, PropertiesManager, createMap, } from "@fluidframework/merge-tree/internal";
+import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
+import { DetachedReferencePosition, ReferenceType, SlidingPreference, getSlideToSegoff, refTypeIncludesFlag, reservedRangeLabelsKey, Side, endpointPosAndSide, createLocalReconnectingPerspective, } 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 { IntervalDeltaOpType, IntervalStickiness, IntervalType, createPositionReferenceFromSegoff, createSequenceInterval, endReferenceSlidingPreference, startReferenceSlidingPreference, } from "./intervals/index.js";
-export const reservedIntervalIdKey = "intervalId";
+import { IntervalStickiness, IntervalType, createPositionReferenceFromSegoff, createSequenceInterval, endReferenceSlidingPreference, getSerializedProperties, startReferenceSlidingPreference, } from "./intervals/index.js";
 export function sidesFromStickiness(stickiness) {
     const startSide = (stickiness & IntervalStickiness.START) !== 0 ? Side.After : Side.Before;
     const endSide = (stickiness & IntervalStickiness.END) !== 0 ? Side.Before : Side.After;
@@ -88,11 +87,6 @@ export class LocalIntervalCollection {
             this.endIntervalIndex,
         ]);
     }
-    createLegacyId(start, end) {
-        // Create a non-unique ID based on start and end to be used on intervals that come from legacy clients
-        // without ID's.
-        return `${LocalIntervalCollection.legacyIdPrefix}${start}-${end}`;
-    }
     /**
      * Validates that a serialized interval has the ID property. Creates an ID
      * if one does not already exist
@@ -100,26 +94,6 @@ export class LocalIntervalCollection {
      * @param serializedInterval - The interval to be checked
      * @returns The interval's existing or newly created id
      */
-    ensureSerializedId(serializedInterval) {
-        let id = serializedInterval.properties?.[reservedIntervalIdKey];
-        if (id === undefined) {
-            // Back-compat: 0.39 and earlier did not have IDs on intervals. If an interval from such a client
-            // comes over the wire, create a non-unique one based on start/end.
-            // This will allow all clients to refer to this interval consistently.
-            id = this.createLegacyId(serializedInterval.start, serializedInterval.end);
-            const newProps = {
-                [reservedIntervalIdKey]: id,
-            };
-            serializedInterval.properties = addProperties(serializedInterval.properties, newProps);
-        }
-        // Make the ID immutable for safety's sake.
-        Object.defineProperty(serializedInterval.properties, reservedIntervalIdKey, {
-            configurable: false,
-            enumerable: true,
-            writable: false,
-        });
-        return id;
-    }
     removeIntervalFromIndexes(interval) {
         for (const index of this.indexes) {
             index.remove(interval);
@@ -135,28 +109,16 @@ export class LocalIntervalCollection {
         this.removeIntervalFromIndexes(interval);
         this.removeIntervalListeners(interval);
     }
-    createInterval(start, end, intervalType, op) {
-        return createSequenceInterval(this.label, start, end, this.client, intervalType, op, undefined, this.options.mergeTreeReferencesCanSlideToEndpoint);
-    }
-    addInterval(start, end, intervalType, props, op) {
-        const interval = this.createInterval(start, end, intervalType, op);
-        if (interval) {
-            if (!interval.properties) {
-                interval.properties = createMap();
-            }
-            if (props) {
-                // 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
-                if (props[reservedRangeLabelsKey] !== undefined &&
-                    props[reservedRangeLabelsKey][0] !== this.label) {
-                    throw new LoggingError("Adding an interval that belongs to another interval collection is not permitted");
-                }
-                interval.properties = addProperties(interval.properties, props);
-            }
-            interval.properties[reservedIntervalIdKey] ??= uuid();
-            this.add(interval);
+    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
+        if (props?.[reservedRangeLabelsKey] !== undefined &&
+            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);
+        this.add(interval);
         return interval;
     }
     linkEndpointsToInterval(interval) {
@@ -227,52 +189,6 @@ export class LocalIntervalCollection {
         interval.removePositionChangeListeners();
     }
 }
-LocalIntervalCollection.legacyIdPrefix = "legacy";
-const rebase = (collection, op, localOpMetadata) => {
-    const { localSeq } = localOpMetadata;
-    const rebasedValue = collection.rebaseLocalInterval(op.opName, op.value, localSeq);
-    if (rebasedValue === undefined) {
-        return undefined;
-    }
-    const rebasedOp = { ...op, value: rebasedValue };
-    return { rebasedOp, rebasedLocalOpMetadata: localOpMetadata };
-};
-export const opsMap = {
-    [IntervalDeltaOpType.ADD]: {
-        process: (collection, params, local, op, localOpMetadata) => {
-            // if params is undefined, the interval was deleted during
-            // rebasing
-            if (!params) {
-                return;
-            }
-            assert(op !== undefined, 0x3fb /* op should exist here */);
-            collection.ackAdd(params, local, op, localOpMetadata);
-        },
-        rebase,
-    },
-    [IntervalDeltaOpType.DELETE]: {
-        process: (collection, params, local, op) => {
-            assert(op !== undefined, 0x3fc /* op should exist here */);
-            collection.ackDelete(params, local, op);
-        },
-        rebase: (collection, op, localOpMetadata) => {
-            // Deletion of intervals is based on id, so requires no rebasing.
-            return { rebasedOp: op, rebasedLocalOpMetadata: localOpMetadata };
-        },
-    },
-    [IntervalDeltaOpType.CHANGE]: {
-        process: (collection, params, local, op, localOpMetadata) => {
-            // if params is undefined, the interval was deleted during
-            // rebasing
-            if (!params) {
-                return;
-            }
-            assert(op !== undefined, 0x3fd /* op should exist here */);
-            collection.ackChange(params, local, op, localOpMetadata);
-        },
-        rebase,
-    },
-};
 class IntervalCollectionIterator {
     constructor(collection, iteratesForward = true, start, end) {
         this.results = [];
@@ -339,6 +255,64 @@ export class IntervalCollection extends TypedEventEmitter {
         }
         return true;
     }
+    process(op, local, message, localOpMetadata) {
+        const { opName, value } = op;
+        switch (opName) {
+            case "add": {
+                this.ackAdd(value, local, message, localOpMetadata);
+                break;
+            }
+            case "delete": {
+                this.ackDelete(value, local, message);
+                break;
+            }
+            case "change": {
+                this.ackChange(value, local, message, localOpMetadata);
+                break;
+            }
+            default:
+                unreachableCase(opName);
+        }
+    }
+    resubmitMessage(op, localOpMetadata) {
+        const { opName, value } = op;
+        const { localSeq } = localOpMetadata;
+        const rebasedValue = opName === "delete" ? value : this.rebaseLocalInterval(opName, value, localSeq);
+        if (rebasedValue === undefined) {
+            return undefined;
+        }
+        this.submitDelta({ opName, value: rebasedValue }, localOpMetadata);
+    }
+    applyStashedOp(op) {
+        const { opName, value } = op;
+        const { id, properties } = getSerializedProperties(value);
+        switch (opName) {
+            case "add": {
+                this.add({
+                    id,
+                    // Todo: we should improve typing so we know add ops always have start and end
+                    start: toSequencePlace(value.start, value.startSide),
+                    end: toSequencePlace(value.end, value.endSide),
+                    props: properties,
+                });
+                break;
+            }
+            case "change": {
+                this.change(id, {
+                    start: toOptionalSequencePlace(value.start, value.startSide),
+                    end: toOptionalSequencePlace(value.end, value.endSide),
+                    props: properties,
+                });
+                break;
+            }
+            case "delete": {
+                this.removeIntervalById(id);
+                break;
+            }
+            default:
+                throw new Error("unknown ops should not be stashed");
+        }
+    }
     rebasePositionWithSegmentSlide(pos, seqNumberFrom, localSeq) {
         if (!this.client) {
             throw new LoggingError("mergeTree client must exist");
@@ -353,7 +327,7 @@ export class IntervalCollection extends TypedEventEmitter {
         }, localSeq);
         // if segment is undefined, it slid off the string
         assert(segment !== undefined, 0x54e /* No segment found */);
-        const segoff = getSlideToSegoff({ segment, offset }, undefined, this.options.mergeTreeReferencesCanSlideToEndpoint) ?? segment;
+        const segoff = getSlideToSegoff({ segment, offset }, undefined, createLocalReconnectingPerspective(this.client.getCurrentSeq(), clientId, localSeq), this.options.mergeTreeReferencesCanSlideToEndpoint) ?? segment;
         // case happens when rebasing op, but concurrently entire string has been deleted
         if (segoff.segment === undefined || segoff.offset === undefined) {
             return DetachedReferencePosition;
@@ -394,18 +368,15 @@ export class IntervalCollection extends TypedEventEmitter {
         this.localCollection = new LocalIntervalCollection(client, label, this.options, (interval, previousInterval) => this.emitChange(interval, previousInterval, true, true));
         if (this.savedSerializedIntervals) {
             for (const serializedInterval of this.savedSerializedIntervals) {
-                this.localCollection.ensureSerializedId(serializedInterval);
-                const { start: startPos, end: endPos, intervalType, properties, startSide, endSide, } = serializedInterval;
+                const { id, properties } = getSerializedProperties(serializedInterval);
+                const { start: startPos, end: endPos, intervalType, startSide, endSide, } = serializedInterval;
                 const start = typeof startPos === "number" && startSide !== undefined
                     ? { pos: startPos, side: startSide }
                     : startPos;
                 const end = typeof endPos === "number" && endSide !== undefined
                     ? { pos: endPos, side: endSide }
                     : endPos;
-                const interval = createSequenceInterval(label, start, end, client, intervalType, undefined, true, this.options.mergeTreeReferencesCanSlideToEndpoint);
-                if (properties) {
-                    interval.properties = addProperties(interval.properties, properties);
-                }
+                const interval = createSequenceInterval(label, id, start, end, client, intervalType, undefined, true, this.options.mergeTreeReferencesCanSlideToEndpoint, properties);
                 this.localCollection.add(interval);
             }
         }
@@ -451,7 +422,7 @@ export class IntervalCollection extends TypedEventEmitter {
     /**
      * {@inheritdoc IIntervalCollection.add}
      */
-    add({ start, end, props, }) {
+    add({ id, start, end, props, }) {
         if (!this.localCollection) {
             throw new LoggingError("attach must be called prior to adding intervals");
         }
@@ -460,24 +431,14 @@ export class IntervalCollection extends TypedEventEmitter {
             endPos !== undefined &&
             startSide !== undefined &&
             endSide !== undefined, 0x793 /* start and end cannot be undefined because they were not passed in as undefined */);
-        const stickiness = computeStickinessFromSide(startPos, startSide, endPos, endSide);
         this.assertStickinessEnabled(start, end);
-        const interval = this.localCollection.addInterval(toSequencePlace(startPos, startSide), toSequencePlace(endPos, endSide), IntervalType.SlideOnRemove, props);
+        const interval = this.localCollection.addInterval(id ?? uuid(), toSequencePlace(startPos, startSide), toSequencePlace(endPos, endSide), props);
         if (interval) {
             if (!this.isCollaborating) {
                 setSlideOnRemove(interval.start);
                 setSlideOnRemove(interval.end);
             }
-            const serializedInterval = {
-                start: startPos,
-                end: endPos,
-                intervalType: IntervalType.SlideOnRemove,
-                properties: { ...interval.properties },
-                sequenceNumber: this.client?.getCurrentSeq() ?? 0,
-                stickiness,
-                startSide,
-                endSide,
-            };
+            const serializedInterval = interval.serialize();
             const localSeq = this.getNextLocalSeq();
             if (this.isCollaborating) {
                 this.localSeqToSerializedInterval.set(localSeq, serializedInterval);
@@ -554,29 +515,21 @@ export class IntervalCollection extends TypedEventEmitter {
             let deltaProps;
             let newInterval;
             if (props !== undefined) {
-                interval.propertyManager ??= new PropertiesManager();
-                deltaProps = interval.propertyManager.handleProperties({ props }, interval, this.isCollaborating ? UnassignedSequenceNumber : UniversalSequenceNumber, UniversalSequenceNumber, true);
+                deltaProps = interval.changeProperties(props);
             }
-            if (start !== undefined && end !== undefined) {
+            const changeEndpoints = start !== undefined && end !== undefined;
+            if (changeEndpoints) {
                 newInterval = this.localCollection.changeInterval(interval, start, end);
                 if (!this.isCollaborating && newInterval !== undefined) {
                     setSlideOnRemove(newInterval.start);
                     setSlideOnRemove(newInterval.end);
                 }
             }
-            const serializedInterval = interval.serialize();
-            const { startPos, startSide, endPos, endSide } = endpointPosAndSide(start, end);
-            const stickiness = computeStickinessFromSide(startPos, startSide, endPos, endSide);
-            serializedInterval.start = startPos;
-            serializedInterval.end = endPos;
-            serializedInterval.startSide = startSide;
-            serializedInterval.endSide = endSide;
-            serializedInterval.stickiness = stickiness;
             // Emit a property bag containing the ID and the other (if any) properties changed
-            serializedInterval.properties = {
-                [reservedIntervalIdKey]: interval.getIntervalId(),
-                ...props,
-            };
+            const serializedInterval = (newInterval ?? interval).serializeDelta({
+                props,
+                includeEndpoints: changeEndpoints,
+            });
             const localSeq = this.getNextLocalSeq();
             if (this.isCollaborating) {
                 this.localSeqToSerializedInterval.set(localSeq, serializedInterval);
@@ -626,7 +579,7 @@ export class IntervalCollection extends TypedEventEmitter {
     }
     removePendingChange(serializedInterval) {
         // Change ops always have an ID.
-        const id = serializedInterval.properties?.[reservedIntervalIdKey];
+        const { id } = getSerializedProperties(serializedInterval);
         if (serializedInterval.start !== undefined) {
             this.removePendingChangeHelper(id, this.pendingChangesStart, serializedInterval);
         }
@@ -668,7 +621,7 @@ export class IntervalCollection extends TypedEventEmitter {
         // Note that the ID is in the property bag only to allow us to find the interval.
         // This API cannot change the ID, and writing to the ID property will result in an exception. So we
         // strip it out of the properties here.
-        const { [reservedIntervalIdKey]: id, ...newProps } = serializedInterval.properties ?? {};
+        const { id, properties } = getSerializedProperties(serializedInterval);
         assert(id !== undefined, 0x3fe /* id must exist on the interval */);
         const interval = this.getIntervalById(id);
         if (!interval) {
@@ -676,11 +629,7 @@ export class IntervalCollection extends TypedEventEmitter {
             return;
         }
         if (local) {
-            interval.propertyManager ??= new PropertiesManager();
-            // Let the propertyManager prune its pending change-properties set.
-            interval.propertyManager.ack(op.sequenceNumber, op.minimumSequenceNumber, {
-                props: newProps,
-            });
+            interval.ackPropertiesChange(properties, op);
             this.ackInterval(interval, op);
         }
         else {
@@ -702,15 +651,14 @@ export class IntervalCollection extends TypedEventEmitter {
                 newInterval =
                     this.localCollection.changeInterval(interval, toOptionalSequencePlace(start, serializedInterval.startSide ?? Side.Before), toOptionalSequencePlace(end, serializedInterval.endSide ?? Side.Before), op) ?? interval;
             }
-            newInterval.propertyManager ??= new PropertiesManager();
-            const deltaProps = newInterval.propertyManager.handleProperties({ props: newProps }, newInterval, op.sequenceNumber, op.minimumSequenceNumber, true);
+            const deltaProps = newInterval.changeProperties(properties, op);
             if (this.onDeserialize) {
                 this.onDeserialize(newInterval);
             }
             if (newInterval !== interval) {
                 this.emitChange(newInterval, interval, local, false, op);
             }
-            const changedProperties = Object.keys(newProps).length > 0;
+            const changedProperties = Object.keys(properties).length > 0;
             if (changedProperties) {
                 this.emit("propertyChanged", interval, deltaProps, local, op);
                 this.emit("changed", interval, deltaProps, undefined, local, false);
@@ -747,9 +695,9 @@ export class IntervalCollection extends TypedEventEmitter {
             throw new LoggingError("attachSequence must be called");
         }
         const { intervalType, properties, stickiness, startSide, endSide } = serializedInterval;
+        const { id } = getSerializedProperties(serializedInterval);
         const { start: startRebased, end: endRebased } = this.localSeqToRebasedInterval.get(localSeq) ?? this.computeRebasedPositions(localSeq);
-        const intervalId = properties?.[reservedIntervalIdKey];
-        const localInterval = this.localCollection?.idIntervalIndex.getIntervalById(intervalId);
+        const localInterval = this.localCollection?.idIntervalIndex.getIntervalById(id);
         const rebased = {
             start: startRebased,
             end: endRebased,
@@ -762,9 +710,9 @@ export class IntervalCollection extends TypedEventEmitter {
         };
         if (opName === "change" &&
             // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- ?? is not logically equivalent when .hasPendingChangeStart returns false.
-            (this.hasPendingChangeStart(intervalId) || this.hasPendingChangeEnd(intervalId))) {
+            (this.hasPendingChangeStart(id) || this.hasPendingChangeEnd(id))) {
             this.removePendingChange(serializedInterval);
-            this.addPendingChange(intervalId, rebased);
+            this.addPendingChange(id, rebased);
         }
         // if the interval slid off the string, rebase the op to be a noop and delete the interval.
         if (!this.options.mergeTreeReferencesCanSlideToEndpoint &&
@@ -792,7 +740,7 @@ export class IntervalCollection extends TypedEventEmitter {
         if (segoff.segment?.localRefs?.has(lref) !== true) {
             return undefined;
         }
-        const newSegoff = getSlideToSegoff(segoff, slidingPreference, this.options.mergeTreeReferencesCanSlideToEndpoint);
+        const newSegoff = getSlideToSegoff(segoff, slidingPreference, undefined, this.options.mergeTreeReferencesCanSlideToEndpoint);
         const value = segoff.segment === newSegoff.segment && segoff.offset === newSegoff.offset
             ? undefined
             : newSegoff;
@@ -805,7 +753,7 @@ export class IntervalCollection extends TypedEventEmitter {
         }
         const newStart = this.getSlideToSegment(interval.start, startReferenceSlidingPreference(interval.stickiness));
         const newEnd = this.getSlideToSegment(interval.end, endReferenceSlidingPreference(interval.stickiness));
-        const id = interval.properties[reservedIntervalIdKey];
+        const id = interval.getIntervalId();
         const hasPendingStartChange = this.hasPendingChangeStart(id);
         const hasPendingEndChange = this.hasPendingChangeEnd(id);
         if (!hasPendingStartChange) {
@@ -858,10 +806,10 @@ export class IntervalCollection extends TypedEventEmitter {
         }
     }
     ackAdd(serializedInterval, local, op, localOpMetadata) {
+        const { id, properties } = getSerializedProperties(serializedInterval);
         if (local) {
             assert(localOpMetadata !== undefined, 0x553 /* op metadata should be defined for local op */);
             this.localSeqToSerializedInterval.delete(localOpMetadata.localSeq);
-            const id = serializedInterval.properties?.[reservedIntervalIdKey];
             const localInterval = this.getIntervalById(id);
             if (localInterval) {
                 this.ackInterval(localInterval, op);
@@ -871,8 +819,7 @@ export class IntervalCollection extends TypedEventEmitter {
         if (!this.localCollection) {
             throw new LoggingError("attachSequence must be called");
         }
-        this.localCollection.ensureSerializedId(serializedInterval);
-        const interval = this.localCollection.addInterval(toSequencePlace(serializedInterval.start, serializedInterval.startSide ?? Side.Before), toSequencePlace(serializedInterval.end, serializedInterval.endSide ?? Side.Before), serializedInterval.intervalType, serializedInterval.properties, op);
+        const interval = this.localCollection.addInterval(id, toSequencePlace(serializedInterval.start, serializedInterval.startSide ?? Side.Before), toSequencePlace(serializedInterval.end, serializedInterval.endSide ?? Side.Before), properties, op);
         if (interval) {
             if (this.onDeserialize) {
                 this.onDeserialize(interval);
@@ -891,7 +838,7 @@ export class IntervalCollection extends TypedEventEmitter {
         if (!this.localCollection) {
             throw new LoggingError("attach must be called prior to deleting intervals");
         }
-        const id = this.localCollection.ensureSerializedId(serializedInterval);
+        const { id } = getSerializedProperties(serializedInterval);
         const interval = this.localCollection.idIntervalIndex.getIntervalById(id);
         if (interval) {
             this.deleteExistingInterval(interval, local, op);