@fluidframework/sequence 0.59.4002 → 1.0.2

package/lib/intervalCollection.js

@@ -15,14 +15,25 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 /* eslint-disable no-bitwise */
 import { assert, TypedEventEmitter } from "@fluidframework/common-utils";
-import { addProperties, createMap, IntervalTree, LocalReference, PropertiesManager, RedBlackTree, ReferenceType, reservedRangeLabelsKey, UnassignedSequenceNumber, } from "@fluidframework/merge-tree";
+import { UsageError } from "@fluidframework/container-utils";
+import { addProperties, createMap, IntervalTree, LocalReference, MergeTreeDeltaType, PropertiesManager, RedBlackTree, ReferenceType, refTypeIncludesFlag, reservedRangeLabelsKey, UnassignedSequenceNumber, } from "@fluidframework/merge-tree";
 import { v4 as uuid } from "uuid";
 const reservedIntervalIdKey = "intervalId";
 export var IntervalType;
 (function (IntervalType) {
     IntervalType[IntervalType["Simple"] = 0] = "Simple";
     IntervalType[IntervalType["Nest"] = 1] = "Nest";
+    /**
+     * SlideOnRemove indicates that the ends of the interval will slide if the segment
+     * they reference is removed and acked.
+     * See `packages\dds\merge-tree\REFERENCEPOSITIONS.md` for details
+     * SlideOnRemove is the default interval behavior and does not need to be specified.
+     */
     IntervalType[IntervalType["SlideOnRemove"] = 2] = "SlideOnRemove";
+    /**
+     * @internal
+     * A temporary interval, used internally
+     */
     IntervalType[IntervalType["Transient"] = 4] = "Transient";
 })(IntervalType || (IntervalType = {}));
 export class Interval {
@@ -229,46 +240,66 @@ export class SequenceInterval {
         return newInterval;
     }
 }
