@fluidframework/sequence 2.0.0-dev.2.3.0.115467 → 2.0.0-dev.3.1.0.125672

package/dist/intervalCollection.js

@@ -177,8 +177,7 @@ class Interval {
      * {@inheritDoc IInterval.overlaps}
      */
     overlaps(b) {
-        const result = (this.start <= b.end) &&
-            (this.end >= b.start);
+        const result = this.start <= b.end && this.end >= b.start;
         return result;
     }
     /**
@@ -265,8 +264,8 @@ class SequenceInterval {
                 beforePositionChange,
                 afterPositionChange,
             };
-            const startCbs = (_a = (_c = this.start).callbacks) !== null && _a !== void 0 ? _a : (_c.callbacks = {});
-            const endCbs = (_b = (_d = this.end).callbacks) !== null && _b !== void 0 ? _b : (_d.callbacks = {});
+            const startCbs = ((_a = (_c = this.start).callbacks) !== null && _a !== void 0 ? _a : (_c.callbacks = {}));
+            const endCbs = ((_b = (_d = this.end).callbacks) !== null && _b !== void 0 ? _b : (_d.callbacks = {}));
             startCbs.beforeSlide = endCbs.beforeSlide = beforePositionChange;
             startCbs.afterSlide = endCbs.afterSlide = afterPositionChange;
         }
@@ -348,8 +347,8 @@ class SequenceInterval {
      * {@inheritDoc IInterval.overlaps}
      */
     overlaps(b) {
-        const result = ((0, merge_tree_1.compareReferencePositions)(this.start, b.end) <= 0) &&
-            ((0, merge_tree_1.compareReferencePositions)(this.end, 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;
     }
     /**
@@ -383,7 +382,7 @@ class SequenceInterval {
     overlapsPos(bstart, bend) {
         const startPos = this.client.localReferencePositionToPosition(this.start);
         const endPos = this.client.localReferencePositionToPosition(this.end);
-        return (endPos > bstart) && (startPos < bend);
+        return endPos > bstart && startPos < bend;
     }
     /**
      * {@inheritDoc IInterval.modify}
@@ -428,13 +427,17 @@ class SequenceInterval {
     }
 }
 exports.SequenceInterval = SequenceInterval;
-function createPositionReferenceFromSegoff(client, segoff, refType, op) {
+function createPositionReferenceFromSegoff(client, segoff, refType, op, localSeq) {
     if (segoff.segment) {
         const ref = client.createLocalReferencePosition(segoff.segment, segoff.offset, refType, undefined);
         return ref;
     }
-    if (!op && !(0, merge_tree_1.refTypeIncludesFlag)(refType, merge_tree_1.ReferenceType.Transient)) {
-        // reference to segment that dne locally
+    // Creating references on detached segments is allowed for:
+    // - Transient segments
+    // - References coming from a remote client (location may have been concurrently removed)
+    // - References being rebased to a new sequence number
+    //   (segment they originally referred to may have been removed with no suitable replacement)
+    if (!op && !localSeq && !(0, merge_tree_1.refTypeIncludesFlag)(refType, merge_tree_1.ReferenceType.Transient)) {
         throw new container_utils_1.UsageError("Non-transient references need segment");
     }
     return (0, merge_tree_1.createDetachedLocalReferencePosition)(refType);
@@ -443,14 +446,17 @@ function createPositionReference(client, pos, refType, op, fromSnapshot, localSe
     let segoff;
     if (op) {
         (0, common_utils_1.assert)((refType & merge_tree_1.ReferenceType.SlideOnRemove) !== 0, 0x2f5 /* op create references must be SlideOnRemove */);
-        segoff = client.getContainingSegment(pos, op);
+        segoff = client.getContainingSegment(pos, {
+            referenceSequenceNumber: op.referenceSequenceNumber,
+            clientId: op.clientId,
+        });
         segoff = client.getSlideToSegment(segoff);
     }
     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, undefined, localSeq);
     }
