@fluidframework/sequence 2.50.0-345060 → 2.51.0-347100

package/src/intervalCollection.ts

@@ -197,7 +197,6 @@ export class LocalIntervalCollection {
 		end: SequencePlace,
 		props?: PropertySet,
 		op?: ISequencedDocumentMessage,
-		rollback?: boolean,
 	) {
 		// This check is intended to prevent scenarios where a random interval is created and then
 		// inserted into a collection. The aim is to ensure that the collection is created first
@@ -221,7 +220,7 @@ export class LocalIntervalCollection {
 			undefined,
 			this.options.mergeTreeReferencesCanSlideToEndpoint,
 			props,
-			rollback,
+			false,
 		);
 
 		this.add(interval);
@@ -693,6 +692,7 @@ type PendingChanges = Partial<
 			endpointChanges?: DoublyLinkedList<
 				IntervalAddLocalMetadata | IntervalChangeLocalMetadata
 			>;
+			consensus: SequenceIntervalClass | undefined;
 		}
 	>
 >;
@@ -709,8 +709,7 @@ function removeMetadataFromPendingChanges(
 
 function clearEmptyPendingEntry(pendingChanges: PendingChanges, id: string) {
 	const pending = pendingChanges[id];
-	assert(pending !== undefined, 0xbbf /* pending must exist for local process */);
-	if (pending.local.empty) {
+	if (pending !== undefined && pending.local.empty) {
 		assert(
 			pending.endpointChanges?.empty !== false,
 			0xbc0 /* endpointChanges must be empty if not pending changes */,
@@ -718,6 +717,7 @@ function clearEmptyPendingEntry(pendingChanges: PendingChanges, id: string) {
 		// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
 		delete pendingChanges[id];
 	}
+	return pending;
 }
 
 function hasEndpointChanges(
@@ -747,6 +747,7 @@ export class IntervalCollection
 	private readonly submitDelta: (
 		op: IIntervalCollectionTypeOperationValue,
 		md: IntervalMessageLocalMetadata,
+		consensus?: SequenceIntervalClass,
 	) => void;
 
 	constructor(
@@ -756,15 +757,15 @@ export class IntervalCollection
 	) {
 		super();
 
-		this.submitDelta = (op, md) => {
+		this.submitDelta = (op, md, consensus) => {
 			const { id } = getSerializedProperties(op.value);
 			const pending = (this.pending[id] ??= {
 				local: new DoublyLinkedList(),
+				consensus,
 			});
 			if (md.type === "add" || (md.type === "change" && hasEndpointChanges(op.value))) {
 				const endpointChanges = (pending.endpointChanges ??= new DoublyLinkedList());
 				md.endpointChangesNode = endpointChanges.push(md).last;
-				md.rebased = undefined;
 			}
 			submitDelta(op, pending.local.push(md).last);
 		};
@@ -814,48 +815,48 @@ export class IntervalCollection
 		const localOpMetadata = removeMetadataFromPendingChanges(maybeMetadata);
 		const { value } = op;
 		const { id, properties } = getSerializedProperties(value);
-		const { type } = localOpMetadata;
+		const pending = clearEmptyPendingEntry(this.pending, id);
+		const previous = pending?.local.empty
+			? pending.consensus
+			: pending?.local.last?.data.interval;
+		const { type, interval } = localOpMetadata;
 		switch (type) {
 			case "add": {
-				const interval = this.getIntervalById(id);
-				if (interval) {
-					this.deleteExistingInterval({ interval, local: true, rollback: true });
-				}
+				this.deleteExistingInterval({ interval, local: true, rollback: true });
+				interval.dispose();
 				break;
 			}
 			case "change": {
-				const { previous } = localOpMetadata;
-				const endpointsChanged = hasEndpointChanges(value);
-				const start = endpointsChanged
-					? toOptionalSequencePlace(previous.start, previous.startSide)
+				const changeProperties = Object.keys(properties).length > 0;
+				const deltaProps = changeProperties
+					? interval.changeProperties(properties, undefined, true)
 					: undefined;
-				const end = endpointsChanged
-					? toOptionalSequencePlace(previous.end, previous.endSide)
-					: undefined;
-				this.change(id, {
-					start,
-					end,
-					props: Object.keys(properties).length > 0 ? properties : undefined,
-					rollback: true,
-				});
+				if (localOpMetadata.endpointChangesNode !== undefined) {
+					if (previous !== undefined) {
+						this.localCollection?.removeExistingInterval(interval);
+						this.localCollection?.add(previous);
+						this.emitChange(previous, interval, true, true);
+					}
+					if (previous !== interval) {
+						interval.dispose();
+					}
+				}
+				if (changeProperties) {
+					this.emit("propertyChanged", previous, deltaProps, true, undefined);
+				}
 				break;
 			}
 			case "delete": {
-				const { previous } = localOpMetadata;
-				this.add({
-					id,
-					start: toSequencePlace(previous.start, previous.startSide),
-					end: toSequencePlace(previous.end, previous.endSide),
-					props: Object.keys(properties).length > 0 ? properties : undefined,
-					rollback: true,
-				});
+				// a remote could delete the same interval, so it may not exist to re-add
+				if (previous !== undefined) {
+					this.localCollection?.add(previous);
+					this.emit("addInterval", previous, true, undefined);
+				}
 				break;
 			}
 			default:
 				unreachableCase(type);
 		}
-
-		clearEmptyPendingEntry(this.pending, id);
 	}
 
 	public process(
@@ -869,13 +870,15 @@ export class IntervalCollection
 			: undefined;
 
 		const { opName, value } = op;
+		const { id } = getSerializedProperties(value);
 		assert(
 			(local === false && localOpMetadata === undefined) || opName === localOpMetadata?.type,
 			0xbc1 /* must be same type */,
 		);
+		let newConsensus = localOpMetadata?.interval;
 		switch (opName) {
 			case "add": {
-				this.ackAdd(
+				newConsensus = this.ackAdd(
 					value,
 					local,
 					message,
@@ -892,16 +895,22 @@ export class IntervalCollection
 			}
 
 			case "change": {
-				this.ackChange(value, local, message);
+				newConsensus = this.ackChange(
+					value,
+					local,
+					message, // this cast is safe because of the above assert which
+					// validates the op and metadata types match for local changes
+					localOpMetadata as IntervalChangeLocalMetadata | undefined,
+				);
 				break;
 			}
 			default:
 				unreachableCase(opName);
 		}
+		const pending = clearEmptyPendingEntry(this.pending, id);
 
-		if (local) {
-			const { id } = getSerializedProperties(value);
-			clearEmptyPendingEntry(this.pending, id);
+		if (pending !== undefined) {
+			pending.consensus = newConsensus;
 		}
 	}
 
@@ -1040,7 +1049,7 @@ export class IntervalCollection
 				for (const pending of Object.values(this.pending)) {
 					if (pending?.endpointChanges !== undefined) {
 						for (const local of pending.endpointChanges) {
-							local.data.rebased = this.computeRebasedPositions(local.data, squash);
+							this.rebaseLocalInterval(local.data.interval.serialize(), local.data, squash);
 						}
 					}
 				}
@@ -1150,13 +1159,11 @@ export class IntervalCollection
 		start,
 		end,
 		props,
-		rollback,
 	}: {
 		id?: string;
 		start: SequencePlace;
 		end: SequencePlace;
 		props?: PropertySet;
-		rollback?: boolean;
 	}): SequenceIntervalClass {
 		if (!this.localCollection) {
 			throw new LoggingError("attach must be called prior to adding intervals");
@@ -1182,7 +1189,6 @@ export class IntervalCollection
 			toSequencePlace(endPos, endSide),
 			props,
 			undefined,
-			rollback,
 		);
 
 		if (interval) {
@@ -1192,7 +1198,7 @@ export class IntervalCollection
 			}
 			const serializedInterval: ISerializedInterval = interval.serialize();
 			const localSeq = this.getNextLocalSeq();
-			if (this.isCollaborating && rollback !== true) {
+			if (this.isCollaborating) {
 				this.submitDelta(
 					{
 						opName: "add",
@@ -1241,8 +1247,8 @@ export class IntervalCollection
 					{
 						type: "delete",
 						localSeq: this.getNextLocalSeq(),
-						previous: value,
 					},
+					interval,
 				);
 			} else {
 				if (this.onDeserialize) {
@@ -1261,7 +1267,7 @@ export class IntervalCollection
 		if (!this.localCollection) {
 			throw new LoggingError("Attach must be called before accessing intervals");
 		}
-		const interval = this.localCollection.idIntervalIndex.getIntervalById(id);
+		const interval = this.getIntervalById(id);
 		if (interval) {
 			this.deleteExistingInterval({ interval, local: true });
 		}
@@ -1329,7 +1335,6 @@ export class IntervalCollection
 				const metadata: IntervalChangeLocalMetadata = {
 					type: "change",
 					localSeq,
-					previous: interval.serialize(),
 					interval: newInterval ?? interval,
 				};
 
@@ -1339,6 +1344,7 @@ export class IntervalCollection
 						value: serializedInterval,
 					},
 					metadata,
+					interval,
 				);
 			}
 			if (deltaProps !== undefined) {
@@ -1377,6 +1383,7 @@ export class IntervalCollection
 		serializedInterval: SerializedIntervalDelta,
 		local: boolean,
 		op: ISequencedDocumentMessage,
+		localOpMetadata: IntervalChangeLocalMetadata | undefined,
 	) {
 		if (!this.localCollection) {
 			throw new LoggingError("Attach must be called before accessing intervals");
@@ -1387,55 +1394,51 @@ export class IntervalCollection
 		// strip it out of the properties here.
 		const { id, properties } = getSerializedProperties(serializedInterval);
 		assert(id !== undefined, 0x3fe /* id must exist on the interval */);
-		const interval: SequenceIntervalClass | undefined = this.getIntervalById(id);
-
-		if (!interval) {
-			// The interval has been removed locally; no-op.
-			return;
-		}
 
 		if (local) {
+			assert(localOpMetadata !== undefined, 0xbd4 /* local must have metadata */);
+			const { interval } = localOpMetadata;
 			interval.ackPropertiesChange(properties, op);
 
 			this.ackInterval(interval, op);
+			return interval;
 		} else {
-			// If there are pending changes with this ID, don't apply the remote start/end change, as the local ack
-			// should be the winning change.
-			let start: number | "start" | "end" | undefined;
-			let end: number | "start" | "end" | undefined;
-			// Track pending start/end independently of one another.
-			if (!this.hasPendingEndpointChanges(id)) {
-				start = serializedInterval.start;
-				end = serializedInterval.end;
-			}
+			const latestInterval = this.getIntervalById(id);
+			const intervalToChange: SequenceIntervalClass | undefined =
+				this.pending[id]?.consensus ?? latestInterval;
 
-			let newInterval = interval;
-			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 =
-					this.localCollection.changeInterval(
-						interval,
-						toOptionalSequencePlace(start, serializedInterval.startSide ?? Side.Before),
-						toOptionalSequencePlace(end, serializedInterval.endSide ?? Side.Before),
-						op,
-					) ?? interval;
-			}
-			const deltaProps = newInterval.changeProperties(properties, op);
+			const isLatestInterval = intervalToChange === latestInterval;
 
-			if (this.onDeserialize) {
-				this.onDeserialize(newInterval);
+			if (!intervalToChange) {
+				return intervalToChange;
 			}
 
-			if (newInterval !== interval) {
-				this.emitChange(newInterval, interval, local, false, op);
+			const deltaProps = intervalToChange.changeProperties(properties, op);
+
+			let newInterval = intervalToChange;
+			if (hasEndpointChanges(serializedInterval)) {
+				const { start, end, startSide, endSide } = serializedInterval;
+				newInterval = intervalToChange.modify(
+					"",
+					toOptionalSequencePlace(start, startSide ?? Side.Before),
+					toOptionalSequencePlace(end, endSide ?? Side.Before),
+					op,
+				);
+				if (isLatestInterval) {
+					this.localCollection.removeExistingInterval(intervalToChange);
+					this.localCollection.add(newInterval);
+					this.emitChange(newInterval, intervalToChange, local, false, op);
+					if (this.onDeserialize) {
+						this.onDeserialize(newInterval);
+					}
+				}
 			}
 
-			const changedProperties = Object.keys(properties).length > 0;
-			if (changedProperties) {
-				this.emit("propertyChanged", interval, deltaProps, local, op);
-				this.emit("changed", interval, deltaProps, undefined, local, false);
+			if (deltaProps !== undefined && Object.keys(deltaProps).length > 0) {
+				this.emit("propertyChanged", latestInterval, deltaProps, local, op);
+				this.emit("changed", latestInterval, deltaProps, undefined, local, false);
 			}
+			return newInterval;
 		}
 	}
 
@@ -1478,11 +1481,9 @@ export class IntervalCollection
 
 		const { localSeq, interval } = localOpMetadata;
 		const { id } = getSerializedProperties(original);
-		const rebasedEndpoint = (localOpMetadata.rebased ??= this.computeRebasedPositions(
-			localOpMetadata,
-			squash,
-		));
-		const localInterval = this.localCollection.idIntervalIndex.getIntervalById(id);
+
+		const rebasedEndpoint = this.computeRebasedPositions(localOpMetadata, squash);
+		const localInterval = this.getIntervalById(id);
 
 		// if the interval slid off the string, rebase the op to be a noop and delete the interval.
 		if (rebasedEndpoint === "detached") {
@@ -1511,8 +1512,7 @@ export class IntervalCollection
 				this.localCollection.add(interval);
 				this.emitChange(interval, old, true, true);
 			}
-			this.client.removeLocalReferencePosition(old.start);
-			this.client.removeLocalReferencePosition(old.end);
+			old.dispose();
 		}
 
 		return {
@@ -1583,10 +1583,14 @@ export class IntervalCollection
 			// `interval`'s endpoints will get modified in-place, so clone it prior to doing so for event emission.
 			const oldInterval = interval.clone();
 
-			// 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 LocalReferencePosition.
-			this.localCollection.removeExistingInterval(interval);
+			const isLatestInterval = this.getIntervalById(id) === interval;
+
+			if (isLatestInterval) {
+				// 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 LocalReferencePosition.
+				this.localCollection.removeExistingInterval(interval);
+			}
 			if (!this.client) {
 				throw new LoggingError("client does not exist");
 			}
@@ -1629,8 +1633,10 @@ export class IntervalCollection
 				oldInterval.end.refType = ReferenceType.Transient;
 				oldSeg?.localRefs?.addLocalRef(oldInterval.end, oldInterval.end.getOffset());
 			}
-			this.localCollection.add(interval);
-			this.emitChange(interval, oldInterval, true, true, op);
+			if (isLatestInterval) {
+				this.localCollection.add(interval);
+				this.emitChange(interval, oldInterval, true, true, op);
+			}
 		}
 	}
 
@@ -1639,7 +1645,7 @@ export class IntervalCollection
 		local: boolean,
 		op: ISequencedDocumentMessage,
 		localOpMetadata: IntervalAddLocalMetadata | undefined,
-	) {
+	): SequenceIntervalClass {
 		const { id, properties } = getSerializedProperties(serializedInterval);
 
 		if (local) {
@@ -1647,11 +1653,8 @@ export class IntervalCollection
 				localOpMetadata !== undefined,
 				0x553 /* op metadata should be defined for local op */,
 			);
-			const localInterval = this.getIntervalById(id);
-			if (localInterval) {
-				this.ackInterval(localInterval, op);
-			}
-			return;
+			this.ackInterval(localOpMetadata.interval, op);
+			return localOpMetadata.interval;
 		}
 
 		if (!this.localCollection) {
@@ -1694,7 +1697,7 @@ export class IntervalCollection
 		}
 
 		const { id } = getSerializedProperties(serializedInterval);
-		const interval = this.localCollection.idIntervalIndex.getIntervalById(id);
+		const interval = this.getIntervalById(id);
 		if (interval) {
 			this.deleteExistingInterval({ interval, local, op });
 		}

package/src/intervalCollectionMapInterfaces.ts

@@ -5,7 +5,7 @@
 
 import type { ListNode } from "@fluidframework/core-utils/internal";
 import { ISequencedDocumentMessage } from "@fluidframework/driver-definitions/internal";
-import { IMergeTreeOptions, type ISegmentInternal } from "@fluidframework/merge-tree/internal";
+import { IMergeTreeOptions } from "@fluidframework/merge-tree/internal";
 
 import type {
 	IntervalCollection,
@@ -23,25 +23,17 @@ export interface IntervalAddLocalMetadata {
 	type: typeof IntervalDeltaOpType.ADD;
 	localSeq: number;
 	endpointChangesNode?: ListNode<IntervalAddLocalMetadata | IntervalChangeLocalMetadata>;
-	rebased?:
-		| Record<"start" | "end", { segment: ISegmentInternal; offset: number }>
-		| "detached";
 	interval: SequenceIntervalClass;
 }
 export interface IntervalChangeLocalMetadata {
 	type: typeof IntervalDeltaOpType.CHANGE;
 	localSeq: number;
-	previous: ISerializedInterval;
 	endpointChangesNode?: ListNode<IntervalChangeLocalMetadata | IntervalChangeLocalMetadata>;
-	rebased?:
-		| Record<"start" | "end", { segment: ISegmentInternal; offset: number }>
-		| "detached";
 	interval: SequenceIntervalClass;
 }
 export interface IntervalDeleteLocalMetadata {
 	type: typeof IntervalDeltaOpType.DELETE;
 	localSeq: number;
-	previous: ISerializedInterval;
 	endpointChangesNode?: undefined;
 	interval?: undefined;
 }