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

package/src/intervalCollection.ts

@@ -622,15 +622,20 @@ function createPositionReferenceFromSegoff(
     client: Client,
     segoff: { segment: ISegment | undefined; offset: number | undefined; },
     refType: ReferenceType,
-    op?: ISequencedDocumentMessage): LocalReferencePosition {
+    op?: ISequencedDocumentMessage,
+    localSeq?: number): LocalReferencePosition {
     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
-        throw new UsageError("Non-transient references need segment");
+    // 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);
@@ -647,14 +652,14 @@ function createPositionReference(
     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(
@@ -1039,19 +1044,26 @@ export class LocalIntervalCollection<TInterval extends ISerializableInterval> {
         };
         if (interval instanceof SequenceInterval) {
             let previousInterval: TInterval & SequenceInterval | undefined;
+            let pendingChanges = 0;
             interval.addPositionChangeListeners(
                 () => {
-                    assert(!previousInterval, 0x3f9 /* Invalid interleaving of before/after slide */);
-                    previousInterval = interval.clone() as TInterval & SequenceInterval;
-                    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() as TInterval & SequenceInterval;
+                        previousInterval.start = cloneRef(previousInterval.start);
+                        previousInterval.end = cloneRef(previousInterval.end);
+                        this.removeIntervalFromIndex(interval);
+                    }
                 },
                 () => {
                     assert(previousInterval !== undefined, 0x3fa /* Invalid interleaving of before/after slide */);
-                    this.addIntervalToIndex(interval);
-                    this.onPositionChange?.(interval, previousInterval);
-                    previousInterval = undefined;
+                    pendingChanges--;
+                    if (pendingChanges === 0) {
+                        this.addIntervalToIndex(interval);
+                        this.onPositionChange?.(interval, previousInterval);
+                        previousInterval = undefined;
+                    }
                 },
             );
         }
@@ -1176,14 +1188,14 @@ export function makeOpsMap<T extends ISerializableInterval>(): Map<string, IValu
         [[
             "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,
             },
@@ -1204,14 +1216,14 @@ export function makeOpsMap<T extends ISerializableInterval>(): Map<string, IValu
         [
             "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,
             },
@@ -1312,6 +1324,8 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
     private localCollection: LocalIntervalCollection<TInterval> | undefined;
     private onDeserialize: DeserializeCallback | undefined;
     private client: Client | undefined;
+    private readonly localSeqToSerializedInterval = new Map<number, ISerializedInterval | SerializedIntervalDelta>();
+    private readonly localSeqToRebasedInterval = new Map<number, ISerializedInterval | SerializedIntervalDelta>();
     private readonly pendingChangesStart: Map<string, ISerializedInterval[]> = new Map<string, ISerializedInterval[]>();
     private readonly pendingChangesEnd: Map<string, ISerializedInterval[]> = new Map<string, ISerializedInterval[]>();
 
@@ -1333,6 +1347,46 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
             : serializedIntervals.intervals.map((i) => decompressInterval(i, serializedIntervals.label));
     }
 
+    private rebasePositionWithSegmentSlide(
+        pos: number,
+        seqNumberFrom: number,
+        localSeq: number
+    ): number | undefined {
+        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 = this.client.getSlideToSegment({ segment, offset }) ?? 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;
+    }
+
+    private computeRebasedPositions(localSeq: number): ISerializedInterval | SerializedIntervalDelta {
+        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 = { ...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 */
     public attachGraph(client: Client, label: string) {
         if (this.attached) {
@@ -1345,6 +1399,14 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 
         // 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<TInterval>(
             client,
             label,
@@ -1450,8 +1512,10 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
                 sequenceNumber: this.client?.getCurrentSeq() ?? 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);
@@ -1531,7 +1595,9 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 
             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);
         }
     }
@@ -1567,7 +1633,9 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
             {
                 [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;
@@ -1638,12 +1706,19 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
     }
 
     /** @internal */
-    public ackChange(serializedInterval: ISerializedInterval, local: boolean, op: ISequencedDocumentMessage) {
+    public ackChange(
+        serializedInterval: ISerializedInterval,
+        local: boolean,
+        op: ISequencedDocumentMessage,
+        localOpMetadata: IMapMessageLocalMetadata | undefined,
+    ) {
         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?.localSeq);
             // This is an ack from the server. Remove the pending change.
             this.removePendingChange(serializedInterval);
         }
@@ -1745,11 +1820,10 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
             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 } = this.localSeqToRebasedInterval.get(localSeq)
+            ?? this.computeRebasedPositions(localSeq);
 
         const intervalId = properties?.[reservedIntervalIdKey];
         const localInterval = this.localCollection?.getIntervalById(intervalId);
@@ -1767,8 +1841,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
             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) {
                 this.localCollection?.removeExistingInterval(localInterval);
@@ -1776,27 +1849,15 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
             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) + (startSegment.offset ?? 0);
-            const newEnd =
-                endSegment && this.client.getPosition(endSegment.segment, localSeq) + (endSegment.offset ?? 0);
-
-            this.localCollection?.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.
+            this.localCollection?.changeInterval(localInterval, startRebased, endRebased, undefined, localSeq);
         }
 
         return rebased;
