@fluidframework/merge-tree 2.20.0 → 2.22.0

package/src/perspective.ts

@@ -35,7 +35,8 @@ export interface SeqTime {
 
 /**
  * Implementation of {@link Perspective}.
- * See {@link Client.createPerspective}.
+ * @privateRemarks
+ * TODO:AB#29765: This class does not support non-local-client perspectives, but should.
  */
 export class PerspectiveImpl implements Perspective {
 	/**
@@ -85,6 +86,8 @@ export class PerspectiveImpl implements Perspective {
  * @param seq - The latest sequence number to consider.
  * @param localSeq - The latest local sequence number to consider.
  * @returns true iff this segment was removed in the given perspective.
+ * @privateRemarks
+ * TODO:AB#29765: This function does not support non-local-client perspectives, but should.
  */
 export function wasRemovedBefore(
 	seg: SegmentWithInfo<IInsertionInfo & IRemovalInfo>,
@@ -106,6 +109,8 @@ export function wasRemovedBefore(
  * @param refSeq - The latest sequence number to consider.
  * @param localSeq - The latest local sequence number to consider.
  * @returns true iff this segment was moved (aka obliterated) in the given perspective.
+ * @privateRemarks
+ * TODO:AB#29765: This function does not support non-local-client perspectives, but should.
  */
 export function wasMovedBefore(
 	seg: SegmentWithInfo<IInsertionInfo & IMoveInfo>,
@@ -123,6 +128,8 @@ export function wasMovedBefore(
 
 /**
  * See {@link wasRemovedBefore} and {@link wasMovedBefore}.
+ * @privateRemarks
+ * TODO:AB#29765: This function does not support non-local-client perspectives, but should.
  */
 export function wasRemovedOrMovedBefore(seg: ISegmentLeaf, seqTime: SeqTime): boolean {
 	return (
@@ -138,6 +145,8 @@ export function wasRemovedOrMovedBefore(seg: ISegmentLeaf, seqTime: SeqTime): bo
  * @param seqTime - The latest sequence number and local sequence number to consider.
  * @returns true iff this segment was inserted before the given perspective,
  * and it was not removed or moved in the given perspective.
+ * @privateRemarks
+ * TODO:AB#29765: This function does not support non-local-client perspectives, but should.
  */
 export function isSegmentPresent(seg: ISegmentLeaf, seqTime: SeqTime): boolean {
 	const { refSeq, localSeq } = seqTime;

package/src/properties.ts

@@ -119,10 +119,9 @@ export function extendIfUndefined<T>(
 	extension: MapLike<T> | undefined,
 ): MapLike<T> {
 	if (extension !== undefined) {
-		// eslint-disable-next-line no-restricted-syntax
-		for (const key in extension) {
+		for (const [key, value] of Object.entries(extension)) {
 			if (base[key] === undefined) {
-				base[key] = extension[key];
+				base[key] = value;
 			}
 		}
 	}

package/src/segmentInfos.ts

@@ -310,6 +310,9 @@ export interface IMoveInfo {
 	 * If a segment is moved on insertion, its length is only ever visible to
 	 * the client that inserted the segment. This is relevant in partial length
 	 * calculations
+	 *
+	 * @privateRemarks
+	 * TODO:AB#29553: This property is not persisted in the summary, but it should be.
 	 */
 	wasMovedOnInsert: boolean;
 }

package/src/snapshotLoader.ts

@@ -140,7 +140,7 @@ export class SnapshotLoader {
 					movedClientIds: spec.movedClientIds.map((id) =>
 						this.client.getOrAddShortClientId(id),
 					),
-					// BUG? This isn't persisted
+					// TODO:AB#29553: This property should be derived from segment data, not hard-coded.
 					wasMovedOnInsert: false,
 				});
 			}

package/src/sortedSegmentSet.ts

@@ -28,11 +28,10 @@ export type SortedSegmentSetItem =
  *
  * @internal
  */
-
 export class SortedSegmentSet<
 	T extends SortedSegmentSetItem = ISegmentInternal,
-> extends SortedSet<T, string> {
-	protected getKey(item: T): string {
+> extends SortedSet<T> {
+	private getOrdinal(item: T): string {
 		const maybeRef = item as Partial<LocalReferencePosition>;
 		if (maybeRef.getSegment !== undefined && maybeRef.isLeaf?.() === false) {
 			const lref = maybeRef as LocalReferencePosition;
@@ -49,55 +48,47 @@ export class SortedSegmentSet<
 		return toMergeNodeInfo(item)?.ordinal ?? "";
 	}
 
-	protected findItemPosition(item: T): { exists: boolean; index: number } {
-		if (this.keySortedItems.length === 0) {
-			return { exists: false, index: 0 };
+	private getOffset(item: T): number {
+		const maybeRef = item as Partial<LocalReferencePosition>;
+		if (maybeRef.getSegment !== undefined && maybeRef.isLeaf?.() === false) {
+			const lref = maybeRef as LocalReferencePosition;
+			return lref.getOffset();
 		}
-		let start = 0;
-		let end = this.keySortedItems.length - 1;
-		const itemKey = this.getKey(item);
-		let index = -1;
+		return 0;
+	}
+
+	protected compare(a: T, b: T): number {
+		const aOrdinal = this.getOrdinal(a);
+		const bOrdinal = this.getOrdinal(b);
 
-		while (start <= end) {
-			index = start + Math.floor((end - start) / 2);
-			const indexKey = this.getKey(this.keySortedItems[index]);
-			if (indexKey > itemKey) {
-				if (start === index) {
-					return { exists: false, index };
-				}
-				end = index - 1;
-			} else if (indexKey < itemKey) {
-				if (index === end) {
-					return { exists: false, index: index + 1 };
-				}
-				start = index + 1;
-			} else if (indexKey === itemKey) {
-				// at this point we've found the key of the item
-				// so we need to find the index of the item instance
-				//
-				if (item === this.keySortedItems[index]) {
-					return { exists: true, index };
-				}
-				for (
-					let b = index - 1;
-					b >= 0 && this.getKey(this.keySortedItems[b]) === itemKey;
-					b--
-				) {
-					if (this.keySortedItems[b] === item) {
-						return { exists: true, index: b };
-					}
-				}
-				for (
-					index + 1;
-					index < this.keySortedItems.length &&
-					this.getKey(this.keySortedItems[index]) === itemKey;
-					index++
-				) {
-					if (this.keySortedItems[index] === item) {
-						return { exists: true, index };
-					}
-				}
-				return { exists: false, index };
+		if (aOrdinal < bOrdinal) {
+			return -1;
+		}
+		if (aOrdinal > bOrdinal) {
+			return 1;
+		}
+		return this.getOffset(a) - this.getOffset(b);
+	}
+
+	protected onFindEquivalent(item: T, startIndex: number): { exists: boolean; index: number } {
+		// SortedSegmentSet may contain multiple items with the same key (e.g. a local ref at offset 0 and the segment it is on).
+		// Items should compare as reference-equal, so we do a linear walk to find the actual item in this case.
+		let index = startIndex;
+		if (item === this.sortedItems[index]) {
+			return { exists: true, index };
+		}
+		for (let b = index - 1; b >= 0 && this.compare(item, this.sortedItems[b]) === 0; b--) {
+			if (this.sortedItems[b] === item) {
+				return { exists: true, index: b };
+			}
+		}
+		for (
+			index + 1;
+			index < this.sortedItems.length && this.compare(item, this.sortedItems[index]) === 0;
+			index++
+		) {
+			if (this.sortedItems[index] === item) {
+				return { exists: true, index };
 			}
 		}
 		return { exists: false, index };

package/src/sortedSet.ts

@@ -6,32 +6,38 @@
 /**
  * @internal
  */
-export abstract class SortedSet<T, U extends string | number> {
-	protected abstract getKey(t: T): U;
+export abstract class SortedSet<T> {
+	/**
+	 * Standard comparator semantics:
+	 * - If a \< b, return a negative number
+	 * - If a \> b, return a positive number
+	 * - If a and b are equivalent, return 0
+	 */
+	protected abstract compare(a: T, b: T): number;
 
-	protected readonly keySortedItems: T[] = [];
+	protected readonly sortedItems: T[] = [];
 
 	public get size(): number {
-		return this.keySortedItems.length;
+		return this.sortedItems.length;
 	}
 
 	public get items(): readonly T[] {
-		return this.keySortedItems;
+		return this.sortedItems;
 	}
 
 	public addOrUpdate(newItem: T, update?: (existingItem: T, newItem: T) => void): void {
 		const position = this.findItemPosition(newItem);
 		if (position.exists) {
-			update?.(this.keySortedItems[position.index], newItem);
+			update?.(this.sortedItems[position.index], newItem);
 		} else {
-			this.keySortedItems.splice(position.index, 0, newItem);
+			this.sortedItems.splice(position.index, 0, newItem);
 		}
 	}
 
 	public remove(item: T): boolean {
 		const position = this.findItemPosition(item);
 		if (position.exists) {
-			this.keySortedItems.splice(position.index, 1);
+			this.sortedItems.splice(position.index, 1);
 			return true;
 		}
 		return false;
@@ -43,31 +49,41 @@ export abstract class SortedSet<T, U extends string | number> {
 	}
 
 	protected findItemPosition(item: T): { exists: boolean; index: number } {
-		if (this.keySortedItems.length === 0) {
+		if (this.sortedItems.length === 0) {
 			return { exists: false, index: 0 };
 		}
 		let start = 0;
-		let end = this.keySortedItems.length - 1;
-		const itemKey = this.getKey(item);
+		let end = this.sortedItems.length - 1;
 		let index = -1;
 
 		while (start <= end) {
 			index = start + Math.floor((end - start) / 2);
-			const indexKey = this.getKey(this.keySortedItems[index]);
-			if (indexKey > itemKey) {
+			const compareResult = this.compare(item, this.sortedItems[index]);
+			if (compareResult < 0) {
 				if (start === index) {
 					return { exists: false, index };
 				}
 				end = index - 1;
-			} else if (indexKey < itemKey) {
+			} else if (compareResult > 0) {
 				if (index === end) {
 					return { exists: false, index: index + 1 };
 				}
 				start = index + 1;
-			} else if (indexKey === itemKey) {
-				return { exists: true, index };
+			} else if (compareResult === 0) {
+				return this.onFindEquivalent(item, index);
 			}
 		}
 		return { exists: false, index };
 	}
+
+	/**
+	 * Invoked when `findItemPosition` finds an equivalent item (i.e. `compare` returns 0 between that item and the search item).
+	 *
+	 * By default, `SortedSet` assumes that equivalent items are equal and returns the found index.
+	 * @param item - The item that is being searched for (argument to `findItemPosition`)
+	 * @param index - The index of the equivalent item in the sorted set
+	 */
+	protected onFindEquivalent(item: T, index: number): { exists: boolean; index: number } {
+		return { exists: true, index };
+	}
 }