@fluidframework/sequence 1.2.7 → 2.0.0-dev.1.3.0.96595

package/dist/intervalCollection.js

@@ -15,7 +15,7 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IntervalCollection = exports.IntervalCollectionIterator = exports.IntervalCollectionValueType = exports.SequenceIntervalCollectionValueType = exports.LocalIntervalCollection = exports.createIntervalIndex = exports.defaultIntervalConflictResolver = exports.SequenceInterval = exports.Interval = exports.IntervalType = void 0;
+exports.intervalLocatorFromEndpoint = exports.IntervalCollection = exports.IntervalCollectionIterator = exports.IntervalCollectionValueType = exports.SequenceIntervalCollectionValueType = exports.LocalIntervalCollection = exports.createIntervalIndex = exports.defaultIntervalConflictResolver = exports.SequenceInterval = exports.Interval = exports.IntervalType = void 0;
 /* eslint-disable no-bitwise */
 const common_utils_1 = require("@fluidframework/common-utils");
 const container_utils_1 = require("@fluidframework/container-utils");
@@ -35,8 +35,8 @@ var IntervalType;
      */
     IntervalType[IntervalType["SlideOnRemove"] = 2] = "SlideOnRemove";
     /**
-     * @internal
      * A temporary interval, used internally
+     * @internal
      */
     IntervalType[IntervalType["Transient"] = 4] = "Transient";
 })(IntervalType = exports.IntervalType || (exports.IntervalType = {}));
