@fluidframework/sequence 2.41.0 → 2.43.0-343119

package/src/intervalCollection.ts

@@ -25,14 +25,18 @@ import {
 	endpointPosAndSide,
 	type ISegmentInternal,
 	createLocalReconnectingPerspective,
+	DoublyLinkedList,
+	type ListNode,
 } from "@fluidframework/merge-tree/internal";
 import { LoggingError, UsageError } from "@fluidframework/telemetry-utils/internal";
 import { v4 as uuid } from "uuid";
 
 import {
-	IMapMessageLocalMetadata,
+	IntervalMessageLocalMetadata,
 	SequenceOptions,
 	type IIntervalCollectionTypeOperationValue,
+	type IntervalAddLocalMetadata,
+	type IntervalChangeLocalMetadata,
 } from "./intervalCollectionMapInterfaces.js";
 import {
 	createIdIntervalIndex,
@@ -600,6 +604,9 @@ export interface ISequenceIntervalCollection
 		{ start, end, props }: { start?: SequencePlace; end?: SequencePlace; props?: PropertySet },
 	): SequenceInterval | undefined;
 
+	/**
+	 * @deprecated This api is not meant or necessary for external consumption and will be removed in subsequent release
+	 */
 	attachDeserializer(onDeserialize: DeserializeCallback): void;
 	/**
 	 * @returns an iterator over all intervals in this collection.
@@ -686,6 +693,56 @@ export interface ISequenceIntervalCollection
 	nextInterval(pos: number): SequenceInterval | undefined;
 }
 
+type PendingChanges = Partial<
+	Record<
+		string,
+		{
+			/**
+			 * The local metadatas are stores in order of submission, FIFO.
+			 * This matches how ops are ordered, and should maintained
+			 * across, submit, process, resubmit, and rollback.
+			 */
+			local: DoublyLinkedList<IntervalMessageLocalMetadata>;
+			/**
+			 * The endpointChanges are unordered, and are used to determine
+			 * if any local changes also change the endpoints. The nodes of the
+			 * list are also stored in the individual change op metadatas, and
+			 * are removed as those metadatas are handled.
+			 */
+			endpointChanges?: DoublyLinkedList<
+				IntervalAddLocalMetadata | IntervalChangeLocalMetadata
+			>;
+		}
+	>
+>;
+
+function removeMetadataFromPendingChanges(
+	localOpMetadataNode: ListNode<IntervalMessageLocalMetadata> | unknown,
+): IntervalMessageLocalMetadata {
+	const acked = (localOpMetadataNode as ListNode<IntervalMessageLocalMetadata>)?.remove()
+		?.data;
+	assert(acked !== undefined, "local change must exist");
+	acked.endpointChangesNode?.remove();
+	return acked;
+}
+
+function clearEmptyPendingEntry(pendingChanges: PendingChanges, id: string) {
+	const pending = pendingChanges[id];
+	assert(pending !== undefined, "pending must exist for local process");
+	if (pending.local.empty) {
+		assert(
+			pending.endpointChanges?.empty !== false,
+			"endpointChanges must be empty if not pending changes",
+		);
+		// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+		delete pendingChanges[id];
+	}
+}
+
+function hasEndpointChanges(serialized: SerializedIntervalDelta) {
+	return serialized.start !== undefined && serialized.end !== undefined;
+}
+
 /**
  * {@inheritdoc IIntervalCollection}
  */
@@ -697,37 +754,37 @@ export class IntervalCollection
 	private localCollection: LocalIntervalCollection | 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, ISerializedIntervalCollectionV1> = new Map<
-		string,
-		ISerializedIntervalCollectionV1
-	>();
-	private readonly pendingChangesEnd: Map<string, ISerializedIntervalCollectionV1> = new Map<
-		string,
-		ISerializedIntervalCollectionV1
-	>();
+
+	private readonly pending: PendingChanges = {};
 
 	public get attached(): boolean {
 		return !!this.localCollection;
 	}
 
