@fluidframework/merge-tree 2.1.0-276985 → 2.1.0

package/src/partialLengths.ts

@@ -33,7 +33,7 @@ class PartialSequenceLengthsSet extends SortedSet<PartialSequenceLength, number>
 	public addOrUpdate(
 		newItem: PartialSequenceLength,
 		update?: (existingItem: PartialSequenceLength, newItem: PartialSequenceLength) => void,
-	) {
+	): void {
 		const prev = this.latestLeq(newItem.seq);
 
 		if (prev?.seq !== newItem.seq) {
@@ -92,15 +92,21 @@ class PartialSequenceLengthsSet extends SortedSet<PartialSequenceLength, number>
 		const mindex = this.latestLeqIndex(minSeq);
 		let minLength = 0;
 		if (mindex >= 0) {
-			minLength = this.keySortedItems[mindex].len;
+			// TODO Non null asserting, why is this not null?
+			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+			minLength = this.keySortedItems[mindex]!.len;
 			const seqCount = this.size;
 			if (mindex <= seqCount - 1) {
 				// Still some entries remaining
 				const remainingCount = seqCount - mindex - 1;
 				// Copy down
 				for (let i = 0; i < remainingCount; i++) {
-					this.keySortedItems[i] = this.keySortedItems[i + mindex + 1];
-					this.keySortedItems[i].len -= minLength;
+					// TODO Non null asserting, why is this not null?
+					// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+					this.keySortedItems[i] = this.keySortedItems[i + mindex + 1]!;
+					// TODO Non null asserting, why is this not null?
+					// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+					this.keySortedItems[i]!.len -= minLength;
 				}
 				this.keySortedItems.length = remainingCount;
 			}
@@ -301,7 +307,9 @@ export class PartialSequenceLengths {
 		let hasInternalChild = false;
 		const childPartials: PartialSequenceLengths[] = [];
 		for (let i = 0; i < block.childCount; i++) {
-			const child = block.children[i];
+			// TODO Non null asserting, why is this not null?
+			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+			const child = block.children[i]!;
 			if (!child.isLeaf()) {
 				hasInternalChild = true;
 				if (recur) {
@@ -335,7 +343,9 @@ export class PartialSequenceLengths {
 			const childOverlapRemoves: LocalPartialSequenceLength[][] = [];
 			for (let i = 0; i < childPartialsLen; i++) {
 				const { segmentCount, minLength, partialLengths, unsequencedRecords } =
-					childPartials[i];
+					// TODO Non null asserting, why is this not null?
+					// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+					childPartials[i]!;
 				combinedPartialLengths.segmentCount += segmentCount;
 				combinedPartialLengths.minLength += minLength;
 				childPartialLengths.push(partialLengths.items as PartialSequenceLength[]);
@@ -352,7 +362,7 @@ export class PartialSequenceLengths {
 			if (computeLocalPartials) {
 				combinedPartialLengths.unsequencedRecords = {
 					partialLengths: mergePartialLengths(childUnsequencedPartialLengths),
-					overlappingRemoves: Array.from(mergeSortedListsBySeq(childOverlapRemoves)),
+					overlappingRemoves: [...mergeSortedListsBySeq(childOverlapRemoves)],
 					cachedOverlappingByRefSeq: new Map(),
 				};
 			}
@@ -371,8 +381,8 @@ export class PartialSequenceLengths {
 	}
 
 	/**
-	 * @returns a PartialSequenceLengths structure which tracks only lengths of leaf children of the provided
-	 * MergeBlock.
+	 * Creates and returns a PartialSequenceLengths structure that tracks the lengths of only the
+	 * leaf children of the provided MergeBlock.
 	 */
 	private static fromLeaves(
 		block: MergeBlock,
@@ -387,7 +397,9 @@ export class PartialSequenceLengths {
 		combinedPartialLengths.segmentCount = block.childCount;
 
 		for (let i = 0; i < block.childCount; i++) {
-			const child = block.children[i];
+			// TODO Non null asserting, why is this not null?
+			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+			const child = block.children[i]!;
 			if (child.isLeaf()) {
 				// Leaf segment
 				const segment = child;
@@ -438,7 +450,10 @@ export class PartialSequenceLengths {
 		return combinedPartialLengths;
 	}
 
-	private static getOverlapClients(overlapClientIds: number[], seglen: number) {
+	private static getOverlapClients(
+		overlapClientIds: number[],
+		seglen: number,
+	): RedBlackTree<number, IOverlapClient> {
 		const bst = new RedBlackTree<number, IOverlapClient>(compareNumbers);
 		for (const clientId of overlapClientIds) {
 			bst.put(clientId, { clientId, seglen });
@@ -450,14 +465,14 @@ export class PartialSequenceLengths {
 		partialLength: PartialSequenceLength,
 		overlapRemoveClientIds: number[],
 		seglen: number,
-	) {
+	): void {
 		if (partialLength.overlapRemoveClients) {
 			for (const clientId of overlapRemoveClientIds) {
 				const overlapClientNode = partialLength.overlapRemoveClients.get(clientId);
-				if (!overlapClientNode) {
-					partialLength.overlapRemoveClients.put(clientId, { clientId, seglen });
-				} else {
+				if (overlapClientNode) {
 					overlapClientNode.data.seglen += seglen;
+				} else {
+					partialLength.overlapRemoveClients.put(clientId, { clientId, seglen });
 				}
 			}
 		} else {
@@ -472,14 +487,14 @@ export class PartialSequenceLengths {
 		partialLength: PartialSequenceLength,
 		overlapMoveClientIds: number[],
 		seglen: number,
-	) {
+	): void {
 		if (partialLength.overlapObliterateClients) {
 			for (const clientId of overlapMoveClientIds) {
 				const overlapClientNode = partialLength.overlapObliterateClients.get(clientId);
-				if (!overlapClientNode) {
-					partialLength.overlapObliterateClients.put(clientId, { clientId, seglen });
-				} else {
+				if (overlapClientNode) {
 					overlapClientNode.data.seglen += seglen;
+				} else {
+					partialLength.overlapObliterateClients.put(clientId, { clientId, seglen });
 				}
 			}
 		} else {
@@ -504,7 +519,7 @@ export class PartialSequenceLengths {
 		segment: ISegment,
 		firstGte: PartialSequenceLength,
 		clientIds: number[],
-	) {
+	): void {
 		const nonInsertingClientIds = clientIds.filter((id) => id !== segment.clientId);
 
 		PartialSequenceLengths.accumulateMoveClientOverlap(
@@ -527,6 +542,8 @@ export class PartialSequenceLengths {
 	}
 
 	/**
+	 * Tracks which clients have made concurrent obliterates.
+	 *
 	 * @param obliterateOverlapLen - Length of segment with overlap
 	 * @param clientIds - Ids of clients that have concurrently obliterated this
 	 * segment
@@ -562,7 +579,7 @@ export class PartialSequenceLengths {
 		clientId: number,
 		removeClientOverlap: number[] | undefined,
 		moveClientOverlap: number[] | undefined,
-	) {
+	): void {
 		const firstGte = partials.firstGte(seq);
 
 		let partialLengthEntry: PartialSequenceLength;
@@ -636,7 +653,7 @@ export class PartialSequenceLengths {
 		segment: ISegment,
 		removalInfo?: IRemovalInfo,
 		moveInfo?: IMoveInfo,
-	) {
+	): void {
 		const removalIsLocal =
 			!!removalInfo && removalInfo.removedSeq === UnassignedSequenceNumber;
 		const moveIsLocal = !!moveInfo && moveInfo.movedSeq === UnassignedSequenceNumber;
@@ -670,13 +687,17 @@ export class PartialSequenceLengths {
 			segmentLen = -segmentLen;
 			// The client who performed the remove is always stored
 			// in the first position of removalInfo.
-			clientId = removalInfo.removedClientIds[0];
+			// TODO Non null asserting, why is this not null?
+			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+			clientId = removalInfo.removedClientIds[0]!;
 			const hasOverlap = removalInfo.removedClientIds.length > 1;
 			removeClientOverlap = hasOverlap ? removalInfo.removedClientIds : undefined;
 		} else if (moveInfo) {
 			// The client who performed the move is always stored
 			// in the first position of moveInfo.
-			clientId = moveInfo.movedClientIds[0];
+			// TODO Non null asserting, why is this not null?
+			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+			clientId = moveInfo.movedClientIds[0]!;
 
 			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 			seqOrLocalSeq = moveIsLocal ? moveInfo.localMovedSeq! : moveInfo.movedSeq;
@@ -712,7 +733,9 @@ export class PartialSequenceLengths {
 		if (moveInfo && removalInfo && removeHappenedFirst && !moveIsLocal) {
 			// The client who performed the remove is always stored
 			// in the first position of removalInfo.
-			const moveClientId = moveInfo.movedClientIds[0];
+			// TODO Non null asserting, why is this not null?
+			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+			const moveClientId = moveInfo.movedClientIds[0]!;
 			const hasOverlap = moveInfo.movedClientIds.length > 1;
 
 			PartialSequenceLengths.updatePartialsAfterInsertion(
@@ -735,7 +758,9 @@ export class PartialSequenceLengths {
 				: removalInfo.removedSeq;
 			// The client who performed the remove is always stored
 			// in the first position of removalInfo.
-			const removeClientId = removalInfo.removedClientIds[0];
+			// TODO Non null asserting, why is this not null?
+			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+			const removeClientId = removalInfo.removedClientIds[0]!;
 			const hasOverlap = removalInfo.removedClientIds.length > 1;
 
 			PartialSequenceLengths.updatePartialsAfterInsertion(
@@ -781,7 +806,11 @@ export class PartialSequenceLengths {
 				localIndexFirstGTE < unsequencedRecords.overlappingRemoves.length;
 				localIndexFirstGTE++
 			) {
-				if (unsequencedRecords.overlappingRemoves[localIndexFirstGTE].seq >= seqOrLocalSeq) {
+				if (
+					// TODO Non null asserting, why is this not null?
+					// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+					unsequencedRecords.overlappingRemoves[localIndexFirstGTE]!.seq >= seqOrLocalSeq
+				) {
 					break;
 				}
 			}
@@ -807,7 +836,7 @@ export class PartialSequenceLengths {
 		seqSeglen: number,
 		remoteObliteratedLen?: number,
 		clientId?: number,
-	) {
+	): void {
 		let seqPartialLen: PartialSequenceLength | undefined;
 		let penultPartialLen: PartialSequenceLength | undefined;
 		let pLen = partialLengths.latestLeq(seq);
@@ -822,7 +851,7 @@ export class PartialSequenceLengths {
 				penultPartialLen = pLen;
 			}
 		}
-		const len = penultPartialLen !== undefined ? penultPartialLen.len + seqSeglen : seqSeglen;
+		const len = penultPartialLen === undefined ? seqSeglen : penultPartialLen.len + seqSeglen;
 		if (seqPartialLen === undefined) {
 			seqPartialLen = {
 				clientId,
@@ -903,25 +932,16 @@ export class PartialSequenceLengths {
 		clientId: number,
 		// eslint-disable-next-line import/no-deprecated
 		collabWindow: CollaborationWindow,
-	) {
+	): void {
 		let seqSeglen = 0;
 		let remoteObliteratedLen = 0;
 		let segCount = 0;
 		// Compute length for seq across children
 		for (let i = 0; i < node.childCount; i++) {
-			const child = node.children[i];
-			if (!child.isLeaf()) {
-				const childBlock = child;
-				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-				const branchPartialLengths = childBlock.partialLengths!;
-				const partialLengths = branchPartialLengths.partialLengths;
-				const leqPartial = partialLengths.latestLeq(seq);
-				if (leqPartial && leqPartial.seq === seq) {
-					seqSeglen += leqPartial.seglen;
-					remoteObliteratedLen += leqPartial.remoteObliteratedLen ?? 0;
-				}
-				segCount += branchPartialLengths.segmentCount;
-			} else {
+			// TODO Non null asserting, why is this not null?
+			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+			const child = node.children[i]!;
+			if (child.isLeaf()) {
 				const segment = child;
 				const removalInfo = toRemovalInfo(segment);
 				const moveInfo = toMoveInfo(segment);
@@ -978,6 +998,17 @@ export class PartialSequenceLengths {
 					}
 				}
 				segCount++;
+			} else {
+				const childBlock = child;
+				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+				const branchPartialLengths = childBlock.partialLengths!;
+				const partialLengths = branchPartialLengths.partialLengths;
+				const leqPartial = partialLengths.latestLeq(seq);
+				if (leqPartial && leqPartial.seq === seq) {
+					seqSeglen += leqPartial.seglen;
+					remoteObliteratedLen += leqPartial.remoteObliteratedLen ?? 0;
+				}
+				segCount += branchPartialLengths.segmentCount;
 			}
 		}
 		this.segmentCount = segCount;
@@ -992,7 +1023,9 @@ export class PartialSequenceLengths {
 		);
 		this.clientSeqNumbers[clientId] ??= new PartialSequenceLengthsSet();
 		PartialSequenceLengths.addSeq(
-			this.clientSeqNumbers[clientId],
+			// TODO Non null asserting, why is this not null?
+			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+			this.clientSeqNumbers[clientId]!,
 			seq,
 			seqSeglen + remoteObliteratedLen,
 			undefined,
@@ -1015,15 +1048,19 @@ export class PartialSequenceLengths {
 	 * Note: the local case (where `localSeq !== undefined`) is only supported on a PartialSequenceLength object
 	 * constructed with `computeLocalPartials` set to true and not subsequently updated with `update`.
 	 */
-	public getPartialLength(refSeq: number, clientId: number, localSeq?: number) {
+	public getPartialLength(refSeq: number, clientId: number, localSeq?: number): number {
 		let pLen = this.minLength;
 		const cliLatestIndex = this.cliLatest(clientId);
-		const cliSeq = this.clientSeqNumbers[clientId];
+		// TODO Non null asserting, why is this not null?
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		const cliSeq = this.clientSeqNumbers[clientId]!;
 		pLen += this.partialLengths.latestLeq(refSeq)?.len ?? 0;
 
 		if (localSeq === undefined) {
 			if (cliLatestIndex >= 0) {
-				const cliLatest = cliSeq.items[cliLatestIndex];
+				// TODO Non null asserting, why is this not null?
+				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+				const cliLatest = cliSeq.items[cliLatestIndex]!;
 				if (cliLatest.seq > refSeq) {
 					// The client has local edits after refSeq, add in the length adjustments
 					pLen += cliLatest.len;
@@ -1103,19 +1140,21 @@ export class PartialSequenceLengths {
 		return overlap?.len ?? 0;
 	}
 
-	public toString(glc?: (id: number) => string, indentCount = 0) {
+	public toString(glc?: (id: number) => string, indentCount = 0): string {
 		let buf = "";
 		for (const partial of this.partialLengths.items) {
 			buf += `(${partial.seq},${partial.len}) `;
 		}
 
-		// eslint-disable-next-line @typescript-eslint/no-for-in-array, no-restricted-syntax
+		// TODO Non null asserting, why is this not null?
+		// eslint-disable-next-line @typescript-eslint/no-for-in-array, no-restricted-syntax, guard-for-in
 		for (const clientId in this.clientSeqNumbers) {
-			if (this.clientSeqNumbers[clientId].size > 0) {
+			const seqNumber = this.clientSeqNumbers[clientId];
+			if (seqNumber !== undefined && seqNumber.size > 0) {
 				buf += `Client `;
 				buf += glc ? `${glc(+clientId)}` : `${clientId}`;
 				buf += "[";
-				for (const partial of this.clientSeqNumbers[clientId].items) {
+				for (const partial of seqNumber.items) {
 					buf += `(${partial.seq},${partial.len})`;
 				}
 				buf += "]";
@@ -1127,7 +1166,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) {
+	private zamboni(segmentWindow: CollaborationWindow): void {
 		this.minLength += this.partialLengths.copyDown(segmentWindow.minSeq);
 		this.minSeq = segmentWindow.minSeq;
 		// eslint-disable-next-line @typescript-eslint/no-for-in-array, guard-for-in, no-restricted-syntax
@@ -1139,14 +1178,16 @@ export class PartialSequenceLengths {
 		}
 	}
 
-	private addClientSeqNumber(clientId: number, seq: number, seglen: number) {
+	private addClientSeqNumber(clientId: number, seq: number, seglen: number): void {
 		this.clientSeqNumbers[clientId] ??= new PartialSequenceLengthsSet();
-		const cli = this.clientSeqNumbers[clientId];
+		// TODO Non null asserting, why is this not null?
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		const cli = this.clientSeqNumbers[clientId]!;
 		cli.addOrUpdate({ seq, len: 0, seglen });
 	}
 
 	// Assumes sequence number already coalesced and that this is called in increasing `seq` order.
-	private addClientSeqNumberFromPartial(partialLength: PartialSequenceLength) {
+	private addClientSeqNumberFromPartial(partialLength: PartialSequenceLength): void {
 		const seglen = partialLength.seglen + (partialLength.remoteObliteratedLen ?? 0);
 		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 		this.addClientSeqNumber(partialLength.clientId!, partialLength.seq, seglen);
@@ -1174,7 +1215,7 @@ export class PartialSequenceLengths {
 		return this.clientSeqNumbers[clientId]?.latestLeq(refSeq);
 	}
 
-	private cliLatest(clientId: number) {
+	private cliLatest(clientId: number): number {
 		const cliSeqs = this.clientSeqNumbers[clientId];
 		return cliSeqs && cliSeqs.size > 0 ? cliSeqs.size - 1 : -1;
 	}
@@ -1268,7 +1309,7 @@ export function verifyExpectedPartialLengths(
 	refSeq: number,
 	clientId: number,
 	localSeq?: number,
-) {
+): void {
 	if (
 		(!mergeTree.collabWindow.collaborating || mergeTree.collabWindow.clientId === clientId) &&
 		(node.isLeaf() || localSeq === undefined)
@@ -1301,7 +1342,7 @@ export function verifyExpectedPartialLengths(
 	}
 }
 
-export function verifyPartialLengths(partialSeqLengths: PartialSequenceLengths) {
+export function verifyPartialLengths(partialSeqLengths: PartialSequenceLengths): void {
 	if (partialSeqLengths["clientSeqNumbers"]) {
 		for (const cliSeq of partialSeqLengths["clientSeqNumbers"]) {
 			if (cliSeq) {
@@ -1343,6 +1384,27 @@ function cloneOverlapRemoveClients(
 	return newTree;
 }
 
+function combineForOverlapClients(
+	treeA: RedBlackTree<number, IOverlapClient> | undefined,
+	treeB: RedBlackTree<number, IOverlapClient> | undefined,
+): RedBlackTree<number, IOverlapClient> | undefined {
+	if (treeA) {
+		if (treeB) {
+			treeB.map((bProp: Property<number, IOverlapClient>) => {
+				const aProp = treeA.get(bProp.key);
+				if (aProp) {
+					aProp.data.seglen += bProp.data.seglen;
+				} else {
+					treeA.put(bProp.data.clientId, { ...bProp.data });
+				}
+				return true;
+			});
+		}
+	} else {
+		return cloneOverlapRemoveClients(treeB);
+	}
+}
+
 /**
  * Combines the `overlapRemoveClients` and `overlapObliterateClients` fields of
  * two `PartialSequenceLength` objects, modifying the first PartialSequenceLength's
@@ -1350,34 +1412,19 @@ function cloneOverlapRemoveClients(
  *
  * Combination is performed additively on `seglen` on a per-client basis.
  */
-export function combineOverlapClients(a: PartialSequenceLength, b: PartialSequenceLength) {
-	function combine(
-		treeA: RedBlackTree<number, IOverlapClient> | undefined,
-		treeB: RedBlackTree<number, IOverlapClient> | undefined,
-	): RedBlackTree<number, IOverlapClient> | undefined {
-		if (treeA) {
-			if (treeB) {
-				treeB.map((bProp: Property<number, IOverlapClient>) => {
-					const aProp = treeA.get(bProp.key);
-					if (aProp) {
-						aProp.data.seglen += bProp.data.seglen;
-					} else {
-						treeA.put(bProp.data.clientId, { ...bProp.data });
-					}
-					return true;
-				});
-			}
-		} else {
-			return cloneOverlapRemoveClients(treeB);
-		}
-	}
-
-	const overlapRemoveClients = combine(a.overlapRemoveClients, b.overlapRemoveClients);
+export function combineOverlapClients(
+	a: PartialSequenceLength,
+	b: PartialSequenceLength,
+): void {
+	const overlapRemoveClients = combineForOverlapClients(
+		a.overlapRemoveClients,
+		b.overlapRemoveClients,
+	);
 	if (overlapRemoveClients) {
 		a.overlapRemoveClients = overlapRemoveClients;
 	}
 
-	const overlapObliterateClients = combine(
+	const overlapObliterateClients = combineForOverlapClients(
 		a.overlapObliterateClients,
 		b.overlapObliterateClients,
 	);
@@ -1433,7 +1480,7 @@ function mergeSortedListsBySeq<T extends PartialSequenceLength>(lists: T[][]): I
 		private readonly nextSmallestIndex: number[];
 
 		constructor(private readonly sublists: T[][]) {
-			this.nextSmallestIndex = new Array(sublists.length);
+			this.nextSmallestIndex = Array.from({ length: sublists.length });
 			for (let i = 0; i < sublists.length; i++) {
 				this.nextSmallestIndex[i] = 0;
 			}
@@ -1444,9 +1491,16 @@ function mergeSortedListsBySeq<T extends PartialSequenceLength>(lists: T[][]): I
 			let currentMin: T | undefined;
 			let currentMinIndex: number | undefined;
 			for (let i = 0; i < len; i++) {
-				const candidateIndex = this.nextSmallestIndex[i];
-				if (candidateIndex < this.sublists[i].length) {
-					const candidate = this.sublists[i][candidateIndex];
+				// TODO Non null asserting, why is this not null?
+				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+				const candidateIndex = this.nextSmallestIndex[i]!;
+				// TODO Non null asserting, why is this not null?
+				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+				const list = this.sublists[i]!;
+				if (candidateIndex < list.length) {
+					// TODO Non null asserting, why is this not null?
+					// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+					const candidate = list[candidateIndex]!;
 					if (!currentMin || candidate.seq < currentMin.seq) {
 						currentMin = candidate;
 						currentMinIndex = i;
@@ -1470,7 +1524,9 @@ function mergeSortedListsBySeq<T extends PartialSequenceLength>(lists: T[][]): I
 function insertIntoList<T>(list: T[], index: number, elem: T): void {
 	if (index < list.length) {
 		for (let k = list.length; k > index; k--) {
-			list[k] = list[k - 1];
+			// TODO Non null asserting, why is this not null?
+			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+			list[k] = list[k - 1]!;
 		}
 		list[index] = elem;
 	} else {

package/src/perspective.ts

@@ -49,7 +49,7 @@ export class PerspectiveImpl implements Perspective {
 	 */
 	public nextSegment(segment: ISegment, forward: boolean = true): ISegment {
 		let next: ISegment | undefined;
-		const action = (seg: ISegment) => {
+		const action = (seg: ISegment): boolean | undefined => {
 			if (isSegmentPresent(seg, this._seqTime)) {
 				next = seg;
 				return LeafAction.Exit;
@@ -60,6 +60,7 @@ export class PerspectiveImpl implements Perspective {
 	}
 
 	/**
+	 * Finds the segment prior to the given segment.
 	 * @param segment - The segment to start from.
 	 * @returns the previous segment, or the start of the tree if there is no previous segment.
 	 * @remarks This is a convenient equivalent to calling `nextSegment(segment, false)`.
@@ -70,6 +71,7 @@ export class PerspectiveImpl implements Perspective {
 }
 
 /**
+ * Determines if the given segment was removed before the given perspective.
  * @param seg - The segment to check.
  * @param seq - The latest sequence number to consider.
  * @param localSeq - The latest local sequence number to consider.
@@ -87,6 +89,7 @@ export function wasRemovedBefore(seg: ISegment, { refSeq, localSeq }: SeqTime):
 }
 
 /**
+ * Determines if the given segment was moved before the given perspective.
  * @param seg - The segment to check.
  * @param refSeq - The latest sequence number to consider.
  * @param localSeq - The latest local sequence number to consider.
@@ -111,7 +114,7 @@ export function wasRemovedOrMovedBefore(seg: ISegment, seqTime: SeqTime): boolea
 }
 
 /**
- *
+ * Determines if the given segment is present in the given perspective.
  * @param seg - The segment to check.
  * @param seqTime - The latest sequence number and local sequence number to consider.
  * @returns true iff this segment was inserted before the given perspective,
@@ -126,13 +129,13 @@ export function isSegmentPresent(seg: ISegment, seqTime: SeqTime): boolean {
 			if (!seqLTE(seg.seq, refSeq)) {
 				return false;
 			}
-		} else if (seg.localSeq !== undefined) {
-			// seg.seq === UnassignedSequenceNumber
+		} else if (
+			seg.localSeq !== undefined && // seg.seq === UnassignedSequenceNumber
 			// If the current perspective does not include local sequence numbers,
 			// then this segment does not exist yet.
-			if (localSeq === undefined || seg.localSeq > localSeq) {
-				return false;
-			}
+			(localSeq === undefined || seg.localSeq > localSeq)
+		) {
+			return false;
 		}
 	}
 	if (wasRemovedOrMovedBefore(seg, seqTime)) {