@@ -50,7 +50,7 @@ function decompressInterval(interval, label) {
         end: interval[1],
         sequenceNumber: interval[2],
         intervalType: interval[3],
-        properties: Object.assign(Object.assign({}, interval[4]), { [merge_tree_1.reservedRangeLabelsKey]: label }),
+        properties: Object.assign(Object.assign({}, interval[4]), { [merge_tree_1.reservedRangeLabelsKey]: [label] }),
     };
 }
 /**
@@ -95,10 +95,8 @@ class Interval {
         this.auxProps.push(props);
     }
     serialize(client) {
-        let seq = 0;
-        if (client) {
-            seq = client.getCurrentSeq();
-        }
+        var _a;
+        const seq = (_a = client === null || client === void 0 ? void 0 : client.getCurrentSeq()) !== null && _a !== void 0 ? _a : 0;
         const serializedInterval = {
             end: this.end,
             intervalType: 0,
@@ -184,7 +182,8 @@ class Interval {
 }
 exports.Interval = Interval;
 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;
@@ -195,8 +194,8 @@ class SequenceInterval {
         }
     }
     /**
-     * @internal
      * Subscribes to position change events on this interval if there are no current listeners.
+     * @internal
      */
     addPositionChangeListeners(beforePositionChange, afterPositionChange) {
         var _a, _b;
@@ -213,8 +212,8 @@ class SequenceInterval {
         }
     }
     /**
-     * @internal
      * Removes the currently subscribed position change listeners.
+     * @internal
      */
     removePositionChangeListeners() {
         if (this.callbacks) {
@@ -224,8 +223,8 @@ 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,
@@ -238,7 +237,7 @@ 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);
@@ -264,14 +263,14 @@ class SequenceInterval {
         }
     }
     compareStart(b) {
-        return this.start.compare(b.start);
+        return (0, merge_tree_1.compareReferencePositions)(this.start, b.start);
     }
     compareEnd(b) {
-        return this.end.compare(b.end);
+        return (0, merge_tree_1.compareReferencePositions)(this.end, b.end);
     }
     overlaps(b) {
-        const result = (this.start.compare(b.end) <= 0) &&
-            (this.end.compare(b.start) >= 0);
+        const result = ((0, merge_tree_1.compareReferencePositions)(this.start, b.end) <= 0) &&
+            ((0, merge_tree_1.compareReferencePositions)(this.end, b.start) >= 0);
         return result;
     }
     getIntervalId() {
@@ -283,18 +282,18 @@ 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, (0, merge_tree_1.minReferencePosition)(this.start, b.start), (0, merge_tree_1.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) {
+    modify(label, start, end, op, localSeq) {
         const getRefType = (baseType) => {
             let refType = baseType;
             if (op === undefined) {
@@ -305,17 +304,15 @@ 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, undefined, localSeq);
             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, undefined, localSeq);
             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);
@@ -337,14 +334,13 @@ function createPositionReferenceFromSegoff(client, segoff, refType, op) {
         const ref = client.createLocalReferencePosition(segoff.segment, segoff.offset, refType, undefined);
         return ref;
     }
-    else {
-        if (!op && !(0, merge_tree_1.refTypeIncludesFlag)(refType, merge_tree_1.ReferenceType.Transient)) {
-            throw new container_utils_1.UsageError("Non-transient references need segment");
-        }
-        return new merge_tree_1.LocalReference(client, undefined, 0, refType);
+    if (!op && !(0, merge_tree_1.refTypeIncludesFlag)(refType, merge_tree_1.ReferenceType.Transient)) {
+        // reference to segment that dne locally
+        throw new container_utils_1.UsageError("Non-transient references need segment");
     }
+    return (0, merge_tree_1.createDetachedLocalReferencePosition)(refType);
 }
-function createPositionReference(client, pos, refType, op, fromSnapshot) {
+function createPositionReference(client, pos, refType, op, fromSnapshot, localSeq) {
     let segoff;
     if (op) {
         (0, common_utils_1.assert)((refType & merge_tree_1.ReferenceType.SlideOnRemove) !== 0, 0x2f5 /* op create references must be SlideOnRemove */);
@@ -353,7 +349,7 @@ function createPositionReference(client, pos, refType, op, fromSnapshot) {
     }
     else {
         (0, common_utils_1.assert)((refType & merge_tree_1.ReferenceType.SlideOnRemove) === 0 || fromSnapshot, 0x2f6 /* SlideOnRemove references must be op created */);
-        segoff = client.getContainingSegment(pos);
+        segoff = client.getContainingSegment(pos, undefined, localSeq);
     }
     return createPositionReferenceFromSegoff(client, segoff, refType, op);
 }
@@ -383,14 +379,12 @@ function createSequenceInterval(label, start, end, client, intervalType, op, fro
     }
     const startLref = createPositionReference(client, start, beginRefType, op, fromSnapshot);
     const endLref = createPositionReference(client, end, endRefType, op, fromSnapshot);
-    startLref.pairedRef = endLref;
-    endLref.pairedRef = startLref;
     const rangeProp = {
         [merge_tree_1.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;
 }
 function defaultIntervalConflictResolver(a, b) {
@@ -579,6 +573,8 @@ class LocalIntervalCollection {
         return this.helpers.create(this.label, start, end, this.client, intervalType, op);
     }
     addInterval(start, end, intervalType, props, op) {
+        var _a;
+        var _b;
         const interval = this.createInterval(start, end, intervalType, op);
         if (interval) {
             if (!interval.properties) {
@@ -587,14 +583,17 @@ class LocalIntervalCollection {
             if (props) {
                 interval.addProperties(props);
             }
-            if (interval.properties[reservedIntervalIdKey] === undefined) {
-                // Create a new ID.
-                interval.properties[reservedIntervalIdKey] = (0, uuid_1.v4)();
-            }
+            (_a = (_b = interval.properties)[reservedIntervalIdKey]) !== null && _a !== void 0 ? _a : (_b[reservedIntervalIdKey] = (0, uuid_1.v4)());
             this.add(interval);
         }
         return interval;
     }
+    linkEndpointsToInterval(interval) {
+        if (interval instanceof SequenceInterval) {
+            interval.start.addProperties({ interval });
+            interval.end.addProperties({ interval });
+        }
+    }
     addIntervalToIndex(interval) {
         const id = interval.getIntervalId();
         (0, common_utils_1.assert)(id !== undefined, 0x2c0 /* "ID must be created before adding interval to collection" */);
@@ -609,14 +608,15 @@ class LocalIntervalCollection {
         this.intervalIdMap.set(id, interval);
     }
     add(interval) {
+        this.linkEndpointsToInterval(interval);
         this.addIntervalToIndex(interval);
         this.addIntervalListeners(interval);
     }
     getIntervalById(id) {
         return this.intervalIdMap.get(id);
     }
-    changeInterval(interval, start, end, op) {
-        const newInterval = interval.modify(this.label, start, end, op);
+    changeInterval(interval, start, end, op, localSeq) {
+        const newInterval = interval.modify(this.label, start, end, op, localSeq);
         if (newInterval) {
             this.removeExistingInterval(interval);
             this.add(newInterval);
@@ -649,7 +649,7 @@ class LocalIntervalCollection {
 }
 exports.LocalIntervalCollection = LocalIntervalCollection;
 LocalIntervalCollection.legacyIdPrefix = "legacy";
-const compareSequenceIntervalEnds = (a, b) => a.end.compare(b.end);
+const compareSequenceIntervalEnds = (a, b) => (0, merge_tree_1.compareReferencePositions)(a.end, b.end);
 class SequenceIntervalCollectionFactory {
     load(emitter, raw = []) {
         const helpers = {
@@ -725,6 +725,11 @@ function makeOpsMap() {
             "add",
             {
                 process: (collection, params, local, op) => {
+                    // if params is undefined, the interval was deleted during
+                    // rebasing
+                    if (!params) {
+                        return;
+                    }
                     collection.ackAdd(params, local, op);
                 },
                 rebase,
@@ -746,6 +751,11 @@ function makeOpsMap() {
             "change",
             {
                 process: (collection, params, local, op) => {
+                    // if params is undefined, the interval was deleted during
+                    // rebasing
+                    if (!params) {
+                        return;
+                    }
                     collection.ackChange(params, local, op);
                 },
                 rebase,
@@ -781,13 +791,9 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         this.emitter = emitter;
         this.pendingChangesStart = new Map();
         this.pendingChangesEnd = new Map();
-        if (Array.isArray(serializedIntervals)) {
-            this.savedSerializedIntervals = serializedIntervals;
-        }
-        else {
-            this.savedSerializedIntervals =
-                serializedIntervals.intervals.map((i) => decompressInterval(i, serializedIntervals.label));
-        }
+        this.savedSerializedIntervals = Array.isArray(serializedIntervals)
+            ? serializedIntervals
+            : serializedIntervals.intervals.map((i) => decompressInterval(i, serializedIntervals.label));
     }
     get attached() {
         return !!this.localCollection;
@@ -817,7 +823,10 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
      * Gets the next local sequence number, modifying this client's collab window in doing so.
      */
     getNextLocalSeq() {
-        return ++this.client.getCollabWindow().localSeq;
+        if (this.client) {
+            return ++this.client.getCollabWindow().localSeq;
+        }
+        return 0;
     }
     getIntervalById(id) {
         if (!this.attached) {
@@ -980,10 +989,6 @@ class IntervalCollection extends common_utils_1.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;
@@ -1057,9 +1062,19 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
             onDeserialize(interval);
         });
     }
-    /** @internal */
+    /**
+     * Returns new interval after rebasing. If undefined, the interval was
+     * deleted as a result of rebasing. This can occur if the interval applies
+     * to a range that no longer exists, and the interval was unable to slide.
+     *
+     * @internal
+     */
     rebaseLocalInterval(opName, serializedInterval, localSeq) {
         var _a, _b;
+        if (!this.client) {
+            // If there's no associated mergeTree client, the originally submitted op is still correct.
+            return serializedInterval;
+        }
         if (!this.attached) {
             throw new telemetry_utils_1.LoggingError("attachSequence must be called");
         }
@@ -1069,6 +1084,7 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         const endRebased = end === undefined ? undefined :
             this.client.rebasePosition(end, sequenceNumber, localSeq);
         const intervalId = properties === null || properties === void 0 ? void 0 : properties[reservedIntervalIdKey];
+        const localInterval = this.localCollection.getIntervalById(intervalId);
         const rebased = {
             start: startRebased,
             end: endRebased,
@@ -1080,10 +1096,31 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
             this.removePendingChange(serializedInterval);
             this.addPendingChange(intervalId, rebased);
         }
+        // if the interval slid off the string, rebase the op to be a noop and
+        // delete the interval
+        if (startRebased === merge_tree_1.DetachedReferencePosition || endRebased === merge_tree_1.DetachedReferencePosition) {
+            if (localInterval) {
+                this.localCollection.removeExistingInterval(localInterval);
+            }
+            return undefined;
+        }
+        if (!localInterval) {
+            return rebased;
+        }
+        // we know we must be using `SequenceInterval` because `this.client` exists
+        (0, common_utils_1.assert)(localInterval instanceof SequenceInterval, 0x3a0 /* localInterval must be `SequenceInterval` when used with client */);
+        const startSegment = this.getSlideToSegment(localInterval.start);
+        const endSegment = this.getSlideToSegment(localInterval.end);
+        // we need to slide because the reference has been removed
+        if (startSegment || endSegment) {
+            const newStart = startSegment && this.client.getPosition(startSegment.segment, localSeq) + startSegment.offset;
+            const newEnd = endSegment && this.client.getPosition(endSegment.segment, localSeq) + endSegment.offset;
+            this.localCollection.changeInterval(localInterval, newStart, newEnd, undefined, localSeq);
+        }
         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;
@@ -1095,7 +1132,7 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         lref.refType = refType;
     }
     ackInterval(interval, op) {
-        // in current usage, interval is always a SequenceInterval
+        // Only SequenceIntervals need potential sliding
         if (!(interval instanceof SequenceInterval)) {
             return;
         }
@@ -1119,7 +1156,7 @@ class IntervalCollection extends common_utils_1.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;
@@ -1140,10 +1177,6 @@ class IntervalCollection extends common_utils_1.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;
@@ -1168,10 +1201,6 @@ class IntervalCollection extends common_utils_1.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) {
@@ -1250,4 +1279,16 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
     }
 }
 exports.IntervalCollection = IntervalCollection;
+/**
+ * Returns an object that can be used to find the interval a given LocalReferencePosition belongs to.
+ * @returns undefined if the reference position is not the endpoint of any interval (e.g. it was created
+ * on the merge tree directly by app code), otherwise an {@link IntervalLocator} for the interval this
+ * endpoint is a part of.
+ */
+function intervalLocatorFromEndpoint(potentialEndpoint) {
+    var _a;
+    const { interval, [merge_tree_1.reservedRangeLabelsKey]: collectionNameArray, } = (_a = potentialEndpoint.properties) !== null && _a !== void 0 ? _a : {};
+    return (interval && (collectionNameArray === null || collectionNameArray === void 0 ? void 0 : collectionNameArray.length) === 1) ? { label: collectionNameArray[0], interval } : undefined;
+}
+exports.intervalLocatorFromEndpoint = intervalLocatorFromEndpoint;
 //# sourceMappingURL=intervalCollection.js.map