+	private readonly submitDelta: (
+		op: IIntervalCollectionTypeOperationValue,
+		md: IntervalMessageLocalMetadata,
+	) => void;
+
 	constructor(
-		private readonly submitDelta: (
-			op: IIntervalCollectionTypeOperationValue,
-			md: IMapMessageLocalMetadata,
-		) => void,
+		submitDelta: (op: IIntervalCollectionTypeOperationValue, md: unknown) => void,
 		serializedIntervals: ISerializedIntervalCollectionV1 | ISerializedIntervalCollectionV2,
 		private readonly options: Partial<SequenceOptions> = {},
 	) {
 		super();
 
+		this.submitDelta = (op, md) => {
+			const { id } = getSerializedProperties(op.value);
+			const pending = (this.pending[id] ??= {
+				local: new DoublyLinkedList(),
+			});
+			if (md.type === "add" || (md.type === "change" && hasEndpointChanges(op.value))) {
+				const endpointChanges = (pending.endpointChanges ??= new DoublyLinkedList());
+				md.endpointChangesNode = endpointChanges.push(md).last;
+			}
+			submitDelta(op, pending.local.push(md).last);
+		};
+
 		this.savedSerializedIntervals = Array.isArray(serializedIntervals)
 			? serializedIntervals
 			: serializedIntervals.intervals.map((i) =>
@@ -769,14 +826,12 @@ export class IntervalCollection
 		return true;
 	}
 
-	public rollback(
-		op: IIntervalCollectionTypeOperationValue,
-		localOpMetadata: IMapMessageLocalMetadata,
-	) {
-		const { opName, value } = op;
+	public rollback(op: IIntervalCollectionTypeOperationValue, maybeMetadata: unknown) {
+		const localOpMetadata = removeMetadataFromPendingChanges(maybeMetadata);
+		const { value } = op;
 		const { id, properties } = getSerializedProperties(value);
-		const { localSeq, previous } = localOpMetadata;
-		switch (opName) {
+		const { type } = localOpMetadata;
+		switch (type) {
 			case "add": {
 				const interval = this.getIntervalById(id);
 				if (interval) {
@@ -785,9 +840,8 @@ export class IntervalCollection
 				break;
 			}
 			case "change": {
-				assert(previous !== undefined, 0xb7c /* must have previous for change */);
-
-				const endpointsChanged = value.start !== undefined && value.end !== undefined;
+				const { previous } = localOpMetadata;
+				const endpointsChanged = hasEndpointChanges(value);
 				const start = endpointsChanged
 					? toOptionalSequencePlace(previous.start, previous.startSide)
 					: undefined;
@@ -800,14 +854,10 @@ export class IntervalCollection
 					props: Object.keys(properties).length > 0 ? properties : undefined,
 					rollback: true,
 				});
-				this.localSeqToSerializedInterval.delete(localSeq);
-				if (endpointsChanged) {
-					this.removePendingChange(value);
-				}
 				break;
 			}
 			case "delete": {
-				assert(previous !== undefined, 0xb7d /* must have previous for delete */);
+				const { previous } = localOpMetadata;
 				this.add({
 					id,
 					start: toSequencePlace(previous.start, previous.startSide),
@@ -818,20 +868,37 @@ export class IntervalCollection
 				break;
 			}
 			default:
-				unreachableCase(opName);
+				unreachableCase(type);
 		}
+
+		clearEmptyPendingEntry(this.pending, id);
 	}
 
 	public process(
 		op: IIntervalCollectionTypeOperationValue,
 		local: boolean,
 		message: ISequencedDocumentMessage,
-		localOpMetadata: IMapMessageLocalMetadata,
+		maybeMetadata: unknown,
 	) {
+		const localOpMetadata = local
+			? removeMetadataFromPendingChanges(maybeMetadata)
+			: undefined;
+
 		const { opName, value } = op;
+		assert(
+			(local === false && localOpMetadata === undefined) || opName === localOpMetadata?.type,
+			"must be same type",
+		);
 		switch (opName) {
 			case "add": {
-				this.ackAdd(value, local, message, localOpMetadata);
+				this.ackAdd(
+					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 IntervalAddLocalMetadata | undefined,
+				);
 				break;
 			}
 
@@ -841,24 +908,36 @@ export class IntervalCollection
 			}
 
 			case "change": {
-				this.ackChange(value, local, message, localOpMetadata);
+				this.ackChange(value, local, message);
 				break;
 			}
 			default:
 				unreachableCase(opName);
 		}
+
+		if (local) {
+			const { id } = getSerializedProperties(value);
+			clearEmptyPendingEntry(this.pending, id);
+		}
 	}
 
 	public resubmitMessage(
 		op: IIntervalCollectionTypeOperationValue,
-		localOpMetadata: IMapMessageLocalMetadata,
+		maybeMetadata: unknown,
 	): void {
 		const { opName, value } = op;
-		const { localSeq } = localOpMetadata;
+
+		const localOpMetadata = removeMetadataFromPendingChanges(maybeMetadata);
+
 		const rebasedValue =
-			opName === "delete" ? value : this.rebaseLocalInterval(opName, value, localSeq);
+			localOpMetadata.endpointChangesNode === undefined
+				? value
+				: this.rebaseLocalInterval(localOpMetadata);
+
 		if (rebasedValue === undefined) {
-			return undefined;
+			const { id } = getSerializedProperties(value);
+			clearEmptyPendingEntry(this.pending, id);
+			return;
 		}
 
 		this.submitDelta({ opName, value: rebasedValue as any }, localOpMetadata);
@@ -909,28 +988,28 @@ export class IntervalCollection
 		}
 
 		const { clientId } = this.client.getCollabWindow();
-		const { segment, offset } = this.client.getContainingSegment(
-			pos,
-			{
-				referenceSequenceNumber: seqNumberFrom,
-				clientId: this.client.getLongClientId(clientId),
-			},
-			localSeq,
-		);
+		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 */);
+		assert(segment !== undefined && offset !== undefined, 0x54e /* No segment found */);
 
-		const segoff =
-			getSlideToSegoff(
-				{ segment, offset },
-				undefined,
-				createLocalReconnectingPerspective(this.client.getCurrentSeq(), clientId, localSeq),
-				this.options.mergeTreeReferencesCanSlideToEndpoint,
-			) ?? segment;
+		const segoff = getSlideToSegoff(
+			{ segment, offset },
+			undefined,
+			createLocalReconnectingPerspective(this.client.getCurrentSeq(), clientId, localSeq),
+			this.options.mergeTreeReferencesCanSlideToEndpoint,
+		);
 
 		// case happens when rebasing op, but concurrently entire string has been deleted
-		if (segoff.segment === undefined || segoff.offset === undefined) {
+		if (segoff?.segment === undefined || segoff.offset === undefined) {
 			return DetachedReferencePosition;
 		}
 
@@ -942,17 +1021,13 @@ export class IntervalCollection
 	}
 
 	private computeRebasedPositions(
-		localSeq: number,
+		localOpMetadata: IntervalAddLocalMetadata | IntervalChangeLocalMetadata,
 	): 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 { localSeq, original } = localOpMetadata;
 		const rebased = { ...original };
 		const { start, end, sequenceNumber } = original;
 		if (start !== undefined) {
@@ -977,8 +1052,12 @@ export class IntervalCollection
 		this.client = client;
 		if (client) {
 			client.on("normalize", () => {
-				for (const localSeq of this.localSeqToSerializedInterval.keys()) {
-					this.localSeqToRebasedInterval.set(localSeq, this.computeRebasedPositions(localSeq));
+				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);
+						}
+					}
 				}
 			});
 		}