@@ -1905,8 +1966,12 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
     public ackAdd(
         serializedInterval: ISerializedInterval,
         local: boolean,
-        op: ISequencedDocumentMessage) {
+        op: ISequencedDocumentMessage,
+        localOpMetadata: IMapMessageLocalMetadata | undefined,
+    ) {
         if (local) {
+            assert(localOpMetadata !== undefined, 0x553 /* op metadata should be defined for local op */);
+            this.localSeqToSerializedInterval.delete(localOpMetadata.localSeq);
             const id: string = serializedInterval.properties?.[reservedIntervalIdKey];
             const localInterval = this.getIntervalById(id);
             if (localInterval) {

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/sequence";
-export const pkgVersion = "2.0.0-internal.2.3.1";
+export const pkgVersion = "2.0.0-internal.3.0.0";

package/src/sequence.ts

@@ -200,40 +200,12 @@ export abstract class SharedSegmentSequence<T extends ISegment>
             ChildLogger.create(this.logger, "SharedSegmentSequence.MergeTreeClient"),
             mergeTreeOptions);
 
-        super.on("newListener", (event) => {
-            switch (event) {
-                case "sequenceDelta":
-                    if (!this.client.mergeTreeDeltaCallback) {
-                        this.client.mergeTreeDeltaCallback = (opArgs, deltaArgs) => {
-                            this.emit("sequenceDelta", new SequenceDeltaEvent(opArgs, deltaArgs, this.client), this);
-                        };
-                    }
-                    break;
-                case "maintenance":
-                    if (!this.client.mergeTreeMaintenanceCallback) {
-                        this.client.mergeTreeMaintenanceCallback = (args, opArgs) => {
-                            this.emit("maintenance", new SequenceMaintenanceEvent(opArgs, args, this.client), this);
-                        };
-                    }
-                    break;
-                default:
-            }
+        this.client.on("delta", (opArgs, deltaArgs) => {
+            this.emit("sequenceDelta", new SequenceDeltaEvent(opArgs, deltaArgs, this.client), this);
         });
-        super.on("removeListener", (event: string | symbol) => {
-            switch (event) {
-                case "sequenceDelta":
-                    if (super.listenerCount(event) === 0) {
-                        this.client.mergeTreeDeltaCallback = undefined;
-                    }
-                    break;
-                case "maintenance":
-                    if (super.listenerCount(event) === 0) {
-                        this.client.mergeTreeMaintenanceCallback = undefined;
-                    }
-                    break;
-                default:
-                    break;
-            }
+
+        this.client.on("maintenance", (args, opArgs) => {
+            this.emit("maintenance", new SequenceMaintenanceEvent(opArgs, args, this.client), this);
         });
 
         this.intervalCollections = new DefaultMap(