-    return createPositionReferenceFromSegoff(client, segoff, refType, op);
+    return createPositionReferenceFromSegoff(client, segoff, refType, op, localSeq);
 }
 function createSequenceInterval(label, start, end, client, intervalType, op, fromSnapshot) {
     let beginRefType = merge_tree_1.ReferenceType.RangeBegin;
@@ -522,14 +528,13 @@ class LocalIntervalCollection {
     }
     addConflictResolver(conflictResolver) {
         this.conflictResolver = conflictResolver;
-        this.endConflictResolver =
-            (key, currentKey) => {
-                const ival = conflictResolver(key, currentKey);
-                return {
-                    data: ival,
-                    key: ival,
-                };
+        this.endConflictResolver = (key, currentKey) => {
+            const ival = conflictResolver(key, currentKey);
+            return {
+                data: ival,
+                key: ival,
             };
+        };
     }
     map(fn) {
         this.intervalTree.map(fn);
@@ -609,11 +614,11 @@ class LocalIntervalCollection {
             else {
                 // Start and (possibly) end provided. Walk the subtrees that may contain
                 // this start position.
-                const compareFn = end === undefined ?
-                    (node) => {
+                const compareFn = end === undefined
+                    ? (node) => {
                         return transientInterval.compareStart(node.key);
-                    } :
-                    (node) => {
+                    }
+                    : (node) => {
                         return transientInterval.compare(node.key);
                     };
                 const continueLeftFn = (cmpResult) => cmpResult <= 0;
@@ -748,18 +753,25 @@ class LocalIntervalCollection {
         };
         if (interval instanceof SequenceInterval) {
             let previousInterval;
+            let pendingChanges = 0;
             interval.addPositionChangeListeners(() => {
-                (0, common_utils_1.assert)(!previousInterval, 0x3f9 /* Invalid interleaving of before/after slide */);
-                previousInterval = interval.clone();
-                previousInterval.start = cloneRef(previousInterval.start);
-                previousInterval.end = cloneRef(previousInterval.end);
-                this.removeIntervalFromIndex(interval);
+                pendingChanges++;
+                // Note: both start and end can change and invoke beforeSlide on each endpoint before afterSlide.
+                if (!previousInterval) {
+                    previousInterval = interval.clone();
+                    previousInterval.start = cloneRef(previousInterval.start);
+                    previousInterval.end = cloneRef(previousInterval.end);
+                    this.removeIntervalFromIndex(interval);
+                }
             }, () => {
                 var _a;
                 (0, common_utils_1.assert)(previousInterval !== undefined, 0x3fa /* Invalid interleaving of before/after slide */);
-                this.addIntervalToIndex(interval);
-                (_a = this.onPositionChange) === null || _a === void 0 ? void 0 : _a.call(this, interval, previousInterval);
-                previousInterval = undefined;
+                pendingChanges--;
+                if (pendingChanges === 0) {
+                    this.addIntervalToIndex(interval);
+                    (_a = this.onPositionChange) === null || _a === void 0 ? void 0 : _a.call(this, interval, previousInterval);
+                    previousInterval = undefined;
+                }
             });
         }
     }
@@ -844,17 +856,18 @@ function makeOpsMap() {
         const rebasedOp = Object.assign(Object.assign({}, op), { value: rebasedValue });
         return { rebasedOp, rebasedLocalOpMetadata: localOpMetadata };
     };
-    return new Map([[
+    return new Map([
+        [
             "add",
             {
-                process: (collection, params, local, op) => {
+                process: (collection, params, local, op, localOpMetadata) => {
                     // if params is undefined, the interval was deleted during
                     // rebasing
                     if (!params) {
                         return;
                     }
                     (0, common_utils_1.assert)(op !== undefined, 0x3fb /* op should exist here */);
-                    collection.ackAdd(params, local, op);
+                    collection.ackAdd(params, local, op, localOpMetadata);
                 },
                 rebase,
             },
@@ -875,18 +888,19 @@ function makeOpsMap() {
         [
             "change",
             {
-                process: (collection, params, local, op) => {
+                process: (collection, params, local, op, localOpMetadata) => {
                     // if params is undefined, the interval was deleted during
                     // rebasing
                     if (!params) {
                         return;
                     }
                     (0, common_utils_1.assert)(op !== undefined, 0x3fd /* op should exist here */);
-                    collection.ackChange(params, local, op);
+                    collection.ackChange(params, local, op, localOpMetadata);
                 },
                 rebase,
             },
-        ]]);
+        ],
+    ]);
 }
 exports.makeOpsMap = makeOpsMap;
 class IntervalCollectionIterator {
@@ -923,6 +937,8 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         this.helpers = helpers;
         this.requiresClient = requiresClient;
         this.emitter = emitter;
+        this.localSeqToSerializedInterval = new Map();
+        this.localSeqToRebasedInterval = new Map();
         this.pendingChangesStart = new Map();
         this.pendingChangesEnd = new Map();
         this.savedSerializedIntervals = Array.isArray(serializedIntervals)
@@ -932,16 +948,57 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
     get attached() {
         return !!this.localCollection;
     }
+    rebasePositionWithSegmentSlide(pos, seqNumberFrom, localSeq) {
+        var _a;
+        if (!this.client) {
+            throw new telemetry_utils_1.LoggingError("mergeTree client must exist");
+        }
+        const { clientId } = this.client.getCollabWindow();
+        const { segment, offset } = this.client.getContainingSegment(pos, {
+            referenceSequenceNumber: seqNumberFrom,
+            clientId: this.client.getLongClientId(clientId),
+        }, localSeq);
+        // if segment is undefined, it slid off the string
+        (0, common_utils_1.assert)(segment !== undefined, 0x54e /* No segment found */);
+        const segoff = (_a = this.client.getSlideToSegment({ segment, offset })) !== null && _a !== void 0 ? _a : segment;
+        // case happens when rebasing op, but concurrently entire string has been deleted
+        if (segoff.segment === undefined || segoff.offset === undefined) {
+            return merge_tree_1.DetachedReferencePosition;
+        }
+        (0, common_utils_1.assert)(offset !== undefined && 0 <= offset && offset < segment.cachedLength, 0x54f /* Invalid offset */);
+        return this.client.findReconnectionPosition(segoff.segment, localSeq) + segoff.offset;
+    }
+    computeRebasedPositions(localSeq) {
+        (0, common_utils_1.assert)(this.client !== undefined, 0x550 /* Client should be defined when computing rebased position */);
+        const original = this.localSeqToSerializedInterval.get(localSeq);
+        (0, common_utils_1.assert)(original !== undefined, 0x551 /* Failed to store pending serialized interval info for this localSeq. */);
+        const rebased = Object.assign({}, original);
+        const { start, end, sequenceNumber } = original;
+        if (start !== undefined) {
+            rebased.start = this.rebasePositionWithSegmentSlide(start, sequenceNumber, localSeq);
+        }
+        if (end !== undefined) {
+            rebased.end = this.rebasePositionWithSegmentSlide(end, sequenceNumber, localSeq);
+        }
+        return rebased;
+    }
     /** @internal */
     attachGraph(client, label) {
         if (this.attached) {
             throw new telemetry_utils_1.LoggingError("Only supports one Sequence attach");
         }
-        if ((client === undefined) && (this.requiresClient)) {
+        if (client === undefined && this.requiresClient) {
             throw new telemetry_utils_1.LoggingError("Client required for this collection");
         }
         // Instantiate the local interval collection based on the saved intervals
         this.client = client;
+        if (client) {
+            client.on("normalize", () => {
+                for (const localSeq of this.localSeqToSerializedInterval.keys()) {
+                    this.localSeqToRebasedInterval.set(localSeq, this.computeRebasedPositions(localSeq));
+                }
+            });
+        }
         this.localCollection = new LocalIntervalCollection(client, label, this.helpers, (interval, previousInterval) => this.emitChange(interval, previousInterval, true));
         if (this.savedSerializedIntervals) {
             for (const serializedInterval of this.savedSerializedIntervals) {
@@ -1019,8 +1076,10 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
                 sequenceNumber: (_b = (_a = this.client) === null || _a === void 0 ? void 0 : _a.getCurrentSeq()) !== null && _b !== void 0 ? _b : 0,
                 start,
             };
+            const localSeq = this.getNextLocalSeq();
+            this.localSeqToSerializedInterval.set(localSeq, serializedInterval);
             // Local ops get submitted to the server. Remote ops have the deserializer run.
-            this.emitter.emit("add", undefined, serializedInterval, { localSeq: this.getNextLocalSeq() });
+            this.emitter.emit("add", undefined, serializedInterval, { localSeq });
         }
         this.emit("addInterval", interval, true, undefined);
         return interval;
@@ -1034,7 +1093,9 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         if (interval) {
             // Local ops get submitted to the server. Remote ops have the deserializer run.
             if (local) {
-                this.emitter.emit("delete", undefined, interval.serialize(), { localSeq: this.getNextLocalSeq() });
+                this.emitter.emit("delete", undefined, interval.serialize(), {
+                    localSeq: this.getNextLocalSeq(),
+                });
             }
             else {
                 if (this.onDeserialize) {
@@ -1069,7 +1130,7 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         if (!this.attached) {
             throw new telemetry_utils_1.LoggingError("Attach must be called before accessing intervals");
         }
-        if (typeof (id) !== "string") {
+        if (typeof id !== "string") {
             throw new telemetry_utils_1.LoggingError("Change API requires an ID that is a string");
         }
         if (!props) {
@@ -1086,7 +1147,9 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
             serializedInterval.end = undefined;
             serializedInterval.properties = props;
             serializedInterval.properties[reservedIntervalIdKey] = interval.getIntervalId();
-            this.emitter.emit("change", undefined, serializedInterval, { localSeq: this.getNextLocalSeq() });
+            const localSeq = this.getNextLocalSeq();
+            this.localSeqToSerializedInterval.set(localSeq, serializedInterval);
+            this.emitter.emit("change", undefined, serializedInterval, { localSeq });
             this.emit("propertyChanged", interval, deltaProps, true, undefined);
         }
     }
@@ -1102,7 +1165,7 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
             throw new telemetry_utils_1.LoggingError("Attach must be called before accessing intervals");
         }
         // Force id to be a string.
-        if (typeof (id) !== "string") {
+        if (typeof id !== "string") {
             throw new telemetry_utils_1.LoggingError("Change API requires an ID that is a string");
         }
         const interval = this.getIntervalById(id);
@@ -1115,11 +1178,12 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
             serializedInterval.start = start;
             serializedInterval.end = end;
             // Emit a property bag containing only the ID, as we don't intend for this op to change any properties.
-            serializedInterval.properties =
-                {
-                    [reservedIntervalIdKey]: interval.getIntervalId(),
-                };
-            this.emitter.emit("change", undefined, serializedInterval, { localSeq: this.getNextLocalSeq() });
+            serializedInterval.properties = {
+                [reservedIntervalIdKey]: interval.getIntervalId(),
+            };
+            const localSeq = this.getNextLocalSeq();
+            this.localSeqToSerializedInterval.set(localSeq, serializedInterval);
+            this.emitter.emit("change", undefined, serializedInterval, { localSeq });
             this.addPendingChange(id, serializedInterval);
             this.emitChange(newInterval, interval, true);
             return newInterval;
@@ -1176,12 +1240,14 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         return entries && entries.length !== 0;
     }
     /** @internal */
-    ackChange(serializedInterval, local, op) {
+    ackChange(serializedInterval, local, op, localOpMetadata) {
         var _a, _b, _c, _d;
         if (!this.localCollection) {
             throw new telemetry_utils_1.LoggingError("Attach must be called before accessing intervals");
         }
         if (local) {
+            (0, common_utils_1.assert)(localOpMetadata !== undefined, 0x552 /* op metadata should be defined for local op */);
+            this.localSeqToSerializedInterval.delete(localOpMetadata === null || localOpMetadata === void 0 ? void 0 : localOpMetadata.localSeq);
             // This is an ack from the server. Remove the pending change.
             this.removePendingChange(serializedInterval);
         }
@@ -1219,7 +1285,8 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
             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 = (_d = this.localCollection.changeInterval(interval, start, end, op)) !== null && _d !== void 0 ? _d : interval;
+                newInterval =
+                    (_d = this.localCollection.changeInterval(interval, start, end, op)) !== null && _d !== void 0 ? _d : interval;
             }
             const deltaProps = newInterval.addProperties(newProps, true, op.sequenceNumber);
             if (this.onDeserialize) {
@@ -1261,7 +1328,7 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
      * @internal
      */
     rebaseLocalInterval(opName, serializedInterval, localSeq) {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a, _b, _c, _d, _e, _f;
         if (!this.client) {
             // If there's no associated mergeTree client, the originally submitted op is still correct.
             return serializedInterval;
@@ -1269,44 +1336,36 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         if (!this.attached) {
             throw new telemetry_utils_1.LoggingError("attachSequence must be called");
         }
-        const { start, end, intervalType, properties, sequenceNumber } = serializedInterval;
-        const startRebased = start === undefined ? undefined :
-            this.client.rebasePosition(start, sequenceNumber, localSeq);
-        const endRebased = end === undefined ? undefined :
-            this.client.rebasePosition(end, sequenceNumber, localSeq);
+        const { intervalType, properties } = serializedInterval;
+        const { start: startRebased, end: endRebased } = (_a = this.localSeqToRebasedInterval.get(localSeq)) !== null && _a !== void 0 ? _a : this.computeRebasedPositions(localSeq);
         const intervalId = properties === null || properties === void 0 ? void 0 : properties[reservedIntervalIdKey];
-        const localInterval = (_a = this.localCollection) === null || _a === void 0 ? void 0 : _a.getIntervalById(intervalId);
+        const localInterval = (_b = this.localCollection) === null || _b === void 0 ? void 0 : _b.getIntervalById(intervalId);
         const rebased = {
             start: startRebased,
             end: endRebased,
             intervalType,
-            sequenceNumber: (_c = (_b = this.client) === null || _b === void 0 ? void 0 : _b.getCurrentSeq()) !== null && _c !== void 0 ? _c : 0,
+            sequenceNumber: (_d = (_c = this.client) === null || _c === void 0 ? void 0 : _c.getCurrentSeq()) !== null && _d !== void 0 ? _d : 0,
             properties,
         };
-        if (opName === "change" && (this.hasPendingChangeStart(intervalId) || this.hasPendingChangeEnd(intervalId))) {
+        if (opName === "change" &&
+            (this.hasPendingChangeStart(intervalId) || this.hasPendingChangeEnd(intervalId))) {
             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 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) {
-                (_d = this.localCollection) === null || _d === void 0 ? void 0 : _d.removeExistingInterval(localInterval);
+                (_e = this.localCollection) === null || _e === void 0 ? void 0 : _e.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) + ((_e = startSegment.offset) !== null && _e !== void 0 ? _e : 0);
-            const newEnd = endSegment && this.client.getPosition(endSegment.segment, localSeq) + ((_f = endSegment.offset) !== null && _f !== void 0 ? _f : 0);
-            (_g = this.localCollection) === null || _g === void 0 ? void 0 : _g.changeInterval(localInterval, newStart, newEnd, undefined, localSeq);
+        if (localInterval !== undefined) {
+            // 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 */);
+            // The rebased op may place this interval's endpoints on different segments. Calling `changeInterval` here
+            // updates the local client's state to be consistent with the emitted op.
+            (_f = this.localCollection) === null || _f === void 0 ? void 0 : _f.changeInterval(localInterval, startRebased, endRebased, undefined, localSeq);
         }
         return rebased;
     }
@@ -1320,7 +1379,9 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
             return undefined;
         }
         const newSegoff = this.client.getSlideToSegment(segoff);
-        const value = (segoff.segment === newSegoff.segment && segoff.offset === newSegoff.offset) ? undefined : newSegoff;
+        const value = segoff.segment === newSegoff.segment && segoff.offset === newSegoff.offset
+            ? undefined
+            : newSegoff;
         return value;
     }
     setSlideOnRemove(lref) {
@@ -1394,9 +1455,11 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         }
     }
     /** @internal */
-    ackAdd(serializedInterval, local, op) {
+    ackAdd(serializedInterval, local, op, localOpMetadata) {
         var _a;
         if (local) {
+            (0, common_utils_1.assert)(localOpMetadata !== undefined, 0x553 /* op metadata should be defined for local op */);
+            this.localSeqToSerializedInterval.delete(localOpMetadata.localSeq);
             const id = (_a = serializedInterval.properties) === null || _a === void 0 ? void 0 : _a[reservedIntervalIdKey];
             const localInterval = this.getIntervalById(id);
             if (localInterval) {
@@ -1533,8 +1596,10 @@ exports.IntervalCollection = IntervalCollection;
  */
 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;
+    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