@fluidframework/merge-tree 2.1.0-276985 → 2.1.0

package/src/collections/rbTree.ts

@@ -129,28 +129,31 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
 	) {}
 
 	private makeNode(key: TKey, data: TData, color: RBColor, size: number): RBNode<TKey, TData> {
-		return { key, data, color, size } as any as RBNode<TKey, TData>;
+		return { key, data, color, size } as unknown as RBNode<TKey, TData>;
 	}
 
-	private isRed(node: RBNode<TKey, TData> | undefined) {
+	private isRed(node: RBNode<TKey, TData> | undefined): boolean {
 		return !!node && node.color === RBColor.RED;
 	}
 
-	private nodeSize(node: RBNode<TKey, TData> | undefined) {
+	private nodeSize(node: RBNode<TKey, TData> | undefined): number {
 		return node ? node.size : 0;
 	}
-	public size() {
+	public size(): number {
 		return this.nodeSize(this.root);
 	}
-	public isEmpty() {
+	public isEmpty(): boolean {
 		return !this.root;
 	}
-	public get(key: TKey) {
+	public get(key: TKey): RBNode<TKey, TData> | undefined {
 		if (key !== undefined) {
 			return this.nodeGet(this.root, key);
 		}
 	}
-	private nodeGet(node: RBNode<TKey, TData> | undefined, key: TKey) {
+	private nodeGet(
+		node: RBNode<TKey, TData> | undefined,
+		key: TKey,
+	): RBNode<TKey, TData> | undefined {
 		let _node = node;
 		while (_node) {
 			const cmp = this.compareKeys(key, _node.key);
@@ -163,11 +166,11 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
 			}
 		}
 	}
-	private contains(key: TKey) {
+	private contains(key: TKey): RBNode<TKey, TData> | undefined {
 		return this.get(key);
 	}
 
-	public gather(key: TKey, matcher: IRBMatcher<TKey, TData>) {
+	public gather(key: TKey, matcher: IRBMatcher<TKey, TData>): RBNode<TKey, TData>[] {
 		const results = [] as RBNode<TKey, TData>[];
 		if (key !== undefined) {
 			this.nodeGather(this.root, results, key, matcher);
@@ -180,7 +183,7 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
 		results: RBNode<TKey, TData>[],
 		key: TKey,
 		matcher: IRBMatcher<TKey, TData>,
-	) {
+	): void {
 		if (node) {
 			if (matcher.continueSubtree(node.left, key)) {
 				this.nodeGather(node.left, results, key, matcher);
@@ -199,7 +202,7 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
 		actionFn: (node: RBNode<TKey, TData>) => void,
 		continueLeftFn: (number: number) => boolean,
 		continueRightFn: (number: number) => boolean,
-	) {
+	): void {
 		this.nodeWalkExactMatchesForward(
 			this.root,
 			compareFn,
@@ -215,7 +218,7 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
 		actionFn: (node: RBNode<TKey, TData>) => void,
 		continueLeftFn: (number: number) => boolean,
 		continueRightFn: (number: number) => boolean,
-	) {
+	): void {
 		if (!node) {
 			return;
 		}
@@ -248,7 +251,7 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
 		actionFn: (node: RBNode<TKey, TData>) => void,
 		continueLeftFn: (number: number) => boolean,
 		continueRightFn: (number: number) => boolean,
-	) {
+	): void {
 		this.nodeWalkExactMatchesBackward(
 			this.root,
 			compareFn,
@@ -264,7 +267,7 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
 		actionFn: (node: RBNode<TKey, TData>) => void,
 		continueLeftFn: (cmp: number) => boolean,
 		continueRightFn: (cmp: number) => boolean,
-	) {
+	): void {
 		if (!node) {
 			return;
 		}
@@ -292,7 +295,7 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
 		}
 	}
 
-	public put(key: TKey, data: TData, conflict?: ConflictAction<TKey, TData>) {
+	public put(key: TKey, data: TData, conflict?: ConflictAction<TKey, TData>): void {
 		if (key !== undefined) {
 			if (data === undefined) {
 				this.remove(key);
@@ -308,11 +311,9 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
 		key: TKey,
 		data: TData,
 		conflict?: ConflictAction<TKey, TData>,
-	) {
+	): RBNode<TKey, TData> {
 		let _node = node;
-		if (!_node) {
-			return this.makeNode(key, data, RBColor.RED, 1);
-		} else {
+		if (_node) {
 			const cmp = this.compareKeys(key, _node.key);
 			if (cmp < 0) {
 				_node.left = this.nodePut(_node.left, key, data, conflict);
@@ -324,7 +325,7 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
 					if (kd.key) {
 						_node.key = kd.key;
 					}
-					_node.data = kd.data ? kd.data : data;
+					_node.data = kd.data ?? data;
 				} else {
 					_node.data = data;
 				}
@@ -344,10 +345,12 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
 				this.updateLocal(_node);
 			}
 			return _node;
+		} else {
+			return this.makeNode(key, data, RBColor.RED, 1);
 		}
 	}
 
-	private updateLocal(node: RBNode<TKey, TData>) {
+	private updateLocal(node: RBNode<TKey, TData>): void {
 		if (this.aug) {
 			if (this.isRed(node.left)) {
 				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -361,7 +364,7 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
 		}
 	}
 
-	private nodeRemoveMin(node: RBNode<TKey, TData>) {
+	private nodeRemoveMin(node: RBNode<TKey, TData>): RBNode<TKey, TData> | undefined {
 		let _node = node;
 		if (_node.left) {
 			if (!this.isRed(_node.left) && !this.isRed(_node.left.left)) {
@@ -374,7 +377,7 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
 		}
 	}
 
-	public remove(key: TKey) {
+	public remove(key: TKey): void {
 		if (key !== undefined) {
 			if (!this.contains(key)) {
 				return;
@@ -385,7 +388,7 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
 		// TODO: error on undefined key
 	}
 
-	public removeExisting(key: TKey) {
+	public removeExisting(key: TKey): void {
 		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 		if (!this.isRed(this.root!.left) && !this.isRed(this.root!.right)) {
 			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -396,7 +399,7 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
 		this.root = this.nodeRemove(this.root!, key);
 	}
 
-	private nodeRemove(node: RBNode<TKey, TData>, key: TKey) {
+	private nodeRemove(node: RBNode<TKey, TData>, key: TKey): RBNode<TKey, TData> | undefined {
 		let _node = node;
 		if (this.compareKeys(key, _node.key) < 0) {
 			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -432,9 +435,9 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
 	}
 
 	/**
-	 * @returns The largest node in this tree which compares less than or equal to `key`
+	 * Finds the largest node that is less than or equal to a given key.
 	 */
-	public floor(key: TKey) {
+	public floor(key: TKey): RBNode<TKey, TData> | undefined {
 		if (!this.isEmpty()) {
 			return this.nodeFloor(this.root, key);
 		}
@@ -452,15 +455,15 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
 				return this.nodeFloor(node.left, key);
 			} else {
 				const rightFloor = this.nodeFloor(node.right, key);
-				return rightFloor ? rightFloor : node;
+				return rightFloor ?? node;
 			}
 		}
 	}
 
 	/**
-	 * @returns The smallest node in this tree which compares greater than or equal to `key`
+	 * Finds the smallest node that is greater than or equal to a given key.
 	 */
-	public ceil(key: TKey) {
+	public ceil(key: TKey): RBNode<TKey, TData> | undefined {
 		if (!this.isEmpty()) {
 			return this.nodeCeil(this.root, key);
 		}
@@ -478,32 +481,32 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
 				return this.nodeCeil(node.right, key);
 			} else {
 				const leftCeil = this.nodeCeil(node.left, key);
-				return leftCeil ? leftCeil : node;
+				return leftCeil ?? node;
 			}
 		}
 	}
 
-	public min() {
+	public min(): RBNode<TKey, TData> | undefined {
 		if (this.root) {
 			return this.nodeMin(this.root);
 		}
 	}
 
 	private nodeMin(node: RBNode<TKey, TData>): RBNode<TKey, TData> {
-		return !node.left ? node : this.nodeMin(node.left);
+		return node.left ? this.nodeMin(node.left) : node;
 	}
 
-	public max() {
+	public max(): RBNode<TKey, TData> | undefined {
 		if (this.root) {
 			return this.nodeMax(this.root);
 		}
 	}
 
 	private nodeMax(node: RBNode<TKey, TData>): RBNode<TKey, TData> {
-		return !node.right ? node : this.nodeMax(node.right);
+		return node.right ? this.nodeMax(node.right) : node;
 	}
 
-	private rotateRight(node: RBNode<TKey, TData>) {
+	private rotateRight(node: RBNode<TKey, TData>): RBNode<TKey, TData> {
 		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 		const leftChild = node.left!;
 		node.left = leftChild.right;
@@ -519,7 +522,7 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
 		return leftChild;
 	}
 
-	private rotateLeft(node: RBNode<TKey, TData>) {
+	private rotateLeft(node: RBNode<TKey, TData>): RBNode<TKey, TData> {
 		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 		const rightChild = node.right!;
 		node.right = rightChild.left;
@@ -535,11 +538,11 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
 		return rightChild;
 	}
 
-	private oppositeColor(c: RBColor) {
+	private oppositeColor(c: RBColor): RBColor {
 		return c === RBColor.BLACK ? RBColor.RED : RBColor.BLACK;
 	}
 
-	private flipColors(node: RBNode<TKey, TData>) {
+	private flipColors(node: RBNode<TKey, TData>): void {
 		node.color = this.oppositeColor(node.color);
 		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 		node.left!.color = this.oppositeColor(node.left!.color);
@@ -547,7 +550,7 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
 		node.right!.color = this.oppositeColor(node.right!.color);
 	}
 
-	private moveRedLeft(node: RBNode<TKey, TData>) {
+	private moveRedLeft(node: RBNode<TKey, TData>): RBNode<TKey, TData> {
 		let _node = node;
 		this.flipColors(_node);
 		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -560,7 +563,7 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
 		return _node;
 	}
 
-	private moveRedRight(node: RBNode<TKey, TData>) {
+	private moveRedRight(node: RBNode<TKey, TData>): RBNode<TKey, TData> {
 		let _node = node;
 		this.flipColors(_node);
 		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -571,7 +574,7 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
 		return _node;
 	}
 
-	private balance(input: RBNode<TKey, TData>) {
+	private balance(input: RBNode<TKey, TData>): RBNode<TKey, TData> {
 		let node: RBNode<TKey, TData> | undefined = input;
 		if (this.isRed(node.right)) {
 			node = this.rotateLeft(node);
@@ -595,16 +598,16 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
 		accum?: TAccum,
 		start?: TKey,
 		end?: TKey,
-	) {
+	): void {
 		this.nodeMap(this.root, action, accum, start, end);
 	}
 
-	public map<TAccum>(action: PropertyAction<TKey, TData>, accum?: TAccum) {
+	public map<TAccum>(action: PropertyAction<TKey, TData>, accum?: TAccum): void {
 		// TODO: optimize to avoid comparisons
 		this.nodeMap(this.root, action, accum);
 	}
 
-	public keys() {
+	public keys(): TKey[] {
 		const keyList: TKey[] = [];
 		const actions: RBNodeActions<TKey, TData> = {
 			showStructure: true,
@@ -622,11 +625,11 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
 	 * false, traversal is halted.
 	 * @param action - action to apply to each node
 	 */
-	public walk(actions: RBNodeActions<TKey, TData>) {
+	public walk(actions: RBNodeActions<TKey, TData>): void {
 		this.nodeWalk(this.root, actions);
 	}
 
-	public walkBackward(actions: RBNodeActions<TKey, TData>) {
+	public walkBackward(actions: RBNodeActions<TKey, TData>): void {
 		this.nodeWalkBackward(this.root, actions);
 	}
 
@@ -636,26 +639,20 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
 	): boolean {
 		let go = true;
 		if (node) {
-			if (actions.pre) {
-				if (!!actions.showStructure || node.color === RBColor.BLACK) {
-					go = actions.pre(node);
-				}
+			if (actions.pre && (!!actions.showStructure || node.color === RBColor.BLACK)) {
+				go = actions.pre(node);
 			}
 			if (node.left) {
 				go = this.nodeWalk(node.left, actions);
 			}
-			if (go && actions.infix) {
-				if (!!actions.showStructure || node.color === RBColor.BLACK) {
-					go = actions.infix(node);
-				}
+			if (go && actions.infix && (!!actions.showStructure || node.color === RBColor.BLACK)) {
+				go = actions.infix(node);
 			}
 			if (go) {
 				go = this.nodeWalk(node.right, actions);
 			}
-			if (go && actions.post) {
-				if (!!actions.showStructure || node.color === RBColor.BLACK) {
-					go = actions.post(node);
-				}
+			if (go && actions.post && (!!actions.showStructure || node.color === RBColor.BLACK)) {
+				go = actions.post(node);
 			}
 		}
 		return go;
@@ -667,26 +664,20 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
 	): boolean {
 		let go = true;
 		if (node) {
-			if (actions.pre) {
-				if (!!actions.showStructure || node.color === RBColor.BLACK) {
-					go = actions.pre(node);
-				}
+			if (actions.pre && (!!actions.showStructure || node.color === RBColor.BLACK)) {
+				go = actions.pre(node);
 			}
 			if (node.right) {
 				go = this.nodeWalkBackward(node.right, actions);
 			}
-			if (go && actions.infix) {
-				if (!!actions.showStructure || node.color === RBColor.BLACK) {
-					go = actions.infix(node);
-				}
+			if (go && actions.infix && (!!actions.showStructure || node.color === RBColor.BLACK)) {
+				go = actions.infix(node);
 			}
 			if (go) {
 				go = this.nodeWalkBackward(node.left, actions);
 			}
-			if (go && actions.post) {
-				if (!!actions.showStructure || node.color === RBColor.BLACK) {
-					go = actions.post(node);
-				}
+			if (go && actions.post && (!!actions.showStructure || node.color === RBColor.BLACK)) {
+				go = actions.post(node);
 			}
 		}
 		return go;

package/src/endOfTreeSegment.ts

@@ -61,11 +61,11 @@ abstract class BaseEndpointSegment {
 		depth: number;
 	};
 
-	get parent() {
+	get parent(): MergeBlock {
 		return this.endpointSegmentProps().parent;
 	}
 
-	get index() {
+	get index(): number {
 		return this.endpointSegmentProps().index;
 	}
 
@@ -77,10 +77,10 @@ abstract class BaseEndpointSegment {
 	 * since this segment isn't real, throw on any segment
 	 * operation that isn't expected
 	 */
-	get segmentGroups() {
+	get segmentGroups(): never {
 		return notSupported();
 	}
-	get trackingCollection() {
+	get trackingCollection(): never {
 		return notSupported();
 	}
 	addProperties = notSupported;
@@ -92,7 +92,7 @@ abstract class BaseEndpointSegment {
 	ack = notSupported;
 }
 
-const notSupported = () => {
+const notSupported = (): never => {
 	assert(false, 0x3ed /* operation not supported */);
 };
 
@@ -107,7 +107,11 @@ export class StartOfTreeSegment extends BaseEndpointSegment implements ISegment,
 	 * this segment pretends to be a sibling of the first real segment.
 	 * so compute the necessary properties to pretend to be that segment.
 	 */
-	protected endpointSegmentProps() {
+	protected endpointSegmentProps(): {
+		parent: MergeBlock;
+		index: number;
+		depth: number;
+	} {
 		let firstSegment: ISegmentLeaf | undefined;
 		let depth = 1;
 		const root = this.mergeTree.root;
@@ -134,7 +138,10 @@ export class StartOfTreeSegment extends BaseEndpointSegment implements ISegment,
 		};
 	}
 
-	get ordinal() {
+	get ordinal(): string {
+		// Ordinals exist purely for lexicographical sort order and use a small set of valid bytes for each string character.
+		// The extra handling fromCodePoint has for things like surrogate pairs is therefore unnecessary.
+		// eslint-disable-next-line unicorn/prefer-code-point
 		return String.fromCharCode(0x00);
 	}
 }
@@ -150,7 +157,11 @@ export class EndOfTreeSegment extends BaseEndpointSegment implements ISegment, I
 	 * this segment pretends to be a sibling of the last real segment.
 	 * so compute the necessary properties to pretend to be that segment.
 	 */
-	protected endpointSegmentProps() {
+	protected endpointSegmentProps(): {
+		parent: MergeBlock;
+		index: number;
+		depth: number;
+	} {
 		let lastSegment: ISegmentLeaf | undefined;
 		let depth = 1;
 		const root = this.mergeTree.root;
@@ -177,11 +188,11 @@ export class EndOfTreeSegment extends BaseEndpointSegment implements ISegment, I
 		};
 	}
 
-	get ordinal() {
+	get ordinal(): string {
 		// just compute an arbitrarily big ordinal
 		// we base it on the depth of the tree
 		// to ensure it is bigger than all ordinals in
 		// the tree, as each layer appends to the previous
-		return String.fromCharCode(0xffff).repeat(this.endpointSegmentProps().depth);
+		return String.fromCodePoint(0xffff).repeat(this.endpointSegmentProps().depth);
 	}
 }