@@ -1110,8 +1189,10 @@ export class IntervalCollection
 
 		this.assertStickinessEnabled(start, end);
 
+		const intervalId = id ?? uuid();
+
 		const interval: SequenceIntervalClass = this.localCollection.addInterval(
-			id ?? uuid(),
+			intervalId,
 			toSequencePlace(startPos, startSide),
 			toSequencePlace(endPos, endSide),
 			props,
@@ -1127,15 +1208,15 @@ export class IntervalCollection
 			const serializedInterval: ISerializedInterval = interval.serialize();
 			const localSeq = this.getNextLocalSeq();
 			if (this.isCollaborating && rollback !== true) {
-				this.localSeqToSerializedInterval.set(localSeq, serializedInterval);
-
 				this.submitDelta(
 					{
 						opName: "add",
 						value: serializedInterval,
 					},
 					{
+						type: "add",
 						localSeq,
+						original: serializedInterval,
 					},
 				);
 			}
@@ -1166,14 +1247,16 @@ export class IntervalCollection
 		if (interval) {
 			// Local ops get submitted to the server. Remote ops have the deserializer run.
 			if (local && rollback !== true) {
+				const value = interval.serialize();
 				this.submitDelta(
 					{
 						opName: "delete",
-						value: interval.serialize(),
+						value,
 					},
 					{
+						type: "delete",
 						localSeq: this.getNextLocalSeq(),
-						previous: interval.serialize(),
+						previous: value,
 					},
 				);
 			} else {
@@ -1258,18 +1341,19 @@ export class IntervalCollection
 				).serializeDelta({ props, includeEndpoints: changeEndpoints });
 				const localSeq = this.getNextLocalSeq();
 
-				this.localSeqToSerializedInterval.set(localSeq, serializedInterval);
-				this.addPendingChange(id, serializedInterval);
+				const metadata: IntervalChangeLocalMetadata = {
+					type: "change",
+					localSeq,
+					previous: interval.serialize(),
+					original: serializedInterval,
+				};
 
 				this.submitDelta(
 					{
 						opName: "change",
 						value: serializedInterval,
 					},
-					{
-						localSeq,
-						previous: interval.serialize(),
-					},
+					metadata,
 				);
 			}
 			if (deltaProps !== undefined) {
@@ -1298,98 +1382,26 @@ export class IntervalCollection
 		return this.client?.getCollabWindow().collaborating ?? false;
 	}
 
-	private addPendingChange(id: string, serializedInterval: SerializedIntervalDelta) {
-		if (!this.isCollaborating) {
-			return;
-		}
-		if (serializedInterval.start !== undefined) {
-			this.addPendingChangeHelper(id, this.pendingChangesStart, serializedInterval);
-		}
-		if (serializedInterval.end !== undefined) {
-			this.addPendingChangeHelper(id, this.pendingChangesEnd, serializedInterval);
-		}
-	}
-
-	private addPendingChangeHelper(
-		id: string,
-		pendingChanges: Map<string, SerializedIntervalDelta[]>,
-		serializedInterval: SerializedIntervalDelta,
-	) {
-		let entries: SerializedIntervalDelta[] | undefined = pendingChanges.get(id);
-		if (!entries) {
-			entries = [];
-			pendingChanges.set(id, entries);
-		}
-		entries.push(serializedInterval);
-	}
-
-	private removePendingChange(serializedInterval: SerializedIntervalDelta) {
-		// Change ops always have an ID.
-		const { id } = getSerializedProperties(serializedInterval);
-		if (serializedInterval.start !== undefined) {
-			this.removePendingChangeHelper(id, this.pendingChangesStart, serializedInterval);
-		}
-		if (serializedInterval.end !== undefined) {
-			this.removePendingChangeHelper(id, this.pendingChangesEnd, serializedInterval);
-		}
-	}
-
-	private removePendingChangeHelper(
-		id: string,
-		pendingChanges: Map<string, SerializedIntervalDelta[]>,
-		serializedInterval: SerializedIntervalDelta,
-	) {
-		const entries = pendingChanges.get(id);
-		if (entries) {
-			const pendingChange = entries.shift();
-			if (entries.length === 0) {
-				pendingChanges.delete(id);
-			}
-			if (
-				pendingChange?.start !== serializedInterval.start ||
-				pendingChange?.end !== serializedInterval.end
-			) {
-				throw new LoggingError("Mismatch in pending changes");
-			}
-		}
-	}
-
-	private hasPendingChangeStart(id: string) {
-		const entries = this.pendingChangesStart.get(id);
-		return entries && entries.length !== 0;
-	}
-
-	private hasPendingChangeEnd(id: string) {
-		const entries = this.pendingChangesEnd.get(id);
-		return entries && entries.length !== 0;
+	private hasPendingEndpointChanges(id: string) {
+		return this.pending[id]?.endpointChanges?.empty === false;
 	}
 
 	public ackChange(
 		serializedInterval: SerializedIntervalDelta,
 		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);
-		}
-
 		// Note that the ID is in the property bag only to allow us to find the interval.
 		// This API cannot change the ID, and writing to the ID property will result in an exception. So we
 		// 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;
@@ -1405,10 +1417,8 @@ export class IntervalCollection
 			let start: number | "start" | "end" | undefined;
 			let end: number | "start" | "end" | undefined;
 			// Track pending start/end independently of one another.
-			if (!this.hasPendingChangeStart(id)) {
+			if (!this.hasPendingEndpointChanges(id)) {
 				start = serializedInterval.start;
-			}
-			if (!this.hasPendingChangeEnd(id)) {
 				end = serializedInterval.end;
 			}
 
@@ -1467,22 +1477,22 @@ export class IntervalCollection
 	 *
 	 */
 	public rebaseLocalInterval(
-		opName: string,
-		serializedInterval: SerializedIntervalDelta,
-		localSeq: number,
+		localOpMetadata: IntervalAddLocalMetadata | IntervalChangeLocalMetadata,
 	): SerializedIntervalDelta | undefined {
+		const original = localOpMetadata.original;
 		if (!this.client) {
 			// If there's no associated mergeTree client, the originally submitted op is still correct.
-			return serializedInterval;
+			return original;
 		}
 		if (!this.attached) {
 			throw new LoggingError("attachSequence must be called");
 		}
 
-		const { intervalType, properties, stickiness, startSide, endSide } = serializedInterval;
-		const { id } = getSerializedProperties(serializedInterval);
-		const { start: startRebased, end: endRebased } =
-			this.localSeqToRebasedInterval.get(localSeq) ?? this.computeRebasedPositions(localSeq);
+		const { localSeq } = localOpMetadata;
+		const { intervalType, properties, stickiness, startSide, endSide } = original;
+		const { id } = getSerializedProperties(original);
+		const { start: startRebased, end: endRebased } = (localOpMetadata.rebased ??=
+			this.computeRebasedPositions(localOpMetadata));
 
 		const localInterval = this.localCollection?.idIntervalIndex.getIntervalById(id);
 
@@ -1497,15 +1507,6 @@ export class IntervalCollection
 			endSide,
 		};
 
-		if (
-			opName === "change" &&
-			// eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- ?? is not logically equivalent when .hasPendingChangeStart returns false.
-			(this.hasPendingChangeStart(id) || this.hasPendingChangeEnd(id))
-		) {
-			this.removePendingChange(serializedInterval);
-			this.addPendingChange(id, rebased);
-		}
-
 		// if the interval slid off the string, rebase the op to be a noop and delete the interval.
 		if (
 			!this.options.mergeTreeReferencesCanSlideToEndpoint &&
@@ -1535,28 +1536,27 @@ export class IntervalCollection
 	private getSlideToSegment(
 		lref: LocalReferencePosition,
 		slidingPreference: SlidingPreference,
-	): { segment: ISegment | undefined; offset: number | undefined } | undefined {
+	): { segment: ISegment; offset: number } | undefined {
 		if (!this.client) {
 			throw new LoggingError("client does not exist");
 		}
-		const segoff: { segment: ISegmentInternal | undefined; offset: number | undefined } = {
-			segment: lref.getSegment(),
+		const segment: ISegmentInternal | undefined = lref.getSegment();
+		if (segment === undefined) {
+			return undefined;
+		}
+		const segoff = {
+			segment,
 			offset: lref.getOffset(),
 		};
-		if (segoff.segment?.localRefs?.has(lref) !== true) {
+		if (segoff.segment.localRefs?.has(lref) !== true) {
 			return undefined;
 		}
-		const newSegoff = getSlideToSegoff(
+		return getSlideToSegoff(
 			segoff,
 			slidingPreference,
 			undefined,
 			this.options.mergeTreeReferencesCanSlideToEndpoint,
 		);
-		const value: { segment: ISegment | undefined; offset: number | undefined } | undefined =
-			segoff.segment === newSegoff.segment && segoff.offset === newSegoff.offset
-				? undefined
-				: newSegoff;
-		return value;
 	}
 
 	private ackInterval(interval: SequenceIntervalClass, op: ISequencedDocumentMessage): void {
@@ -1577,19 +1577,16 @@ export class IntervalCollection
 		);
 
 		const id = interval.getIntervalId();
-		const hasPendingStartChange = this.hasPendingChangeStart(id);
-		const hasPendingEndChange = this.hasPendingChangeEnd(id);
+		const hasPendingChange = this.hasPendingEndpointChanges(id);
 
-		if (!hasPendingStartChange) {
+		if (!hasPendingChange) {
 			setSlideOnRemove(interval.start);
-		}
-
-		if (!hasPendingEndChange) {
 			setSlideOnRemove(interval.end);
 		}
 
-		const needsStartUpdate = newStart !== undefined && !hasPendingStartChange;
-		const needsEndUpdate = newEnd !== undefined && !hasPendingEndChange;
+		const needsStartUpdate =
+			newStart?.segment !== interval.start.getSegment() && !hasPendingChange;
+		const needsEndUpdate = newEnd?.segment !== interval.end.getSegment() && !hasPendingChange;
 
 		if (needsStartUpdate || needsEndUpdate) {
 			if (!this.localCollection) {
@@ -1658,7 +1655,7 @@ export class IntervalCollection
 		serializedInterval: ISerializedInterval,
 		local: boolean,
 		op: ISequencedDocumentMessage,
-		localOpMetadata: IMapMessageLocalMetadata | undefined,
+		localOpMetadata: IntervalAddLocalMetadata | undefined,
 	) {
 		const { id, properties } = getSerializedProperties(serializedInterval);
 
@@ -1667,7 +1664,6 @@ export class IntervalCollection
 				localOpMetadata !== undefined,
 				0x553 /* op metadata should be defined for local op */,
 			);
-			this.localSeqToSerializedInterval.delete(localOpMetadata.localSeq);
 			const localInterval = this.getIntervalById(id);
 			if (localInterval) {
 				this.ackInterval(localInterval, op);