@fluidframework/matrix 2.1.0-276985 → 2.1.0

package/src/runtime.ts

@@ -30,11 +30,11 @@ export class SharedMatrixFactory implements IChannelFactory<ISharedMatrix> {
 		packageVersion: pkgVersion,
 	};
 
-	public get type() {
+	public get type(): string {
 		return SharedMatrixFactory.Type;
 	}
 
-	public get attributes() {
+	public get attributes(): IChannelAttributes {
 		return SharedMatrixFactory.Attributes;
 	}
 
@@ -74,4 +74,7 @@ export const SharedMatrix = createSharedObjectKind<ISharedMatrix>(SharedMatrixFa
  * @privateRemarks
  * This alias is for legacy compat from when the SharedMatrix class was exported as public.
  */
+// Changing this to `unknown` would be a breaking change.
+// TODO: if possible, transition SharedMatrix to not use `any`.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type SharedMatrix<T = any> = ISharedMatrix<T>;

package/src/serialization.ts

@@ -17,13 +17,15 @@ export const serializeBlob = <T>(
 	path: string,
 	snapshot: Serializable<T>,
 	serializer: IFluidSerializer,
-) => new BlobTreeEntry(path, serializer.stringify(snapshot, handle));
+): BlobTreeEntry => new BlobTreeEntry(path, serializer.stringify(snapshot, handle));
 
 export async function deserializeBlob(
 	storage: IChannelStorageService,
 	path: string,
 	serializer: IFluidSerializer,
-) {
+	// Allowing parsed content to remain in its original (any) form.
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+): Promise<any> {
 	const blob = await storage.readBlob(path);
 	const utf8 = bufferToString(blob, "utf8");
 	// eslint-disable-next-line @typescript-eslint/no-unsafe-return

package/src/sparsearray2d.ts

@@ -5,45 +5,51 @@
 
 /* eslint-disable no-bitwise */
 
-import { IMatrixReader, IMatrixWriter } from "@tiny-calc/nano";
+import { IMatrixReader, IMatrixWriter, type IMatrixProducer } from "@tiny-calc/nano";
 
 // Build a lookup table that maps a uint8 to the corresponding uint16 where 0s
 // are interleaved between the original bits. (e.g., 1111... -> 01010101...).
 //
 // (Lookup table ~17% faster than inlining the bit-twiddling on Node v12 x64)
 // (Array<T> ~2% faster than typed array on Node v12 x64)
-const x8ToInterlacedX16 = new Array(256).fill(0).map((value, i) => {
-	let j = i;
-	j = (j | (j << 4)) & 0x0f0f; // .... 7654 .... 3210
-	j = (j | (j << 2)) & 0x3333; // ..76 ..54 ..32 ..10
-	j = (j | (j << 1)) & 0x5555; // .7.6 .5.4 .3.2 .1.0
-	return j;
-});
+const x8ToInterlacedX16 = Array.from({ length: 256 })
+	.fill(0)
+	.map((value, i) => {
+		let j = i;
+		j = (j | (j << 4)) & 0x0f0f; // .... 7654 .... 3210
+		j = (j | (j << 2)) & 0x3333; // ..76 ..54 ..32 ..10
+		j = (j | (j << 1)) & 0x5555; // .7.6 .5.4 .3.2 .1.0
+		return j;
+	});
 
 // Selects individual bytes from a given 32b integer.  The left shift are used to
 // clear upper bits (faster than using masks on Node 10 x64).
-const byte0 = (x32: number) => x32 >>> 24;
-const byte1 = (x32: number) => (x32 << 8) >>> 24;
-const byte2 = (x32: number) => (x32 << 16) >>> 24;
-const byte3 = (x32: number) => (x32 << 24) >>> 24;
+const byte0 = (x32: number): number => x32 >>> 24;
+const byte1 = (x32: number): number => (x32 << 8) >>> 24;
+const byte2 = (x32: number): number => (x32 << 16) >>> 24;
+const byte3 = (x32: number): number => (x32 << 24) >>> 24;
 
 // Given a uint16 returns the corresponding uint32 integer where 0s are
 // interleaved between the original bits. (e.g., 1111... -> 01010101...).
-const interlaceBitsX16 = (x16: number) =>
-	(x8ToInterlacedX16[byte2(x16)] << 16) | x8ToInterlacedX16[byte3(x16)];
+const interlaceBitsX16 = (x16: number): number =>
+	// TODO Non null asserting, why is this not null?
+	// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+	(x8ToInterlacedX16[byte2(x16)]! << 16) | x8ToInterlacedX16[byte3(x16)]!;
 
-const r0ToMorton16 = (row: number) => (interlaceBitsX16(row) << 1) >>> 0;
-const c0ToMorton16 = (col: number) => interlaceBitsX16(col) >>> 0;
+const r0ToMorton16 = (row: number): number => (interlaceBitsX16(row) << 1) >>> 0;
+const c0ToMorton16 = (col: number): number => interlaceBitsX16(col) >>> 0;
 
 // Given a 2D uint16 coordinate returns the corresponding unt32 Morton coded
 // coordinate.  (See https://en.wikipedia.org/wiki/Z-order_curve)
-const r0c0ToMorton2x16 = (row: number, col: number) =>
+const r0c0ToMorton2x16 = (row: number, col: number): number =>
 	(r0ToMorton16(row) | c0ToMorton16(col)) >>> 0;
 
 type RecurArrayHelper<T> = RecurArray<T> | T;
-type RecurArray<T> = RecurArrayHelper<T>[];
+export type RecurArray<T> = RecurArrayHelper<T>[];
 
-/** Undo JSON serialization's coercion of 'undefined' to null. */
+/**
+ * Undo JSON serialization's coercion of 'undefined' to null.
+ */
 // eslint-disable-next-line @rushstack/no-new-null -- Private use of 'null' to preserve 'undefined'
 const nullToUndefined = <T>(array: RecurArray<T | null>): RecurArray<T | undefined> =>
 	array.map((value) => {
@@ -83,12 +89,13 @@ export class SparseArray2D<T>
 		return undefined;
 	}
 
-	public get matrixProducer() {
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-return
-		return undefined as any;
+	public get matrixProducer(): IMatrixProducer<T> {
+		// Cast is needed to satisfy the interface declaration while also not returning
+		// an IMatrixProducer for this class.
+		return undefined as unknown as IMatrixProducer<T>;
 	}
 
-	public setCell(row: number, col: number, value: T | undefined) {
+	public setCell(row: number, col: number, value: T | undefined): void {
 		const keyHi = r0c0ToMorton2x16(row >>> 16, col >>> 16);
 		const keyLo = r0c0ToMorton2x16(row, col);
 
@@ -105,7 +112,7 @@ export class SparseArray2D<T>
 	 * (Note that 'rowBits' is the appropriate byte from 'r0ToMorton16' for the current
 	 * level being traversed.)
 	 */
-	private forEachKeyInRow(rowBits: number, callback: (key: number) => void) {
+	private forEachKeyInRow(rowBits: number, callback: (key: number) => void): void {
 		for (let col = 0; col < 16; col++) {
 			// Perf: Potentially faster to replace 'c0ToMorton16()' with a short look up table?
 			callback((rowBits | c0ToMorton16(col)) >>> 0);
@@ -118,7 +125,7 @@ export class SparseArray2D<T>
 	 * (Note that 'colBits' is the appropriate byte from 'c0ToMorton16' for the current
 	 * level being traversed.)
 	 */
-	private forEachKeyInCol(col: number, callback: (key: number) => void) {
+	private forEachKeyInCol(col: number, callback: (key: number) => void): void {
 		for (let row = 0; row < 16; row++) {
 			// Perf: Potentially faster to replace 'r0ToMorton16()' with a short look up table?
 			callback((r0ToMorton16(row) | col) >>> 0);
@@ -132,11 +139,14 @@ export class SparseArray2D<T>
 	 * (Note that 'rowBits' is the appropriate byte from 'r0ToMorton16' for the current
 	 * level being traversed.)
 	 */
+	// The suppression is needed because forEachInRow is called in a loop, and expected to
+	// use various abstractions on UA<T> at each level of the loop.
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	private forEachInRow<V extends UA<any>, U extends UA<V>>(
 		currentLevel: U,
 		rowBits: number,
 		callback: (level: V) => void,
-	) {
+	): void {
 		this.forEachKeyInRow(rowBits, (key) => {
 			const nextLevel = currentLevel[key];
 			if (nextLevel !== undefined) {
@@ -152,11 +162,14 @@ export class SparseArray2D<T>
 	 * (Note that 'colBits' is the appropriate byte from 'c0ToMorton16' for the current
 	 * level being traversed.)
 	 */
+	// The suppression is needed because forEachInRow is called in a loop, and expected to
+	// use various abstractions on UA<T> at each level of the loop.
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	private forEachInCol<V extends UA<any>, U extends UA<V>>(
 		currentLevel: U,
 		colBits: number,
 		callback: (level: V) => void,
-	) {
+	): void {
 		this.forEachKeyInCol(colBits, (key) => {
 			const nextLevel = currentLevel[key];
 			if (nextLevel !== undefined) {
@@ -165,8 +178,10 @@ export class SparseArray2D<T>
 		});
 	}
 
-	/** Clears the all cells contained within the specified span of rows. */
-	public clearRows(rowStart: number, rowCount: number) {
+	/**
+	 * Clears the all cells contained within the specified span of rows.
+	 */
+	public clearRows(rowStart: number, rowCount: number): void {
 		const rowEnd = rowStart + rowCount;
 		for (let row = rowStart; row < rowEnd; row++) {
 			const rowHi = r0ToMorton16(row >>> 16);
@@ -192,8 +207,10 @@ export class SparseArray2D<T>
 		}
 	}
 
-	/** Clears the all cells contained within the specifed span of cols. */
-	public clearCols(colStart: number, colCount: number) {
+	/**
+	 * Clears the all cells contained within the specifed span of cols.
+	 */
+	public clearCols(colStart: number, colCount: number): void {
 		const colEnd = colStart + colCount;
 		for (let col = colStart; col < colEnd; col++) {
 			const colHi = c0ToMorton16(col >>> 16);
@@ -219,17 +236,19 @@ export class SparseArray2D<T>
 		}
 	}
 
-	private getLevel<T>(parent: UA<UA<T>>, subKey: number) {
+	private getLevel<T>(parent: UA<UA<T>>, subKey: number): UA<T> {
 		const level = parent[subKey];
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-return
-		return level ?? (parent[subKey] = new Array(256).fill(undefined));
+		// Using new Array is needed because the array created with Array.from does not
+		// satisfy (T|undefined)[].
+		// eslint-disable-next-line unicorn/no-new-array
+		return level ?? (parent[subKey] = new Array<T | undefined>(256).fill(undefined));
 	}
 
-	public snapshot() {
+	public snapshot(): UA<UA<UA<UA<UA<T>>>>> {
 		return this.root;
 	}
 
-	public static load<T>(data: RecurArray<T>) {
+	public static load<T>(data: RecurArray<T>): SparseArray2D<T> {
 		return new SparseArray2D<T>(nullToUndefined<T>(data) as SparseArray2D<T>["root"]);
 	}
 }

package/src/undoprovider.ts

@@ -35,7 +35,7 @@ export class VectorUndoProvider {
 		private readonly driver: MergeTreeRevertibleDriver,
 	) {}
 
-	public record(deltaArgs: IMergeTreeDeltaCallbackArgs) {
+	public record(deltaArgs: IMergeTreeDeltaCallbackArgs): void {
 		if (deltaArgs.deltaSegments.length > 0) {
 			// If we are in the process of reverting, the `IRevertible.revert()` will provide the tracking
 			// group so that we can preserve the original segment ranges as a single op/group as we move
@@ -63,21 +63,22 @@ export class VectorUndoProvider {
 				//		the tracking group provides one.
 				const trackingGroup = (removeTrackingGroup =
 					this.currentRemoveTrackingGroup ?? new TrackingGroup());
-				deltaArgs.deltaSegments.forEach((d) =>
-					d.segment.trackingCollection.link(trackingGroup),
-				);
+				for (const d of deltaArgs.deltaSegments)
+					d.segment.trackingCollection.link(trackingGroup);
 			}
 
 			switch (deltaArgs.operation) {
 				case MergeTreeDeltaType.REMOVE:
-				case MergeTreeDeltaType.INSERT:
+				case MergeTreeDeltaType.INSERT: {
 					if (this.currentOp !== deltaArgs.operation) {
 						this.pushRevertible(revertibles, removeTrackingGroup);
 					}
 					break;
+				}
 
-				default:
+				default: {
 					throw new Error("operation type not revertible");
+				}
 			}
 
 			// If we are in the process of reverting, set 'currentOp' to remind ourselves not to push
@@ -93,9 +94,12 @@ export class VectorUndoProvider {
 	private pushRevertible(
 		revertibles: MergeTreeDeltaRevertible[],
 		removedTrackingGroup: ITrackingGroup | undefined,
-	) {
+	): {
+		revert: () => void;
+		discard: () => void;
+	} {
 		const reverter = {
-			revert: () => {
+			revert: (): void => {
 				assert(
 					this.currentGroup === undefined && this.currentOp === undefined,
 					0x02b /* "Must not nest calls to IRevertible.revert()" */,
@@ -106,7 +110,9 @@ export class VectorUndoProvider {
 				try {
 					if (removedTrackingGroup !== undefined) {
 						while (removedTrackingGroup.size > 0) {
-							const tracked = removedTrackingGroup.tracked[0];
+							// TODO Non null asserting, why is this not null?
+							// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+							const tracked = removedTrackingGroup.tracked[0]!;
 							removedTrackingGroup.unlink(tracked);
 							// if there are groups tracked, this in a revert of a remove.
 							// this means we are about to re-insert the row/column
@@ -124,10 +130,12 @@ export class VectorUndoProvider {
 					this.currentRemoveTrackingGroup = undefined;
 				}
 			},
-			discard: () => {
+			discard: (): void => {
 				if (removedTrackingGroup !== undefined) {
 					while (removedTrackingGroup.size > 0) {
-						removedTrackingGroup.unlink(removedTrackingGroup.tracked[0]);
+						// TODO Non null asserting, why is this not null?
+						// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+						removedTrackingGroup.unlink(removedTrackingGroup.tracked[0]!);
 					}
 				}
 				discardMergeTreeDeltaRevertible(revertibles);
@@ -148,30 +156,30 @@ export class MatrixUndoProvider<T> {
 		private readonly cols: PermutationVector,
 	) {
 		rows.undo = new VectorUndoProvider(consumer, {
-			annotateRange() {
+			annotateRange(): void {
 				throw new Error("not implemented");
 			},
-			insertFromSpec(pos, spec) {
+			insertFromSpec(pos, spec): void {
 				matrix._undoRemoveRows(pos, spec);
 			},
-			removeRange(start, end) {
+			removeRange(start, end): void {
 				matrix.removeRows(start, end - start);
 			},
 		});
 		cols.undo = new VectorUndoProvider(consumer, {
-			annotateRange() {
+			annotateRange(): void {
 				throw new Error("not implemented");
 			},
-			insertFromSpec(pos, spec) {
+			insertFromSpec(pos, spec): void {
 				matrix._undoRemoveCols(pos, spec);
 			},
-			removeRange(start, end) {
+			removeRange(start, end): void {
 				matrix.removeCols(start, end - start);
 			},
 		});
 	}
 
-	cellSet(rowHandle: Handle, colHandle: Handle, oldValue: MatrixItem<T>) {
+	cellSet(rowHandle: Handle, colHandle: Handle, oldValue: MatrixItem<T>): void {
 		assert(
 			isHandleValid(rowHandle) && isHandleValid(colHandle),
 			0x02c /* "On cellSet(), invalid row and/or column handles!" */,

package/tsconfig.json

@@ -6,7 +6,6 @@
 		"rootDir": "./src",
 		"outDir": "./lib",
 		"noImplicitAny": true,
-		"noUncheckedIndexedAccess": false,
 		"exactOptionalPropertyTypes": false,
 	},
 }