@fluidframework/merge-tree 2.1.0-276985 → 2.1.0

package/src/properties.ts

@@ -23,12 +23,18 @@ export interface MapLike<T> {
  * @legacy
  * @alpha
  */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type PropertySet = MapLike<any>;
 
 /**
+ * Compares two PropertySets for equality.
+ *
  * @internal
  */
-export function matchProperties(a: PropertySet | undefined, b: PropertySet | undefined) {
+export function matchProperties(
+	a: PropertySet | undefined,
+	b: PropertySet | undefined,
+): boolean {
 	if (!a && !b) {
 		return true;
 	}
@@ -44,6 +50,7 @@ export function matchProperties(a: PropertySet | undefined, b: PropertySet | und
 		if (b?.[key] === undefined) {
 			return false;
 		} else if (typeof b[key] === "object") {
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
 			if (!matchProperties(a?.[key], b[key])) {
 				return false;
 			}
@@ -56,20 +63,23 @@ export function matchProperties(a: PropertySet | undefined, b: PropertySet | und
 }
 
 /**
- * @deprecated This functionality was not intended for public export and will
- * be removed in a future release.
+ * Adds properties from one PropertySet to another.
+ *
  * @internal
  */
-export function extend<T>(base: MapLike<T>, extension: MapLike<T> | undefined) {
+export function extend<T>(base: MapLike<T>, extension: MapLike<T> | undefined): MapLike<T> {
 	if (extension !== undefined) {
 		// eslint-disable-next-line guard-for-in, no-restricted-syntax
 		for (const key in extension) {
 			const v = extension[key];
+			// TODO Non null asserting, why is this not null?
 			if (v === null) {
 				// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
 				delete base[key];
 			} else {
-				base[key] = v;
+				// Non null aseerting here since we are checking if v is not null
+				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+				base[key] = v!;
 			}
 		}
 	}
@@ -77,11 +87,11 @@ export function extend<T>(base: MapLike<T>, extension: MapLike<T> | undefined) {
 }
 
 /**
- * @deprecated This functionality was not intended for public export and will
- * be removed in a future release.
+ * Clones properties in a given PropertySet into a new PropertySet.
+ *
  * @internal
  */
-export function clone<T>(extension: MapLike<T> | undefined) {
+export function clone<T>(extension: MapLike<T> | undefined): MapLike<T> | undefined {
 	if (extension === undefined) {
 		return undefined;
 	}
@@ -90,37 +100,46 @@ export function clone<T>(extension: MapLike<T> | undefined) {
 	for (const key in extension) {
 		const v = extension[key];
 		if (v !== null) {
-			cloneMap[key] = v;
+			// If `v` is undefined, undefined must have been assignable to `T`.
+			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+			cloneMap[key] = v!;
 		}
 	}
 	return cloneMap;
 }
 
 /**
- * @deprecated This functionality was not intended for public export and will
- * be removed in a future release.
+ * Add properties in one PropertySet to another PropertySet. If the PropertySet we are adding
+ * to does not exist, create one.
+ *
  * @internal
  */
 export function addProperties(
 	oldProps: PropertySet | undefined,
 	newProps: PropertySet,
 ): PropertySet {
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	const _oldProps = oldProps ?? createMap<any>();
 	extend(_oldProps, newProps);
 	return { ..._oldProps };
 }
 
 /**
- * @deprecated This functionality was not intended for public export and will
- * be removed in a future release.
+ * Replace values of undefined in one PropertySet with values for the same key from another PropertySet.
+ *
  * @internal
  */
-export function extendIfUndefined<T>(base: MapLike<T>, extension: MapLike<T> | undefined) {
+export function extendIfUndefined<T>(
+	base: MapLike<T>,
+	extension: MapLike<T> | undefined,
+): MapLike<T> {
 	if (extension !== undefined) {
 		// eslint-disable-next-line no-restricted-syntax
 		for (const key in extension) {
 			if (base[key] === undefined) {
-				base[key] = extension[key];
+				// TODO Non null asserting, why is this not null?
+				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+				base[key] = extension[key]!;
 			}
 		}
 	}
@@ -128,11 +147,10 @@ export function extendIfUndefined<T>(base: MapLike<T>, extension: MapLike<T> | u
 }
 
 /**
- * @deprecated This functionality was not intended for public export and will
- * be removed in a future release.
+ * Create a MapLike with good performance.
+ *
  * @internal
  */
-// Create a MapLike with good performance.
 export function createMap<T>(): MapLike<T> {
 	return Object.create(null) as MapLike<T>;
 }

package/src/referencePositions.ts

@@ -18,6 +18,7 @@ export const reservedTileLabelsKey = "referenceTileLabels";
 export const reservedRangeLabelsKey = "referenceRangeLabels";
 
 /**
+ * Determines if the given reference type includes the given flags.
  * @internal
  */
 export function refTypeIncludesFlag(
@@ -30,6 +31,7 @@ export function refTypeIncludesFlag(
 }
 
 /**
+ * Gets the tile labels stored in the given reference position.
  * @legacy
  * @alpha
  */
@@ -39,6 +41,7 @@ export const refGetTileLabels = (refPos: ReferencePosition): string[] | undefine
 		: undefined;
 
 /**
+ * Determines if a reference position has the given tile label.
  * @legacy
  * @alpha
  */
@@ -48,6 +51,7 @@ export function refHasTileLabel(refPos: ReferencePosition, label: string): boole
 }
 
 /**
+ * Determines if a reference position has any tile labels.
  * @internal
  */
 export function refHasTileLabels(refPos: ReferencePosition): boolean {
@@ -108,6 +112,7 @@ export interface ReferencePosition {
 export const DetachedReferencePosition = -1;
 
 /**
+ * Finds the minimum reference position.
  * @internal
  */
 export function minReferencePosition<T extends ReferencePosition>(a: T, b: T): T {
@@ -115,6 +120,7 @@ export function minReferencePosition<T extends ReferencePosition>(a: T, b: T): T
 }
 
 /**
+ * Finds the maximum reference position.
  * @internal
  */
 export function maxReferencePosition<T extends ReferencePosition>(a: T, b: T): T {
@@ -122,6 +128,7 @@ export function maxReferencePosition<T extends ReferencePosition>(a: T, b: T): T
 }
 
 /**
+ * Compares two reference positions.
  * @internal
  */
 export function compareReferencePositions(a: ReferencePosition, b: ReferencePosition): number {

package/src/revertibles.ts

@@ -114,15 +114,17 @@ function findMergeTreeWithRevert(trackable: Trackable): MergeTreeWithRevert {
 function appendLocalInsertToRevertibles(
 	deltaArgs: IMergeTreeDeltaCallbackArgs,
 	revertibles: MergeTreeDeltaRevertible[],
-) {
+): MergeTreeDeltaRevertible[] {
 	if (revertibles[revertibles.length - 1]?.operation !== MergeTreeDeltaType.INSERT) {
 		revertibles.push({
 			operation: MergeTreeDeltaType.INSERT,
 			trackingGroup: new UnorderedTrackingGroup(),
 		});
 	}
-	const last = revertibles[revertibles.length - 1];
-	deltaArgs.deltaSegments.forEach((t) => last.trackingGroup.link(t.segment));
+	// TODO Non null asserting, why is this not null?
+	// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+	const last = revertibles[revertibles.length - 1]!;
+	for (const t of deltaArgs.deltaSegments) last.trackingGroup.link(t.segment);
 
 	return revertibles;
 }
@@ -130,20 +132,24 @@ function appendLocalInsertToRevertibles(
 function appendLocalRemoveToRevertibles(
 	deltaArgs: IMergeTreeDeltaCallbackArgs,
 	revertibles: MergeTreeDeltaRevertible[],
-) {
+): MergeTreeDeltaRevertible[] {
 	if (revertibles[revertibles.length - 1]?.operation !== MergeTreeDeltaType.REMOVE) {
 		revertibles.push({
 			operation: MergeTreeDeltaType.REMOVE,
 			trackingGroup: new UnorderedTrackingGroup(),
 		});
 	}
-	const last = revertibles[revertibles.length - 1];
+	// TODO Non null asserting, why is this not null?
+	// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+	const last = revertibles[revertibles.length - 1]!;
 
-	const mergeTreeWithRevert = findMergeTreeWithRevert(deltaArgs.deltaSegments[0].segment);
+	// TODO Non null asserting, why is this not null?
+	// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+	const mergeTreeWithRevert = findMergeTreeWithRevert(deltaArgs.deltaSegments[0]!.segment);
 
-	deltaArgs.deltaSegments.forEach((t) => {
+	for (const t of deltaArgs.deltaSegments) {
 		const props: RemoveSegmentRefProperties = {
-			segSpec: t.segment.toJSONObject(),
+			segSpec: t.segment.toJSONObject() as IJSONSegment,
 			referenceSpace: "mergeTreeDeltaRevertible",
 		};
 		const ref = mergeTreeWithRevert.createLocalReferencePosition(
@@ -153,22 +159,22 @@ function appendLocalRemoveToRevertibles(
 			props,
 		);
 		ref.callbacks = mergeTreeWithRevert.__mergeTreeRevertible.refCallbacks;
-		t.segment.trackingCollection.trackingGroups.forEach((tg) => {
+		for (const tg of t.segment.trackingCollection.trackingGroups) {
 			tg.link(ref);
 			tg.unlink(t.segment);
-		});
+		}
 
 		last.trackingGroup.link(ref);
-	});
+	}
 	return revertibles;
 }
 
 function appendLocalAnnotateToRevertibles(
 	deltaArgs: IMergeTreeDeltaCallbackArgs,
 	revertibles: MergeTreeDeltaRevertible[],
-) {
+): MergeTreeDeltaRevertible[] {
 	let last = revertibles[revertibles.length - 1];
-	deltaArgs.deltaSegments.forEach((ds) => {
+	for (const ds of deltaArgs.deltaSegments) {
 		const propertyDeltas = ds.propertyDeltas;
 		if (propertyDeltas) {
 			if (
@@ -186,64 +192,76 @@ function appendLocalAnnotateToRevertibles(
 				revertibles.push(last);
 			}
 		}
-	});
+	}
 	return revertibles;
 }
 
 /**
+ * Appends a merge tree delta to the list of revertibles.
+ *
  * @legacy
  * @alpha
  */
 export function appendToMergeTreeDeltaRevertibles(
 	deltaArgs: IMergeTreeDeltaCallbackArgs,
 	revertibles: MergeTreeDeltaRevertible[],
-) {
+): void {
 	if (deltaArgs.deltaSegments.length === 0) {
 		return;
 	}
 	switch (deltaArgs.operation) {
-		case MergeTreeDeltaType.INSERT:
+		case MergeTreeDeltaType.INSERT: {
 			appendLocalInsertToRevertibles(deltaArgs, revertibles);
 			break;
+		}
 
-		case MergeTreeDeltaType.REMOVE:
+		case MergeTreeDeltaType.REMOVE: {
 			appendLocalRemoveToRevertibles(deltaArgs, revertibles);
 			break;
+		}
 
-		case MergeTreeDeltaType.ANNOTATE:
+		case MergeTreeDeltaType.ANNOTATE: {
 			appendLocalAnnotateToRevertibles(deltaArgs, revertibles);
 			break;
+		}
 
-		default:
+		default: {
 			throw new UsageError("Unsupported event delta type", {
 				operation: deltaArgs.operation,
 			});
+		}
 	}
 }
 
 /**
+ * Removes all revertibles from the list of revertibles.
+ *
  * @legacy
  * @alpha
  */
-export function discardMergeTreeDeltaRevertible(revertibles: MergeTreeDeltaRevertible[]) {
-	revertibles.forEach((r) => {
-		r.trackingGroup.tracked.forEach((t) => {
+export function discardMergeTreeDeltaRevertible(
+	revertibles: MergeTreeDeltaRevertible[],
+): void {
+	for (const r of revertibles) {
+		for (const t of r.trackingGroup.tracked) {
 			t.trackingCollection.unlink(r.trackingGroup);
 			// remove untracked local references
 			if (t.trackingCollection.empty && !t.isLeaf()) {
 				t.getSegment()?.localRefs?.removeLocalRef(t);
 			}
-		});
-	});
+		}
+	}
 }
 
 function revertLocalInsert(
 	driver: MergeTreeRevertibleDriver,
 	mergeTreeWithRevert: MergeTreeWithRevert,
 	revertible: TypedRevertible<typeof MergeTreeDeltaType.INSERT>,
-) {
+): void {
 	while (revertible.trackingGroup.size > 0) {
-		const tracked = revertible.trackingGroup.tracked[0];
+		// TODO Non null asserting, why is this not null?
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		const tracked = revertible.trackingGroup.tracked[0]!;
 		assert(
 			tracked.trackingCollection.unlink(revertible.trackingGroup),
 			0x3f1 /* tracking group removed */,
@@ -260,9 +278,11 @@ function revertLocalRemove(
 	driver: MergeTreeRevertibleDriver,
 	mergeTreeWithRevert: MergeTreeWithRevert,
 	revertible: TypedRevertible<typeof MergeTreeDeltaType.REMOVE>,
-) {
+): void {
 	while (revertible.trackingGroup.size > 0) {
-		const tracked = revertible.trackingGroup.tracked[0];
+		// TODO Non null asserting, why is this not null?
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		const tracked = revertible.trackingGroup.tracked[0]!;
 
 		assert(
 			tracked.trackingCollection.unlink(revertible.trackingGroup),
@@ -295,7 +315,7 @@ function revertLocalRemove(
 		).segment;
 		assert(insertSegment !== undefined, 0x3f5 /* insert segment must exist at position */);
 
-		const localSlideFilter = (lref: LocalReferencePosition) =>
+		const localSlideFilter = (lref: LocalReferencePosition): boolean =>
 			(lref.properties as Partial<RemoveSegmentRefProperties>)?.referenceSpace ===
 			"mergeTreeDeltaRevertible";
 
@@ -303,7 +323,7 @@ function revertLocalRemove(
 			Record<"before" | "after", DoublyLinkedList<LocalReferencePosition>>
 		> = {};
 		const forward = insertSegment.ordinal < refSeg.ordinal;
-		const refHandler = (lref: LocalReferencePosition) => {
+		const refHandler = (lref: LocalReferencePosition): false | undefined => {
 			// once we reach it keep the original reference where it is
 			// we'll move tracking groups, and remove it as a last step.
 			if (tracked === lref) {
@@ -352,10 +372,10 @@ function revertLocalRemove(
 			}
 		}
 
-		tracked.trackingCollection.trackingGroups.forEach((tg) => {
+		for (const tg of tracked.trackingCollection.trackingGroups) {
 			tg.link(insertSegment);
 			tg.unlink(tracked);
-		});
+		}
 		tracked.getSegment()?.localRefs?.removeLocalRef(tracked);
 	}
 }
@@ -364,9 +384,11 @@ function revertLocalAnnotate(
 	driver: MergeTreeRevertibleDriver,
 	mergeTreeWithRevert: MergeTreeWithRevert,
 	revertible: TypedRevertible<typeof MergeTreeDeltaType.ANNOTATE>,
-) {
+): void {
 	while (revertible.trackingGroup.size > 0) {
-		const tracked = revertible.trackingGroup.tracked[0];
+		// TODO Non null asserting, why is this not null?
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		const tracked = revertible.trackingGroup.tracked[0]!;
 		const unlinked = tracked.trackingCollection.unlink(revertible.trackingGroup);
 		assert(unlinked && tracked.isLeaf(), 0x3f7 /* annotates must track segments */);
 		if (toRemovalInfo(tracked) === undefined) {
@@ -376,7 +398,7 @@ function revertLocalAnnotate(
 	}
 }
 
-function getPosition(mergeTreeWithRevert: MergeTreeWithRevert, segment: ISegment) {
+function getPosition(mergeTreeWithRevert: MergeTreeWithRevert, segment: ISegment): number {
 	return mergeTreeWithRevert.getPosition(
 		segment,
 		mergeTreeWithRevert.collabWindow.currentSeq,
@@ -385,13 +407,15 @@ function getPosition(mergeTreeWithRevert: MergeTreeWithRevert, segment: ISegment
 }
 
 /**
+ * Reverts all operations in the list of revertibles.
+ *
  * @legacy
  * @alpha
  */
 export function revertMergeTreeDeltaRevertibles(
 	driver: MergeTreeRevertibleDriver,
 	revertibles: MergeTreeDeltaRevertible[],
-) {
+): void {
 	let mergeTreeWithRevert: MergeTreeWithRevert | undefined;
 
 	while (revertibles.length > 0) {
@@ -399,19 +423,25 @@ export function revertMergeTreeDeltaRevertibles(
 		const r = revertibles.pop()!;
 		const operation = r.operation;
 		if (r.trackingGroup.size > 0) {
-			mergeTreeWithRevert ??= findMergeTreeWithRevert(r.trackingGroup.tracked[0]);
+			// TODO Non null asserting, why is this not null?
+			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+			mergeTreeWithRevert ??= findMergeTreeWithRevert(r.trackingGroup.tracked[0]!);
 			switch (operation) {
-				case MergeTreeDeltaType.INSERT:
+				case MergeTreeDeltaType.INSERT: {
 					revertLocalInsert(driver, mergeTreeWithRevert, r);
 					break;
-				case MergeTreeDeltaType.REMOVE:
+				}
+				case MergeTreeDeltaType.REMOVE: {
 					revertLocalRemove(driver, mergeTreeWithRevert, r);
 					break;
-				case MergeTreeDeltaType.ANNOTATE:
+				}
+				case MergeTreeDeltaType.ANNOTATE: {
 					revertLocalAnnotate(driver, mergeTreeWithRevert, r);
 					break;
-				default:
+				}
+				default: {
 					unreachableCase(operation);
+				}
 			}
 		}
 	}

package/src/segmentGroupCollection.ts

@@ -20,16 +20,16 @@ export class SegmentGroupCollection {
 		this.segmentGroups = new DoublyLinkedList<SegmentGroup>();
 	}
 
-	public get size() {
+	public get size(): number {
 		return this.segmentGroups.length;
 	}
 
-	public get empty() {
+	public get empty(): boolean {
 		return this.segmentGroups.empty;
 	}
 
 	// eslint-disable-next-line import/no-deprecated
-	public enqueue(segmentGroup: SegmentGroup) {
+	public enqueue(segmentGroup: SegmentGroup): void {
 		this.segmentGroups.push(segmentGroup);
 		segmentGroup.segments.push(this.segment);
 	}
@@ -54,20 +54,22 @@ export class SegmentGroupCollection {
 		return this.segmentGroups.pop ? this.segmentGroups.pop()?.data : undefined;
 	}
 
-	public copyTo(segment: ISegment) {
+	public copyTo(segment: ISegment): void {
 		walkList(this.segmentGroups, (sg) =>
 			segment.segmentGroups.enqueueOnCopy(sg.data, this.segment),
 		);
 	}
 
 	// eslint-disable-next-line import/no-deprecated
-	private enqueueOnCopy(segmentGroup: SegmentGroup, sourceSegment: ISegment) {
+	private enqueueOnCopy(segmentGroup: SegmentGroup, sourceSegment: ISegment): void {
 		this.enqueue(segmentGroup);
 		if (segmentGroup.previousProps) {
 			// duplicate the previousProps for this segment
 			const index = segmentGroup.segments.indexOf(sourceSegment);
 			if (index !== -1) {
-				segmentGroup.previousProps.push(segmentGroup.previousProps[index]);
+				// TODO Non null asserting, why is this not null?
+				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+				segmentGroup.previousProps.push(segmentGroup.previousProps[index]!);
 			}
 		}
 	}

package/src/segmentPropertiesManager.ts

@@ -9,7 +9,6 @@ import { assert } from "@fluidframework/core-utils/internal";
 
 import { UnassignedSequenceNumber, UniversalSequenceNumber } from "./constants.js";
 import { IMergeTreeAnnotateMsg } from "./ops.js";
-// eslint-disable-next-line import/no-deprecated
 import { MapLike, PropertySet, createMap } from "./properties.js";
 
 /**
@@ -17,10 +16,14 @@ import { MapLike, PropertySet, createMap } from "./properties.js";
  * @alpha
  */
 export enum PropertiesRollback {
-	/** Not in a rollback */
+	/**
+	 * Not in a rollback
+	 */
 	None,
 
-	/** Rollback */
+	/**
+	 * Rollback
+	 */
 	Rollback,
 }
 
@@ -31,23 +34,22 @@ export enum PropertiesRollback {
 export class PropertiesManager {
 	private pendingKeyUpdateCount: MapLike<number> | undefined;
 
-	public ackPendingProperties(annotateOp: IMergeTreeAnnotateMsg) {
+	public ackPendingProperties(annotateOp: IMergeTreeAnnotateMsg): void {
 		this.decrementPendingCounts(annotateOp.props);
 	}
 
-	private decrementPendingCounts(props: PropertySet) {
+	private decrementPendingCounts(props: PropertySet): void {
 		for (const [key, value] of Object.entries(props)) {
-			if (value !== undefined) {
-				if (this.pendingKeyUpdateCount?.[key] !== undefined) {
-					assert(
-						this.pendingKeyUpdateCount[key] > 0,
-						0x05c /* "Trying to update more annotate props than do exist!" */,
-					);
-					this.pendingKeyUpdateCount[key]--;
-					if (this.pendingKeyUpdateCount?.[key] === 0) {
-						// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-						delete this.pendingKeyUpdateCount[key];
-					}
+			if (value !== undefined && this.pendingKeyUpdateCount?.[key] !== undefined) {
+				assert(
+					// TODO Non null asserting, why is this not null?
+					this.pendingKeyUpdateCount[key]! > 0,
+					0x05c /* "Trying to update more annotate props than do exist!" */,
+				);
+				this.pendingKeyUpdateCount[key]--;
+				if (this.pendingKeyUpdateCount?.[key] === 0) {
+					// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+					delete this.pendingKeyUpdateCount[key];
 				}
 			}
 		}
@@ -60,7 +62,6 @@ export class PropertiesManager {
 		collaborating: boolean = false,
 		rollback: PropertiesRollback = PropertiesRollback.None,
 	): PropertySet {
-		// eslint-disable-next-line import/no-deprecated
 		this.pendingKeyUpdateCount ??= createMap<number>();
 
 		// Clean up counts for rolled back edits before modifying oldProps
@@ -97,13 +98,15 @@ export class PropertiesManager {
 				}
 			}
 
-			const previousValue: any = oldProps[key];
+			const previousValue: unknown = oldProps[key];
 			// The delta should be null if undefined, as that's how we encode delete
+			// eslint-disable-next-line unicorn/no-null
 			deltas[key] = previousValue === undefined ? null : previousValue;
 			if (newValue === null) {
 				// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
 				delete oldProps[key];
 			} else {
+				// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 				oldProps[key] = newValue;
 			}
 		}
@@ -117,27 +120,28 @@ export class PropertiesManager {
 		newManager: PropertiesManager,
 	): PropertySet | undefined {
 		if (oldProps) {
-			// eslint-disable-next-line no-param-reassign, import/no-deprecated
-			newProps ??= createMap<any>();
+			// eslint-disable-next-line no-param-reassign
+			newProps ??= createMap<unknown>();
 			if (!newManager) {
 				throw new Error("Must provide new PropertyManager");
 			}
 			for (const key of Object.keys(oldProps)) {
+				// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 				newProps[key] = oldProps[key];
 			}
-			// eslint-disable-next-line import/no-deprecated
 			newManager.pendingKeyUpdateCount = createMap<number>();
 			for (const key of Object.keys(this.pendingKeyUpdateCount!)) {
-				newManager.pendingKeyUpdateCount[key] = this.pendingKeyUpdateCount![key];
+				// TODO Non null asserting, why is this not null?
+				newManager.pendingKeyUpdateCount[key] = this.pendingKeyUpdateCount![key]!;
 			}
 		}
 		return newProps;
 	}
 
 	/**
-	 * @returns whether all valid (i.e. defined) entries of the property bag are pending
+	 * Determines if all of the defined properties in a given property set are pending.
 	 */
-	public hasPendingProperties(props: PropertySet) {
+	public hasPendingProperties(props: PropertySet): boolean {
 		for (const [key, value] of Object.entries(props)) {
 			if (value !== undefined && this.pendingKeyUpdateCount?.[key] === undefined) {
 				return false;