@fluidframework/sequence 2.0.0-internal.2.3.1 → 2.0.0-internal.3.0.0

package/lib/intervalCollection.js

@@ -423,13 +423,17 @@ export class 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 && !refTypeIncludesFlag(refType, 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 && !refTypeIncludesFlag(refType, ReferenceType.Transient)) {
         throw new UsageError("Non-transient references need segment");
     }
     return createDetachedLocalReferencePosition(refType);
@@ -438,14 +442,14 @@ function createPositionReference(client, pos, refType, op, fromSnapshot, localSe
     let segoff;
     if (op) {
         assert((refType & 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 {
         assert((refType & 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);
 }
 export function createSequenceInterval(label, start, end, client, intervalType, op, fromSnapshot) {
     let beginRefType = ReferenceType.RangeBegin;
@@ -740,18 +744,25 @@ export class LocalIntervalCollection {
         };
         if (interval instanceof SequenceInterval) {
             let previousInterval;
+            let pendingChanges = 0;
             interval.addPositionChangeListeners(() => {
-                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;
                 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;
+                }
             });
         }
     }
@@ -835,14 +846,14 @@ export function makeOpsMap() {
     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;
                     }
                     assert(op !== undefined, 0x3fb /* op should exist here */);
-                    collection.ackAdd(params, local, op);
+                    collection.ackAdd(params, local, op, localOpMetadata);
                 },
                 rebase,
             },
@@ -863,14 +874,14 @@ export 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;
                     }
                     assert(op !== undefined, 0x3fd /* op should exist here */);
-                    collection.ackChange(params, local, op);
+                    collection.ackChange(params, local, op, localOpMetadata);
                 },
                 rebase,
             },
@@ -909,6 +920,8 @@ export class IntervalCollection extends 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)
@@ -918,6 +931,37 @@ export class IntervalCollection extends TypedEventEmitter {
     get attached() {
         return !!this.localCollection;
     }
+    rebasePositionWithSegmentSlide(pos, seqNumberFrom, localSeq) {
+        var _a;
+        if (!this.client) {
+            throw new 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
+        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 DetachedReferencePosition;
+        }
+        assert(offset !== undefined && 0 <= offset && offset < segment.cachedLength, 0x54f /* Invalid offset */);
+        return this.client.findReconnectionPosition(segoff.segment, localSeq) + segoff.offset;
+    }
+    computeRebasedPositions(localSeq) {
+        assert(this.client !== undefined, 0x550 /* Client should be defined when computing rebased position */);
+        const original = this.localSeqToSerializedInterval.get(localSeq);
+        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) {
@@ -928,6 +972,13 @@ export class IntervalCollection extends TypedEventEmitter {
         }
         // 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) {
@@ -1005,8 +1056,10 @@ export class IntervalCollection extends 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;
@@ -1072,7 +1125,9 @@ export class IntervalCollection extends 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);
         }
     }
@@ -1105,7 +1160,9 @@ export class IntervalCollection extends TypedEventEmitter {
                 {
                     [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.addPendingChange(id, serializedInterval);
             this.emitChange(newInterval, interval, true);
             return newInterval;
@@ -1162,12 +1219,14 @@ export class IntervalCollection extends 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 LoggingError("Attach must be called before accessing intervals");
         }
         if (local) {
+            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);
         }
@@ -1247,7 +1306,7 @@ export class IntervalCollection extends 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;
@@ -1255,44 +1314,34 @@ export class IntervalCollection extends TypedEventEmitter {
         if (!this.attached) {
             throw new 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))) {
             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 the interval slid off the string, rebase the op to be a noop and delete the interval.
         if (startRebased === DetachedReferencePosition || endRebased === 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
-        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
+            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;
     }
@@ -1380,9 +1429,11 @@ export class IntervalCollection extends TypedEventEmitter {
         }
     }
     /** @internal */
-    ackAdd(serializedInterval, local, op) {
+    ackAdd(serializedInterval, local, op, localOpMetadata) {
         var _a;
         if (local) {
+            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) {