@fluidframework/merge-tree 2.12.0 → 2.13.0

package/src/mergeTreeTracking.ts

@@ -5,7 +5,6 @@
 
 import { LocalReferencePosition } from "./localReference.js";
 import { ISegment } from "./mergeTreeNodes.js";
-// eslint-disable-next-line import/no-deprecated
 import { SortedSegmentSet } from "./sortedSegmentSet.js";
 
 /**
@@ -31,11 +30,9 @@ export interface ITrackingGroup {
  * @alpha
  */
 export class TrackingGroup implements ITrackingGroup {
-	// eslint-disable-next-line import/no-deprecated
 	private readonly trackedSet: SortedSegmentSet<Trackable>;
 
 	constructor() {
-		// eslint-disable-next-line import/no-deprecated
 		this.trackedSet = new SortedSegmentSet<Trackable>();
 	}
 

package/src/partialLengths.ts

@@ -9,24 +9,25 @@ import { Property, RedBlackTree } from "./collections/index.js";
 import { UnassignedSequenceNumber } from "./constants.js";
 import { MergeTree } from "./mergeTree.js";
 import {
-	// eslint-disable-next-line import/no-deprecated
 	CollaborationWindow,
 	IMergeNode,
-	// eslint-disable-next-line import/no-deprecated
-	IMoveInfo,
-	// eslint-disable-next-line import/no-deprecated
-	IRemovalInfo,
-	ISegmentLeaf,
+	ISegmentPrivate,
 	compareNumbers,
 	seqLTE,
-	toMoveInfo,
-	toRemovalInfo,
 	type MergeBlock,
 } from "./mergeTreeNodes.js";
-// eslint-disable-next-line import/no-deprecated
+import {
+	toRemovalInfo,
+	toMoveInfo,
+	// eslint-disable-next-line import/no-deprecated
+	IRemovalInfo,
+	// eslint-disable-next-line import/no-deprecated
+	IMoveInfo,
+	assertInserted,
+	isRemoved,
+} from "./segmentInfos.js";
 import { SortedSet } from "./sortedSet.js";
 
-// eslint-disable-next-line import/no-deprecated
 class PartialSequenceLengthsSet extends SortedSet<PartialSequenceLength, number> {
 	protected getKey(item: PartialSequenceLength): number {
 		return item.seq;
@@ -289,7 +290,7 @@ export class PartialSequenceLengths {
 	 */
 	public static combine(
 		block: MergeBlock,
-		// eslint-disable-next-line import/no-deprecated
+
 		collabWindow: CollaborationWindow,
 		recur = false,
 		computeLocalPartials = false,
@@ -378,7 +379,7 @@ export class PartialSequenceLengths {
 	 */
 	private static fromLeaves(
 		block: MergeBlock,
-		// eslint-disable-next-line import/no-deprecated
+
 		collabWindow: CollaborationWindow,
 		computeLocalPartials: boolean,
 	): PartialSequenceLengths {
@@ -506,10 +507,11 @@ export class PartialSequenceLengths {
 	 */
 	static accumulateMoveOverlapForExisting(
 		segmentLen: number,
-		segment: ISegmentLeaf,
+		segment: ISegmentPrivate,
 		firstGte: PartialSequenceLength,
 		clientIds: number[],
 	): void {
+		assertInserted(segment);
 		const nonInsertingClientIds = clientIds.filter((id) => id !== segment.clientId);
 
 		PartialSequenceLengths.accumulateMoveClientOverlap(
@@ -526,7 +528,7 @@ export class PartialSequenceLengths {
 			PartialSequenceLengths.accumulateMoveClientOverlap(
 				firstGte,
 				[segment.clientId],
-				segment.wasMovedOnInsert ? -segment.cachedLength : segmentLen,
+				toMoveInfo(segment)?.wasMovedOnInsert ? -segment.cachedLength : segmentLen,
 			);
 		}
 	}
@@ -539,10 +541,11 @@ export class PartialSequenceLengths {
 	 * segment
 	 */
 	private static getMoveOverlapForExisting(
-		segment: ISegmentLeaf,
+		segment: ISegmentPrivate,
 		obliterateOverlapLen: number,
 		clientIds: number[],
 	): RedBlackTree<number, IOverlapClient> {
+		assertInserted(segment);
 		const nonInsertingClientIds = clientIds.filter((id) => id !== segment.clientId);
 		const overlapObliterateClients = PartialSequenceLengths.getOverlapClients(
 			nonInsertingClientIds,
@@ -552,7 +555,9 @@ export class PartialSequenceLengths {
 		if (clientIds.length !== nonInsertingClientIds.length) {
 			overlapObliterateClients.put(segment.clientId, {
 				clientId: segment.clientId,
-				seglen: segment.wasMovedOnInsert ? -segment.cachedLength : obliterateOverlapLen,
+				seglen: toMoveInfo(segment)?.wasMovedOnInsert
+					? -segment.cachedLength
+					: obliterateOverlapLen,
 			});
 		}
 
@@ -560,7 +565,7 @@ export class PartialSequenceLengths {
 	}
 
 	private static updatePartialsAfterInsertion(
-		segment: ISegmentLeaf,
+		segment: ISegmentPrivate,
 		segmentLen: number,
 		remoteObliteratedLen: number | undefined,
 		obliterateOverlapLen: number = segmentLen,
@@ -640,12 +645,14 @@ export class PartialSequenceLengths {
 	 */
 	private static insertSegment(
 		combinedPartialLengths: PartialSequenceLengths,
-		segment: ISegmentLeaf,
+		segment: ISegmentPrivate,
 		// eslint-disable-next-line import/no-deprecated
 		removalInfo?: IRemovalInfo,
 		// eslint-disable-next-line import/no-deprecated
 		moveInfo?: IMoveInfo,
 	): void {
+		assertInserted(segment);
+
 		const removalIsLocal =
 			!!removalInfo && removalInfo.removedSeq === UnassignedSequenceNumber;
 		const moveIsLocal = !!moveInfo && moveInfo.movedSeq === UnassignedSequenceNumber;
@@ -654,7 +661,7 @@ export class PartialSequenceLengths {
 			(!!removalInfo && removalIsLocal && (!moveInfo || moveIsLocal)) ||
 			(!!moveInfo && moveIsLocal && (!removalInfo || removalIsLocal));
 		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		let seqOrLocalSeq = isLocal ? segment.localSeq! : segment.seq!;
+		let seqOrLocalSeq = isLocal ? segment.localSeq! : segment.seq;
 		let segmentLen = segment.cachedLength;
 		let clientId = segment.clientId;
 		let removeClientOverlap: number[] | undefined;
@@ -690,7 +697,7 @@ export class PartialSequenceLengths {
 			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 			seqOrLocalSeq = moveIsLocal ? moveInfo.localMovedSeq! : moveInfo.movedSeq;
 
-			if (segment.wasMovedOnInsert) {
+			if (moveInfo.wasMovedOnInsert) {
 				assert(
 					moveInfo.movedSeq !== -1,
 					0x871 /* wasMovedOnInsert should only be set on acked obliterates */,
@@ -702,7 +709,10 @@ export class PartialSequenceLengths {
 
 			const hasOverlap = moveInfo.movedClientIds.length > 1;
 			moveClientOverlap = hasOverlap ? moveInfo.movedClientIds : undefined;
-		} else if (segment.wasMovedOnInsert) {
+		} // BUG BUG: something fishy here around how/when move info is passed or not
+		// this condition only hits if it is not passed, so we can't rely on the passed move info
+		// and need to inspect the segment directly. maybe related to AB#15630.
+		else if (toMoveInfo(segment)?.wasMovedOnInsert) {
 			// if this segment was obliterated on insert, its length is only
 			// visible to the client that inserted it
 			segmentLen = 0;
@@ -775,7 +785,12 @@ export class PartialSequenceLengths {
 		// todo: the below block needs to be changed to handle obliterate, which
 		// doesn't have great support for reconnect at the moment. see ADO #3714
 		const { unsequencedRecords } = combinedPartialLengths;
-		if (unsequencedRecords && removeClientOverlap && segment.localRemovedSeq !== undefined) {
+		if (
+			unsequencedRecords &&
+			removeClientOverlap &&
+			isRemoved(segment) &&
+			segment.localRemovedSeq !== undefined
+		) {
 			const localSeq = segment.localRemovedSeq;
 			const localPartialLengthEntry: LocalPartialSequenceLength = {
 				seq: seqOrLocalSeq,
@@ -910,7 +925,7 @@ export class PartialSequenceLengths {
 		node: MergeBlock,
 		seq: number,
 		clientId: number,
-		// eslint-disable-next-line import/no-deprecated
+
 		collabWindow: CollaborationWindow,
 	): void {
 		let seqSeglen = 0;
@@ -938,10 +953,10 @@ export class PartialSequenceLengths {
 					// if this segment was moved on insert, its length should
 					// only be visible to the inserting client
 					if (
-						segment.wasMovedOnInsert &&
 						segment.seq !== undefined &&
 						moveInfo &&
-						moveInfo.movedSeq < segment.seq
+						moveInfo.movedSeq < segment.seq &&
+						moveInfo.wasMovedOnInsert
 					) {
 						remoteObliteratedLen += segment.cachedLength;
 					} else {
@@ -964,7 +979,7 @@ export class PartialSequenceLengths {
 					if (removeHappenedFirst) {
 						remoteObliteratedLen -= segment.cachedLength;
 					} else if (
-						segment.wasMovedOnInsert &&
+						moveInfo.wasMovedOnInsert &&
 						segment.seq !== UnassignedSequenceNumber &&
 						segment.seq !== undefined &&
 						moveInfo.movedSeq > segment.seq
@@ -1135,7 +1150,7 @@ export class PartialSequenceLengths {
 	}
 
 	// Clear away partial sums for sequence numbers earlier than the current window
-	// eslint-disable-next-line import/no-deprecated
+
 	private zamboni(segmentWindow: CollaborationWindow): void {
 		this.minLength += this.partialLengths.copyDown(segmentWindow.minSeq);
 		this.minSeq = segmentWindow.minSeq;

package/src/perspective.ts

@@ -7,6 +7,17 @@ import { UnassignedSequenceNumber } from "./constants.js";
 import { type MergeTree } from "./mergeTree.js";
 import { LeafAction, backwardExcursion, forwardExcursion } from "./mergeTreeNodeWalk.js";
 import { seqLTE, type ISegmentLeaf } from "./mergeTreeNodes.js";
+import {
+	isInserted,
+	isMoved,
+	isRemoved,
+	type IInsertionInfo,
+	// eslint-disable-next-line import/no-deprecated
+	type IMoveInfo,
+	// eslint-disable-next-line import/no-deprecated
+	type IRemovalInfo,
+	type SegmentWithInfo,
+} from "./segmentInfos.js";
 
 /**
  * Provides a view of a MergeTree from the perspective of a specific client at a specific sequence number.
@@ -77,7 +88,11 @@ export class PerspectiveImpl implements Perspective {
  * @param localSeq - The latest local sequence number to consider.
  * @returns true iff this segment was removed in the given perspective.
  */
-export function wasRemovedBefore(seg: ISegmentLeaf, { refSeq, localSeq }: SeqTime): boolean {
+export function wasRemovedBefore(
+	// eslint-disable-next-line import/no-deprecated
+	seg: SegmentWithInfo<IInsertionInfo & IRemovalInfo>,
+	{ refSeq, localSeq }: SeqTime,
+): boolean {
 	if (
 		seg.removedSeq === UnassignedSequenceNumber &&
 		localSeq !== undefined &&
@@ -95,7 +110,11 @@ export function wasRemovedBefore(seg: ISegmentLeaf, { refSeq, localSeq }: SeqTim
  * @param localSeq - The latest local sequence number to consider.
  * @returns true iff this segment was moved (aka obliterated) in the given perspective.
  */
-export function wasMovedBefore(seg: ISegmentLeaf, { refSeq, localSeq }: SeqTime): boolean {
+export function wasMovedBefore(
+	// eslint-disable-next-line import/no-deprecated
+	seg: SegmentWithInfo<IInsertionInfo & IMoveInfo>,
+	{ refSeq, localSeq }: SeqTime,
+): boolean {
 	if (
 		seg.movedSeq === UnassignedSequenceNumber &&
 		localSeq !== undefined &&
@@ -110,7 +129,11 @@ export function wasMovedBefore(seg: ISegmentLeaf, { refSeq, localSeq }: SeqTime)
  * See {@link wasRemovedBefore} and {@link wasMovedBefore}.
  */
 export function wasRemovedOrMovedBefore(seg: ISegmentLeaf, seqTime: SeqTime): boolean {
-	return wasRemovedBefore(seg, seqTime) || wasMovedBefore(seg, seqTime);
+	return (
+		isInserted(seg) &&
+		((isRemoved(seg) && wasRemovedBefore(seg, seqTime)) ||
+			(isMoved(seg) && wasMovedBefore(seg, seqTime)))
+	);
 }
 
 /**
@@ -124,7 +147,7 @@ export function isSegmentPresent(seg: ISegmentLeaf, seqTime: SeqTime): boolean {
 	const { refSeq, localSeq } = seqTime;
 	// If seg.seq is undefined, then this segment has existed since minSeq.
 	// It may have been moved or removed since.
-	if (seg.seq !== undefined) {
+	if (isInserted(seg)) {
 		if (seg.seq !== UnassignedSequenceNumber) {
 			if (!seqLTE(seg.seq, refSeq)) {
 				return false;

package/src/referencePositions.ts

@@ -7,6 +7,7 @@ import { SlidingPreference } from "./localReference.js";
 import { ISegment } from "./mergeTreeNodes.js";
 import { ReferenceType } from "./ops.js";
 import { PropertySet } from "./properties.js";
+import { isMergeNodeInfo } from "./segmentInfos.js";
 
 /**
  * @internal
@@ -131,6 +132,8 @@ export function compareReferencePositions(a: ReferencePosition, b: ReferencePosi
 	if (aSeg === bSeg) {
 		return a.getOffset() - b.getOffset();
 	} else {
-		return aSeg === undefined || (bSeg !== undefined && aSeg.ordinal < bSeg.ordinal) ? -1 : 1;
+		return !isMergeNodeInfo(aSeg) || (isMergeNodeInfo(bSeg) && aSeg.ordinal < bSeg.ordinal)
+			? -1
+			: 1;
 	}
 }

package/src/revertibles.ts

@@ -13,11 +13,18 @@ import { LocalReferenceCollection, LocalReferencePosition } from "./localReferen
 import { MergeTree, findRootMergeBlock } from "./mergeTree.js";
 import { IMergeTreeDeltaCallbackArgs } from "./mergeTreeDeltaCallback.js";
 import { depthFirstNodeWalk } from "./mergeTreeNodeWalk.js";
-import { toRemovalInfo, type ISegmentLeaf } from "./mergeTreeNodes.js";
+import {
+	assertSegmentLeaf,
+	isSegmentLeaf,
+	toSegmentLeaf,
+	type ISegmentLeaf,
+	type ISegmentPrivate,
+} from "./mergeTreeNodes.js";
 import { ITrackingGroup, Trackable, UnorderedTrackingGroup } from "./mergeTreeTracking.js";
 import { IJSONSegment, MergeTreeDeltaType, ReferenceType } from "./ops.js";
 import { PropertySet, matchProperties } from "./properties.js";
 import { DetachedReferencePosition } from "./referencePositions.js";
+import { toRemovalInfo } from "./segmentInfos.js";
 
 /**
  * @legacy
@@ -86,7 +93,7 @@ export interface MergeTreeWithRevert extends MergeTree {
 export type PickPartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 function findMergeTreeWithRevert(trackable: Trackable): MergeTreeWithRevert {
 	const segmentOrNode = trackable.isLeaf() ? trackable : trackable.getSegment();
-	const maybeRoot = findRootMergeBlock(segmentOrNode);
+	const maybeRoot = findRootMergeBlock(toSegmentLeaf(segmentOrNode));
 	assert(
 		maybeRoot?.mergeTree !== undefined,
 		0x5c2 /* trackable is invalid as it is not in a rooted merge tree. */,
@@ -243,7 +250,7 @@ export function discardMergeTreeDeltaRevertible(
 			t.trackingCollection.unlink(r.trackingGroup);
 			// remove untracked local references
 			if (t.trackingCollection.empty && !t.isLeaf()) {
-				const segment: ISegmentLeaf | undefined = t.getSegment();
+				const segment: ISegmentPrivate | undefined = t.getSegment();
 				segment?.localRefs?.removeLocalRef(t);
 			}
 		}
@@ -261,7 +268,7 @@ function revertLocalInsert(
 			tracked.trackingCollection.unlink(revertible.trackingGroup),
 			0x3f1 /* tracking group removed */,
 		);
-		assert(tracked.isLeaf(), 0x3f2 /* inserts must track segments */);
+		assert(isSegmentLeaf(tracked), 0x3f2 /* inserts must track segments */);
 		if (toRemovalInfo(tracked) === undefined) {
 			const start = getPosition(mergeTreeWithRevert, tracked);
 			driver.removeRange(start, start + tracked.cachedLength);
@@ -284,14 +291,14 @@ function revertLocalRemove(
 
 		assert(!tracked.isLeaf(), 0x3f4 /* removes must track local refs */);
 
-		const refSeg: ISegmentLeaf | undefined = tracked.getSegment();
+		const refSeg = tracked.getSegment();
 		let realPos = mergeTreeWithRevert.referencePositionToLocalPosition(tracked);
 
 		// References which are on EndOfStringSegment don't return detached for pos,
 		// they will return the length of the merge-tree. this case just catches
 		// random references, likely not created in the revertible flow,
 		// that are tying to be reverted for some reason.
-		if (realPos === DetachedReferencePosition || refSeg === undefined) {
+		if (realPos === DetachedReferencePosition || !isSegmentLeaf(refSeg)) {
 			throw new UsageError("Cannot insert at detached references position");
 		}
 
@@ -301,12 +308,12 @@ function revertLocalRemove(
 
 		const props = tracked.properties as RemoveSegmentRefProperties;
 		driver.insertFromSpec(realPos, props.segSpec);
-		const insertSegment: ISegmentLeaf | undefined = mergeTreeWithRevert.getContainingSegment(
+		const insertSegment = mergeTreeWithRevert.getContainingSegment(
 			realPos,
 			mergeTreeWithRevert.collabWindow.currentSeq,
 			mergeTreeWithRevert.collabWindow.clientId,
 		).segment;
-		assert(insertSegment !== undefined, 0x3f5 /* insert segment must exist at position */);
+		assertSegmentLeaf(insertSegment);
 
 		const localSlideFilter = (lref: LocalReferencePosition): boolean =>
 			(lref.properties as Partial<RemoveSegmentRefProperties>)?.referenceSpace ===
@@ -333,11 +340,10 @@ function revertLocalRemove(
 			}
 		};
 		depthFirstNodeWalk(
-			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-			insertSegment.parent!,
+			insertSegment.parent,
 			insertSegment,
 			undefined,
-			(seg: ISegmentLeaf) => {
+			(seg: ISegmentPrivate) => {
 				if (seg.localRefs?.empty === false) {
 					return seg.localRefs.walkReferences(refHandler, undefined, forward);
 				}
@@ -370,7 +376,7 @@ function revertLocalRemove(
 			tg.link(insertSegment);
 			tg.unlink(tracked);
 		}
-		const segment: ISegmentLeaf | undefined = tracked.getSegment();
+		const segment: ISegmentPrivate | undefined = tracked.getSegment();
 		segment?.localRefs?.removeLocalRef(tracked);
 	}
 }
@@ -383,7 +389,7 @@ function revertLocalAnnotate(
 	while (revertible.trackingGroup.size > 0) {
 		const tracked = revertible.trackingGroup.tracked[0];
 		const unlinked = tracked.trackingCollection.unlink(revertible.trackingGroup);
-		assert(unlinked && tracked.isLeaf(), 0x3f7 /* annotates must track segments */);
+		assert(unlinked && isSegmentLeaf(tracked), 0x3f7 /* annotates must track segments */);
 		if (toRemovalInfo(tracked) === undefined) {
 			const start = getPosition(mergeTreeWithRevert, tracked);
 			driver.annotateRange(start, start + tracked.cachedLength, revertible.propertyDeltas);

package/src/segmentGroupCollection.ts

@@ -4,16 +4,13 @@
  */
 
 import { DoublyLinkedList, walkList } from "./collections/index.js";
-// eslint-disable-next-line import/no-deprecated
 import { SegmentGroup, type ISegmentLeaf } from "./mergeTreeNodes.js";
 
 export class SegmentGroupCollection {
-	// eslint-disable-next-line import/no-deprecated
-	private readonly segmentGroups: DoublyLinkedList<SegmentGroup<ISegmentLeaf>>;
+	private readonly segmentGroups: DoublyLinkedList<SegmentGroup>;
 
 	constructor(private readonly segment: ISegmentLeaf) {
-		// eslint-disable-next-line import/no-deprecated
-		this.segmentGroups = new DoublyLinkedList<SegmentGroup<ISegmentLeaf>>();
+		this.segmentGroups = new DoublyLinkedList<SegmentGroup>();
 	}
 
 	public get size(): number {
@@ -24,19 +21,16 @@ export class SegmentGroupCollection {
 		return this.segmentGroups.empty;
 	}
 
-	// eslint-disable-next-line import/no-deprecated
-	public enqueue(segmentGroup: SegmentGroup<ISegmentLeaf>): void {
+	public enqueue(segmentGroup: SegmentGroup): void {
 		this.segmentGroups.push(segmentGroup);
 		segmentGroup.segments.push(this.segment);
 	}
 
-	// eslint-disable-next-line import/no-deprecated
-	public dequeue(): SegmentGroup<ISegmentLeaf> | undefined {
+	public dequeue(): SegmentGroup | undefined {
 		return this.segmentGroups.shift()?.data;
 	}
 
-	// eslint-disable-next-line import/no-deprecated
-	public remove?(segmentGroup: SegmentGroup<ISegmentLeaf>): boolean {
+	public remove(segmentGroup: SegmentGroup): boolean {
 		const found = this.segmentGroups.find((v) => v.data === segmentGroup);
 		if (found === undefined) {
 			return false;
@@ -45,8 +39,7 @@ export class SegmentGroupCollection {
 		return true;
 	}
 
-	// eslint-disable-next-line import/no-deprecated
-	public pop?(): SegmentGroup<ISegmentLeaf> | undefined {
+	public pop(): SegmentGroup | undefined {
 		return this.segmentGroups.pop ? this.segmentGroups.pop()?.data : undefined;
 	}
 
@@ -54,11 +47,7 @@ export class SegmentGroupCollection {
 		walkList(this.segmentGroups, (sg) => segmentGroups.enqueueOnCopy(sg.data, this.segment));
 	}
 
-	// eslint-disable-next-line import/no-deprecated
-	private enqueueOnCopy(
-		segmentGroup: SegmentGroup<ISegmentLeaf>,
-		sourceSegment: ISegmentLeaf,
-	): void {
+	private enqueueOnCopy(segmentGroup: SegmentGroup, sourceSegment: ISegmentLeaf): void {
 		this.enqueue(segmentGroup);
 		if (segmentGroup.previousProps) {
 			// duplicate the previousProps for this segment