@fluidframework/sequence 1.2.0 → 2.0.0-internal.1.0.0.81589

package/lib/intervalCollection.js

@@ -16,7 +16,7 @@ var __rest = (this && this.__rest) || function (s, e) {
 /* eslint-disable no-bitwise */
 import { assert, TypedEventEmitter } from "@fluidframework/common-utils";
 import { UsageError } from "@fluidframework/container-utils";
-import { addProperties, createMap, IntervalTree, LocalReference, MergeTreeDeltaType, PropertiesManager, RedBlackTree, ReferenceType, refTypeIncludesFlag, reservedRangeLabelsKey, UnassignedSequenceNumber, } from "@fluidframework/merge-tree";
+import { addProperties, compareReferencePositions, createMap, IntervalTree, MergeTreeDeltaType, minReferencePosition, PropertiesManager, RedBlackTree, ReferenceType, refTypeIncludesFlag, reservedRangeLabelsKey, UnassignedSequenceNumber, maxReferencePosition, createDetachedLocalReferencePosition, } from "@fluidframework/merge-tree";
 import { LoggingError } from "@fluidframework/telemetry-utils";
 import { v4 as uuid } from "uuid";
 const reservedIntervalIdKey = "intervalId";
@@ -180,7 +180,8 @@ export class Interval {
     }
 }
 export class SequenceInterval {
-    constructor(start, end, intervalType, props) {
+    constructor(client, start, end, intervalType, props) {
+        this.client = client;
         this.start = start;
         this.end = end;
         this.intervalType = intervalType;
@@ -220,8 +221,8 @@ export class SequenceInterval {
         }
     }
     serialize(client) {
-        const startPosition = this.start.toPosition();
-        const endPosition = this.end.toPosition();
+        const startPosition = client.localReferencePositionToPosition(this.start);
+        const endPosition = client.localReferencePositionToPosition(this.end);
         const serializedInterval = {
             end: endPosition,
             intervalType: this.intervalType,
@@ -234,7 +235,7 @@ export class SequenceInterval {
         return serializedInterval;
     }
     clone() {
-        return new SequenceInterval(this.start, this.end, this.intervalType, this.properties);
+        return new SequenceInterval(this.client, this.start, this.end, this.intervalType, this.properties);
     }
     compare(b) {
         const startResult = this.compareStart(b);
@@ -260,14 +261,14 @@ export class SequenceInterval {
         }
     }
     compareStart(b) {
-        return this.start.compare(b.start);
+        return compareReferencePositions(this.start, b.start);
     }
     compareEnd(b) {
-        return this.end.compare(b.end);
+        return compareReferencePositions(this.end, b.end);
     }
     overlaps(b) {
-        const result = (this.start.compare(b.end) <= 0) &&
-            (this.end.compare(b.start) >= 0);
+        const result = (compareReferencePositions(this.start, b.end) <= 0) &&
+            (compareReferencePositions(this.end, b.start) >= 0);
         return result;
     }
     getIntervalId() {
@@ -279,15 +280,15 @@ export class SequenceInterval {
         return `${id}`;
     }
     union(b) {
-        return new SequenceInterval(this.start.min(b.start), this.end.max(b.end), this.intervalType);
+        return new SequenceInterval(this.client, minReferencePosition(this.start, b.start), maxReferencePosition(this.end, b.end), this.intervalType);
     }
     addProperties(newProps, collab = false, seq, op) {
         this.initializeProperties();
         return this.propertyManager.addProperties(this.properties, newProps, op, seq, collab);
     }
     overlapsPos(bstart, bend) {
-        const startPos = this.start.toPosition();
-        const endPos = this.start.toPosition();
+        const startPos = this.client.localReferencePositionToPosition(this.start);
+        const endPos = this.client.localReferencePositionToPosition(this.end);
         return (endPos > bstart) && (startPos < bend);
     }
     modify(label, start, end, op) {
@@ -301,17 +302,15 @@ export class SequenceInterval {
         };
         let startRef = this.start;
         if (start !== undefined) {
-            startRef = createPositionReference(this.start.getClient(), start, getRefType(this.start.refType), op);
+            startRef = createPositionReference(this.client, start, getRefType(this.start.refType), op);
             startRef.addProperties(this.start.properties);
         }
         let endRef = this.end;
         if (end !== undefined) {
-            endRef = createPositionReference(this.end.getClient(), end, getRefType(this.end.refType), op);
+            endRef = createPositionReference(this.client, end, getRefType(this.end.refType), op);
             endRef.addProperties(this.end.properties);
         }
-        startRef.pairedRef = endRef;
-        endRef.pairedRef = startRef;
-        const newInterval = new SequenceInterval(startRef, endRef, this.intervalType);
+        const newInterval = new SequenceInterval(this.client, startRef, endRef, this.intervalType);
         if (this.properties) {
             newInterval.initializeProperties();
             this.propertyManager.copyTo(this.properties, newInterval.properties, newInterval.propertyManager);
@@ -336,10 +335,10 @@ function createPositionReferenceFromSegoff(client, segoff, refType, op) {
         if (!op && !refTypeIncludesFlag(refType, ReferenceType.Transient)) {
             throw new UsageError("Non-transient references need segment");
         }
-        return new LocalReference(client, undefined, 0, refType);
     }
+    return createDetachedLocalReferencePosition(refType);
 }
-function createPositionReference(client, pos, refType, op) {
+function createPositionReference(client, pos, refType, op, fromSnapshot) {
     let segoff;
     if (op) {
         assert((refType & ReferenceType.SlideOnRemove) !== 0, 0x2f5 /* op create references must be SlideOnRemove */);
@@ -347,12 +346,12 @@ function createPositionReference(client, pos, refType, op) {
         segoff = client.getSlideToSegment(segoff);
     }
     else {
-        assert((refType & ReferenceType.SlideOnRemove) === 0, 0x2f6 /* SlideOnRemove references must be op created */);
+        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.Transient) {
@@ -367,7 +366,7 @@ function createSequenceInterval(label, start, end, client, intervalType, op) {
         // 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) {
+        if (op || fromSnapshot) {
             beginRefType |= ReferenceType.SlideOnRemove;
             endRefType |= ReferenceType.SlideOnRemove;
         }
@@ -376,16 +375,14 @@ function createSequenceInterval(label, start, end, client, intervalType, op) {
             endRefType |= ReferenceType.StayOnRemove;
         }
     }
-    const startLref = createPositionReference(client, start, beginRefType, op);
-    const endLref = createPositionReference(client, end, endRefType, op);
-    startLref.pairedRef = endLref;
-    endLref.pairedRef = startLref;
+    const startLref = createPositionReference(client, start, beginRefType, op, fromSnapshot);
+    const endLref = createPositionReference(client, end, endRefType, op, fromSnapshot);
     const rangeProp = {
         [reservedRangeLabelsKey]: [label],
     };
     startLref.addProperties(rangeProp);
     endLref.addProperties(rangeProp);
-    const ival = new SequenceInterval(startLref, endLref, intervalType, rangeProp);
+    const ival = new SequenceInterval(client, startLref, endLref, intervalType, rangeProp);
     return ival;
 }
 export function defaultIntervalConflictResolver(a, b) {
@@ -641,7 +638,7 @@ export class LocalIntervalCollection {
     }
 }
 LocalIntervalCollection.legacyIdPrefix = "legacy";
-const compareSequenceIntervalEnds = (a, b) => a.end.compare(b.end);
+const compareSequenceIntervalEnds = (a, b) => compareReferencePositions(a.end, b.end);
 class SequenceIntervalCollectionFactory {
     load(emitter, raw = []) {
         const helpers = {
@@ -794,7 +791,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;
@@ -966,10 +966,6 @@ export class IntervalCollection extends TypedEventEmitter {
         const entries = this.pendingChangesEnd.get(id);
         return entries && entries.length !== 0;
     }
-    /** @deprecated - use ackChange */
-    changeInterval(serializedInterval, local, op) {
-        return this.ackChange(serializedInterval, local, op);
-    }
     /** @internal */
     ackChange(serializedInterval, local, op) {
         var _a, _b, _c, _d;
@@ -1069,7 +1065,7 @@ export class IntervalCollection extends TypedEventEmitter {
         return rebased;
     }
     getSlideToSegment(lref) {
-        const segoff = { segment: lref.segment, offset: lref.offset };
+        const segoff = { segment: lref.getSegment(), offset: lref.getOffset() };
         const newSegoff = this.client.getSlideToSegment(segoff);
         const value = (segoff.segment === newSegoff.segment && segoff.offset === newSegoff.offset) ? undefined : newSegoff;
         return value;
@@ -1105,7 +1101,7 @@ export class IntervalCollection extends TypedEventEmitter {
         if (needsStartUpdate || needsEndUpdate) {
             // 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 ReferencePosition.
+            // This ensures that the correct listeners are added to the LocalReferencePosition.
             this.localCollection.removeExistingInterval(interval);
             if (needsStartUpdate) {
                 const props = interval.start.properties;
@@ -1126,10 +1122,6 @@ export class IntervalCollection extends TypedEventEmitter {
             this.localCollection.add(interval);
         }
     }
-    /** @deprecated - use ackAdd */
-    addInternal(serializedInterval, local, op) {
-        return this.ackAdd(serializedInterval, local, op);
-    }
     /** @internal */
     ackAdd(serializedInterval, local, op) {
         var _a;
@@ -1154,10 +1146,6 @@ export class IntervalCollection extends TypedEventEmitter {
         this.emit("addInterval", interval, local, op);
         return interval;
     }
-    /** @deprecated - use ackDelete */
-    deleteInterval(serializedInterval, local, op) {
-        return this.ackDelete(serializedInterval, local, op);
-    }
     /** @internal */
     ackDelete(serializedInterval, local, op) {
         if (local) {