-function createPositionReference(client, pos, refType, op) {
-    const segoff = client.getContainingSegment(pos, op);
-    if (segoff === null || segoff === void 0 ? void 0 : segoff.segment) {
-        const lref = new LocalReference(client, segoff.segment, segoff.offset, refType);
-        if (refType !== ReferenceType.Transient) {
-            client.addLocalReference(lref);
+function createPositionReferenceFromSegoff(client, segoff, refType, op) {
+    if (segoff.segment) {
+        const ref = client.createLocalReferencePosition(segoff.segment, segoff.offset, refType, undefined);
+        return ref;
+    }
+    else {
+        if (!op && !refTypeIncludesFlag(refType, ReferenceType.Transient)) {
+            throw new UsageError("Non-transient references need segment");
         }
-        return lref;
+        return new LocalReference(client, undefined, 0, refType);
+    }
+}
+function createPositionReference(client, pos, refType, op, fromSnapshot) {
+    let segoff;
+    if (op) {
+        assert((refType & ReferenceType.SlideOnRemove) !== 0, 0x2f5 /* op create references must be SlideOnRemove */);
+        segoff = client.getContainingSegment(pos, op);
+        segoff = client.getSlideToSegment(segoff);
     }
-    return new LocalReference(client, undefined);
+    else {
+        assert((refType & ReferenceType.SlideOnRemove) === 0 || fromSnapshot, 0x2f6 /* SlideOnRemove references must be op created */);
+        segoff = client.getContainingSegment(pos);
+    }
+    return createPositionReferenceFromSegoff(client, segoff, refType, op);
 }
-function createSequenceInterval(label, start, end, client, intervalType, op) {
+function createSequenceInterval(label, start, end, client, intervalType, op, fromSnapshot) {
     let beginRefType = ReferenceType.RangeBegin;
     let endRefType = ReferenceType.RangeEnd;
-    if (intervalType === IntervalType.Nest) {
-        beginRefType = ReferenceType.NestBegin;
-        endRefType = ReferenceType.NestEnd;
-    }
-    else if (intervalType === IntervalType.Transient) {
+    if (intervalType === IntervalType.Transient) {
         beginRefType = ReferenceType.Transient;
         endRefType = ReferenceType.Transient;
     }
-    // TODO: Should SlideOnRemove be the default behavior?
-    if (intervalType & IntervalType.SlideOnRemove) {
-        beginRefType |= ReferenceType.SlideOnRemove;
-        endRefType |= ReferenceType.SlideOnRemove;
-    }
-    const startLref = createPositionReference(client, start, beginRefType, op);
-    const endLref = createPositionReference(client, end, endRefType, op);
-    if (startLref && endLref) {
-        startLref.pairedRef = endLref;
-        endLref.pairedRef = startLref;
-        const rangeProp = {
-            [reservedRangeLabelsKey]: [label],
-        };
-        startLref.addProperties(rangeProp);
-        endLref.addProperties(rangeProp);
-        const ival = new SequenceInterval(startLref, endLref, intervalType, rangeProp);
-        return ival;
+    else {
+        if (intervalType === IntervalType.Nest) {
+            beginRefType = ReferenceType.NestBegin;
+            endRefType = ReferenceType.NestEnd;
+        }
+        // All non-transient interval references must eventually be SlideOnRemove
+        // To ensure eventual consistency, they must start as StayOnRemove when
+        // pending (created locally and creation op is not acked)
+        if (op || fromSnapshot) {
+            beginRefType |= ReferenceType.SlideOnRemove;
+            endRefType |= ReferenceType.SlideOnRemove;
+        }
+        else {
+            beginRefType |= ReferenceType.StayOnRemove;
+            endRefType |= ReferenceType.StayOnRemove;
+        }
     }
+    const startLref = createPositionReference(client, start, beginRefType, op, fromSnapshot);
+    const endLref = createPositionReference(client, end, endRefType, op, fromSnapshot);
+    startLref.pairedRef = endLref;
+    endLref.pairedRef = startLref;
+    const rangeProp = {
+        [reservedRangeLabelsKey]: [label],
+    };
+    startLref.addProperties(rangeProp);
+    endLref.addProperties(rangeProp);
+    const ival = new SequenceInterval(startLref, endLref, intervalType, rangeProp);
+    return ival;
 }
 export function defaultIntervalConflictResolver(a, b) {
     a.addPropertySet(b.properties);
@@ -398,14 +429,12 @@ export class LocalIntervalCollection {
         }
     }
     findOverlappingIntervals(startPosition, endPosition) {
-        if (!this.intervalTree.intervals.isEmpty()) {
-            const transientInterval = this.helpers.create("transient", startPosition, endPosition, this.client, IntervalType.Transient);
-            const overlappingIntervalNodes = this.intervalTree.match(transientInterval);
-            return overlappingIntervalNodes.map((node) => node.key);
-        }
-        else {
+        if (endPosition < startPosition || this.intervalTree.intervals.isEmpty()) {
             return [];
         }
+        const transientInterval = this.helpers.create("transient", startPosition, endPosition, this.client, IntervalType.Transient);
+        const overlappingIntervalNodes = this.intervalTree.match(transientInterval);
+        return overlappingIntervalNodes.map((node) => node.key);
     }
     previousInterval(pos) {
         const transientInterval = this.helpers.create("transient", pos, pos, this.client, IntervalType.Transient);
@@ -642,7 +671,10 @@ export class IntervalCollection extends TypedEventEmitter {
         if (this.savedSerializedIntervals) {
             for (const serializedInterval of this.savedSerializedIntervals) {
                 this.localCollection.ensureSerializedId(serializedInterval);
-                this.localCollection.addInterval(serializedInterval.start, serializedInterval.end, serializedInterval.intervalType, serializedInterval.properties);
+                const { start, end, intervalType, properties } = serializedInterval;
+                const interval = this.helpers.create(label, start, end, client, intervalType, undefined, true);
+                interval.addProperties(properties);
+                this.localCollection.add(interval);
             }
         }
         this.savedSerializedIntervals = undefined;
@@ -653,11 +685,22 @@ export class IntervalCollection extends TypedEventEmitter {
         }
         return this.localCollection.getIntervalById(id);
     }
+    /**
+     * Create a new interval and add it to the collection
+     * @param start - interval start position
+     * @param end - interval end position
+     * @param intervalType - type of the interval. All intervals are SlideOnRemove. Intervals may not be Transient.
+     * @param props - properties of the interval
+     * @returns - the created interval
+     */
     add(start, end, intervalType, props) {
         var _a, _b;
         if (!this.attached) {
             throw new Error("attach must be called prior to adding intervals");
         }
+        if (intervalType & IntervalType.Transient) {
+            throw new Error("Can not add transient intervals");
+        }
         const interval = this.localCollection.addInterval(start, end, intervalType, props);
         if (interval) {
             const serializedInterval = {
@@ -816,13 +859,15 @@ export class IntervalCollection extends TypedEventEmitter {
             // This is an ack from the server. Remove the pending change.
             this.removePendingChange(serializedInterval);
             const id = serializedInterval.properties[reservedIntervalIdKey];
+            // Could store the interval in the localOpMetadata to avoid the getIntervalById call
             interval = this.getIntervalById(id);
             if (interval) {
                 // Let the propertyManager prune its pending change-properties set.
                 (_a = interval.propertyManager) === null || _a === void 0 ? void 0 : _a.ackPendingProperties({
-                    type: 2 /* ANNOTATE */,
+                    type: MergeTreeDeltaType.ANNOTATE,
                     props: serializedInterval.properties,
                 });
+                this.ackInterval(interval, op);
             }
         }
         else {
@@ -877,6 +922,46 @@ export class IntervalCollection extends TypedEventEmitter {
             this.onDeserialize(interval);
         });
     }
+    getSlideToSegment(lref) {
+        const segoff = { segment: lref.segment, offset: lref.offset };
+        const newSegoff = this.client.getSlideToSegment(segoff);
+        const value = (segoff === newSegoff) ? undefined : newSegoff;
+        return value;
+    }
+    setSlideOnRemove(lref) {
+        let refType = lref.refType;
+        refType = refType & ~ReferenceType.StayOnRemove;
+        refType = refType | ReferenceType.SlideOnRemove;
+        lref.refType = refType;
+    }
+    ackInterval(interval, op) {
+        // in current usage, interval is always a SequenceInterval
+        if (!(interval instanceof SequenceInterval)) {
+            return;
+        }
+        if (!refTypeIncludesFlag(interval.start, ReferenceType.StayOnRemove)) {
+            return;
+        }
+        assert(refTypeIncludesFlag(interval.end, ReferenceType.StayOnRemove), 0x2f7 /* start and end must both be StayOnRemove */);
+        const newStart = this.getSlideToSegment(interval.start);
+        const newEnd = this.getSlideToSegment(interval.end);
+        this.setSlideOnRemove(interval.start);
+        this.setSlideOnRemove(interval.end);
+        if (newStart || newEnd) {
+            this.localCollection.removeExistingInterval(interval);
+            if (newStart) {
+                const props = interval.start.properties;
+                interval.start = createPositionReferenceFromSegoff(this.client, newStart, interval.start.refType, op);
+                interval.start.addProperties(props);
+            }
+            if (newEnd) {
+                const props = interval.end.properties;
+                interval.end = createPositionReferenceFromSegoff(this.client, newEnd, interval.end.refType, op);
+                interval.end.addProperties(props);
+            }
+            this.localCollection.add(interval);
+        }
+    }
     /** @deprecated - use ackAdd */
     addInternal(serializedInterval, local, op) {
         return this.ackAdd(serializedInterval, local, op);
@@ -884,8 +969,12 @@ export class IntervalCollection extends TypedEventEmitter {
     /** @internal */
     ackAdd(serializedInterval, local, op) {
         if (local) {
-            // Local ops were applied when the message was created and there's no "pending add"
-            // state to bookkeep
+            const id = serializedInterval.properties[reservedIntervalIdKey];
+            // Could store the interval in the localOpMetadata to avoid the getIntervalById call
+            const localInterval = this.getIntervalById(id);
+            if (localInterval) {
+                this.ackInterval(localInterval, op);
+            }
             return;
         }
         if (!this.attached) {