@fluidframework/matrix 2.0.0-internal.3.0.5 → 2.0.0-internal.3.1.1

package/src/range.ts

@@ -3,14 +3,14 @@
  * Licensed under the MIT License.
  */
 
- /**
-  * Ensures that 0 \<= 'value' \< 'limit'.  Throws a RangeError otherwise.
-  */
+/**
+ * Ensures that 0 \<= 'value' \< 'limit'.  Throws a RangeError otherwise.
+ */
 export function ensureRange(value: number, limit: number) {
-    // Coerce 'value' to Uint32 so that we can range check with a single branch.
-    const _value = value >>> 0;   // eslint-disable-line no-bitwise
+	// Coerce 'value' to Uint32 so that we can range check with a single branch.
+	const _value = value >>> 0; // eslint-disable-line no-bitwise
 
-    if (_value >= limit) {
-        throw new RangeError("Invalid (row, col) coordinate.");
-    }
+	if (_value >= limit) {
+		throw new RangeError("Invalid (row, col) coordinate.");
+	}
 }

package/src/runtime.ts

@@ -4,49 +4,49 @@
  */
 
 import {
-    IChannelAttributes,
-    IFluidDataStoreRuntime,
-    IChannelServices,
-    IChannel,
-    IChannelFactory,
+	IChannelAttributes,
+	IFluidDataStoreRuntime,
+	IChannelServices,
+	IChannel,
+	IChannelFactory,
 } from "@fluidframework/datastore-definitions";
 import { pkgVersion } from "./packageVersion";
 import { SharedMatrix } from "./matrix";
 
 export class SharedMatrixFactory implements IChannelFactory {
-    public static Type = "https://graph.microsoft.com/types/sharedmatrix";
+	public static Type = "https://graph.microsoft.com/types/sharedmatrix";
 
-    public static readonly Attributes: IChannelAttributes = {
-        type: SharedMatrixFactory.Type,
-        snapshotFormatVersion: "0.1",
-        packageVersion: pkgVersion,
-    };
+	public static readonly Attributes: IChannelAttributes = {
+		type: SharedMatrixFactory.Type,
+		snapshotFormatVersion: "0.1",
+		packageVersion: pkgVersion,
+	};
 
-    public get type() {
-        return SharedMatrixFactory.Type;
-    }
+	public get type() {
+		return SharedMatrixFactory.Type;
+	}
 
-    public get attributes() {
-        return SharedMatrixFactory.Attributes;
-    }
+	public get attributes() {
+		return SharedMatrixFactory.Attributes;
+	}
 
-    /**
-     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.load}
-     */
-    public async load(
-        runtime: IFluidDataStoreRuntime,
-        id: string,
-        services: IChannelServices,
-        attributes: IChannelAttributes,
-    ): Promise<IChannel> {
-        const matrix = new SharedMatrix(runtime, id, attributes);
-        await matrix.load(services);
-        return matrix;
-    }
+	/**
+	 * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.load}
+	 */
+	public async load(
+		runtime: IFluidDataStoreRuntime,
+		id: string,
+		services: IChannelServices,
+		attributes: IChannelAttributes,
+	): Promise<IChannel> {
+		const matrix = new SharedMatrix(runtime, id, attributes);
+		await matrix.load(services);
+		return matrix;
+	}
 
-    public create(document: IFluidDataStoreRuntime, id: string): IChannel {
-        const matrix = new SharedMatrix(document, id, this.attributes);
-        matrix.initializeLocal();
-        return matrix;
-    }
+	public create(document: IFluidDataStoreRuntime, id: string): IChannel {
+		const matrix = new SharedMatrix(document, id, this.attributes);
+		matrix.initializeLocal();
+		return matrix;
+	}
 }

package/src/serialization.ts

@@ -10,15 +10,19 @@ import { IFluidSerializer } from "@fluidframework/shared-object-base";
 import { bufferToString } from "@fluidframework/common-utils";
 
 export const serializeBlob = (
-    handle: IFluidHandle,
-    path: string,
-    snapshot: Serializable,
-    serializer: IFluidSerializer,
+	handle: IFluidHandle,
+	path: string,
+	snapshot: Serializable,
+	serializer: IFluidSerializer,
 ) => new BlobTreeEntry(path, serializer.stringify(snapshot, handle));
 
-export async function deserializeBlob(storage: IChannelStorageService, path: string, serializer: IFluidSerializer) {
-    const blob = await storage.readBlob(path);
-    const utf8 = bufferToString(blob, "utf8");
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return serializer.parse(utf8);
+export async function deserializeBlob(
+	storage: IChannelStorageService,
+	path: string,
+	serializer: IFluidSerializer,
+) {
+	const blob = await storage.readBlob(path);
+	const utf8 = bufferToString(blob, "utf8");
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+	return serializer.parse(utf8);
 }

package/src/sparsearray2d.ts

@@ -12,14 +12,13 @@ import { IMatrixReader, IMatrixWriter } from "@tiny-calc/nano";
 //
 // (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 = 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;
+});
 
 // 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).
@@ -30,205 +29,210 @@ const byte3 = (x32: 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) =>
+	(x8ToInterlacedX16[byte2(x16)] << 16) | x8ToInterlacedX16[byte3(x16)];
 
 const r0ToMorton16 = (row: number) => (interlaceBitsX16(row) << 1) >>> 0;
 const c0ToMorton16 = (col: 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) => (r0ToMorton16(row) | c0ToMorton16(col)) >>> 0;
+const r0c0ToMorton2x16 = (row: number, col: number) =>
+	(r0ToMorton16(row) | c0ToMorton16(col)) >>> 0;
 
 type RecurArrayHelper<T> = RecurArray<T> | T;
 type RecurArray<T> = RecurArrayHelper<T>[];
 
 /** Undo JSON serialization's coercion of 'undefined' to null. */
-const nullToUndefined = <T>(array: RecurArray<T | null>): RecurArray<T | undefined> => array.map((value) => {
-    return value === null
-        ? undefined
-        : Array.isArray(value)
-            ? nullToUndefined(value)
-            : value;
-});
+const nullToUndefined = <T>(array: RecurArray<T | null>): RecurArray<T | undefined> =>
+	array.map((value) => {
+		return value === null ? undefined : Array.isArray(value) ? nullToUndefined(value) : value;
+	});
 
 type UA<T> = (T | undefined)[];
 
 /**
  * A sparse 4 billion x 4 billion array stored as 16x16 tiles.
  */
-export class SparseArray2D<T> implements IMatrixReader<T | undefined>, IMatrixWriter<T | undefined> {
-    constructor(private readonly root: UA<UA<UA<UA<UA<T>>>>> = [undefined]) { }
-
-    public get rowCount() { return 0xFFFFFFFF; }
-    public get colCount() { return 0xFFFFFFFF; }
-
-    public getCell(row: number, col: number): T | undefined {
-        const keyHi = r0c0ToMorton2x16(row >>> 16, col >>> 16);
-        const level0 = this.root[keyHi];
-        if (level0 !== undefined) {
-            const keyLo = r0c0ToMorton2x16(row, col);
-            const level1 = level0[byte0(keyLo)];
-            if (level1 !== undefined) {
-                const level2 = level1[byte1(keyLo)];
-                if (level2 !== undefined) {
-                    const level3 = level2[byte2(keyLo)];
-                    if (level3 !== undefined) {
-                        return level3[byte3(keyLo)];
-                    }
-                }
-            }
-        }
-
-        return undefined;
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    public get matrixProducer() { return undefined as any; }
-
-    public setCell(row: number, col: number, value: T | undefined) {
-        const keyHi = r0c0ToMorton2x16(row >>> 16, col >>> 16);
-        const keyLo = r0c0ToMorton2x16(row, col);
-
-        const level0 = this.getLevel(this.root, keyHi);
-        const level1 = this.getLevel(level0, byte0(keyLo));
-        const level2 = this.getLevel(level1, byte1(keyLo));
-        const level3 = this.getLevel(level2, byte2(keyLo));
-        level3[byte3(keyLo)] = value;
-    }
-
-    /**
-     * Invokes the given 'callback' for each key in a 16 x 16 tile at the indicated row.
-     *
-     * (Note that 'rowBits' is the appropriate byte from 'r0ToMorton16' for the current
-     * level being traversed.)
-     */
-    private forEachKeyInRow(rowBits: number, callback: (key: number) => 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);
-        }
-    }
-
-    /**
-     * Invokes the given 'callback' for each key in a 16 x 16 tile at the indicated col.
-     *
-     * (Note that 'colBits' is the appropriate byte from 'c0ToMorton16' for the current
-     * level being traversed.)
-     */
-    private forEachKeyInCol(col: number, callback: (key: number) => 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);
-        }
-    }
-
-    /**
-     * Invokes the give 'callback' with the next 'level' array for each populated region
-     * of the given row  in the 'currentLevel'.
-     *
-     * (Note that 'rowBits' is the appropriate byte from 'r0ToMorton16' for the current
-     * level being traversed.)
-     */
-    private forEachInRow<V extends UA<any>, U extends UA<V>>(
-        currentLevel: U,
-        rowBits: number,
-        callback: (level: V) => void,
-    ) {
-        this.forEachKeyInRow(rowBits, (key) => {
-            const nextLevel = currentLevel[key];
-            if (nextLevel !== undefined) {
-                callback(nextLevel);
-            }
-        });
-    }
-
-    /**
-     * Invokes the give 'callback' with the next 'level' array for each populated region
-     * of the given col in the 'currentLevel'.
-     *
-     * (Note that 'colBits' is the appropriate byte from 'c0ToMorton16' for the current
-     * level being traversed.)
-     */
-    private forEachInCol<V extends UA<any>, U extends UA<V>>(
-        currentLevel: U,
-        colBits: number,
-        callback: (level: V) => void,
-    ) {
-        this.forEachKeyInCol(colBits, (key) => {
-            const nextLevel = currentLevel[key];
-            if (nextLevel !== undefined) {
-                callback(nextLevel);
-            }
-        });
-    }
-
-    /** Clears the all cells contained within the specified span of rows. */
-    public clearRows(rowStart: number, rowCount: number) {
-        const rowEnd = rowStart + rowCount;
-        for (let row = rowStart; row < rowEnd; row++) {
-            const rowHi = r0ToMorton16(row >>> 16);
-
-            // The top level of tree is a 64k x 64k tile.  We need to scan all 64k entries.
-            for (let colHi = 0; colHi < 0x10000; colHi++) {
-                const keyHi = (rowHi | c0ToMorton16(colHi)) >>> 0;
-                const level0 = this.root[keyHi];
-                if (level0 !== undefined) {
-                    // The remainder of the tree is divided in 16 x 16 tiles.
-                    const rowLo = r0ToMorton16(row);
-                    this.forEachInRow(level0, byte0(rowLo), (level1) => {
-                        this.forEachInRow(level1, byte1(rowLo), (level2) => {
-                            this.forEachInRow(level2, byte2(rowLo), (level3) => {
-                                this.forEachKeyInRow(byte3(rowLo), (key) => {
-                                    level3[key] = undefined;
-                                });
-                            });
-                        });
-                    });
-                }
-            }
-        }
-    }
-
-    /** Clears the all cells contained within the specifed span of cols. */
-    public clearCols(colStart: number, colCount: number) {
-        const colEnd = colStart + colCount;
-        for (let col = colStart; col < colEnd; col++) {
-            const colHi = c0ToMorton16(col >>> 16);
-
-            // The top level of tree is a 64k x 64k tile.  We need to scan all 64k entries.
-            for (let rowHi = 0; rowHi < 0x10000; rowHi++) {
-                const keyHi = (colHi | r0ToMorton16(rowHi)) >>> 0;
-                const level0 = this.root[keyHi];
-                if (level0 !== undefined) {
-                    // The remainder of the tree is divided in 16 x 16 tiles.
-                    const colLo = c0ToMorton16(col);
-                    this.forEachInCol(level0, byte0(colLo), (level1) => {
-                        this.forEachInCol(level1, byte1(colLo), (level2) => {
-                            this.forEachInCol(level2, byte2(colLo), (level3) => {
-                                this.forEachKeyInCol(byte3(colLo), (key) => {
-                                    level3[key] = undefined;
-                                });
-                            });
-                        });
-                    });
-                }
-            }
-        }
-    }
-
-    private getLevel<T>(parent: UA<UA<T>>, subKey: number) {
-        const level = parent[subKey];
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        return level === undefined
-            ? (parent[subKey] = new Array(256).fill(undefined))
-            : level;
-    }
-
-    public snapshot() {
-        return this.root;
-    }
-
-    public static load<T>(data: RecurArray<T>) {
-        return new SparseArray2D<T>(nullToUndefined<T>(data) as SparseArray2D<T>["root"]);
-    }
+export class SparseArray2D<T>
+	implements IMatrixReader<T | undefined>, IMatrixWriter<T | undefined>
+{
+	constructor(private readonly root: UA<UA<UA<UA<UA<T>>>>> = [undefined]) {}
+
+	public get rowCount() {
+		return 0xffffffff;
+	}
+	public get colCount() {
+		return 0xffffffff;
+	}
+
+	public getCell(row: number, col: number): T | undefined {
+		const keyHi = r0c0ToMorton2x16(row >>> 16, col >>> 16);
+		const level0 = this.root[keyHi];
+		if (level0 !== undefined) {
+			const keyLo = r0c0ToMorton2x16(row, col);
+			const level1 = level0[byte0(keyLo)];
+			if (level1 !== undefined) {
+				const level2 = level1[byte1(keyLo)];
+				if (level2 !== undefined) {
+					const level3 = level2[byte2(keyLo)];
+					if (level3 !== undefined) {
+						return level3[byte3(keyLo)];
+					}
+				}
+			}
+		}
+
+		return undefined;
+	}
+
+	public get matrixProducer() {
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+		return undefined as any;
+	}
+
+	public setCell(row: number, col: number, value: T | undefined) {
+		const keyHi = r0c0ToMorton2x16(row >>> 16, col >>> 16);
+		const keyLo = r0c0ToMorton2x16(row, col);
+
+		const level0 = this.getLevel(this.root, keyHi);
+		const level1 = this.getLevel(level0, byte0(keyLo));
+		const level2 = this.getLevel(level1, byte1(keyLo));
+		const level3 = this.getLevel(level2, byte2(keyLo));
+		level3[byte3(keyLo)] = value;
+	}
+
+	/**
+	 * Invokes the given 'callback' for each key in a 16 x 16 tile at the indicated row.
+	 *
+	 * (Note that 'rowBits' is the appropriate byte from 'r0ToMorton16' for the current
+	 * level being traversed.)
+	 */
+	private forEachKeyInRow(rowBits: number, callback: (key: number) => 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);
+		}
+	}
+
+	/**
+	 * Invokes the given 'callback' for each key in a 16 x 16 tile at the indicated col.
+	 *
+	 * (Note that 'colBits' is the appropriate byte from 'c0ToMorton16' for the current
+	 * level being traversed.)
+	 */
+	private forEachKeyInCol(col: number, callback: (key: number) => 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);
+		}
+	}
+
+	/**
+	 * Invokes the give 'callback' with the next 'level' array for each populated region
+	 * of the given row  in the 'currentLevel'.
+	 *
+	 * (Note that 'rowBits' is the appropriate byte from 'r0ToMorton16' for the current
+	 * level being traversed.)
+	 */
+	private forEachInRow<V extends UA<any>, U extends UA<V>>(
+		currentLevel: U,
+		rowBits: number,
+		callback: (level: V) => void,
+	) {
+		this.forEachKeyInRow(rowBits, (key) => {
+			const nextLevel = currentLevel[key];
+			if (nextLevel !== undefined) {
+				callback(nextLevel);
+			}
+		});
+	}
+
+	/**
+	 * Invokes the give 'callback' with the next 'level' array for each populated region
+	 * of the given col in the 'currentLevel'.
+	 *
+	 * (Note that 'colBits' is the appropriate byte from 'c0ToMorton16' for the current
+	 * level being traversed.)
+	 */
+	private forEachInCol<V extends UA<any>, U extends UA<V>>(
+		currentLevel: U,
+		colBits: number,
+		callback: (level: V) => void,
+	) {
+		this.forEachKeyInCol(colBits, (key) => {
+			const nextLevel = currentLevel[key];
+			if (nextLevel !== undefined) {
+				callback(nextLevel);
+			}
+		});
+	}
+
+	/** Clears the all cells contained within the specified span of rows. */
+	public clearRows(rowStart: number, rowCount: number) {
+		const rowEnd = rowStart + rowCount;
+		for (let row = rowStart; row < rowEnd; row++) {
+			const rowHi = r0ToMorton16(row >>> 16);
+
+			// The top level of tree is a 64k x 64k tile.  We need to scan all 64k entries.
+			for (let colHi = 0; colHi < 0x10000; colHi++) {
+				const keyHi = (rowHi | c0ToMorton16(colHi)) >>> 0;
+				const level0 = this.root[keyHi];
+				if (level0 !== undefined) {
+					// The remainder of the tree is divided in 16 x 16 tiles.
+					const rowLo = r0ToMorton16(row);
+					this.forEachInRow(level0, byte0(rowLo), (level1) => {
+						this.forEachInRow(level1, byte1(rowLo), (level2) => {
+							this.forEachInRow(level2, byte2(rowLo), (level3) => {
+								this.forEachKeyInRow(byte3(rowLo), (key) => {
+									level3[key] = undefined;
+								});
+							});
+						});
+					});
+				}
+			}
+		}
+	}
+
+	/** Clears the all cells contained within the specifed span of cols. */
+	public clearCols(colStart: number, colCount: number) {
+		const colEnd = colStart + colCount;
+		for (let col = colStart; col < colEnd; col++) {
+			const colHi = c0ToMorton16(col >>> 16);
+
+			// The top level of tree is a 64k x 64k tile.  We need to scan all 64k entries.
+			for (let rowHi = 0; rowHi < 0x10000; rowHi++) {
+				const keyHi = (colHi | r0ToMorton16(rowHi)) >>> 0;
+				const level0 = this.root[keyHi];
+				if (level0 !== undefined) {
+					// The remainder of the tree is divided in 16 x 16 tiles.
+					const colLo = c0ToMorton16(col);
+					this.forEachInCol(level0, byte0(colLo), (level1) => {
+						this.forEachInCol(level1, byte1(colLo), (level2) => {
+							this.forEachInCol(level2, byte2(colLo), (level3) => {
+								this.forEachKeyInCol(byte3(colLo), (key) => {
+									level3[key] = undefined;
+								});
+							});
+						});
+					});
+				}
+			}
+		}
+	}
+
+	private getLevel<T>(parent: UA<UA<T>>, subKey: number) {
+		const level = parent[subKey];
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+		return level === undefined ? (parent[subKey] = new Array(256).fill(undefined)) : level;
+	}
+
+	public snapshot() {
+		return this.root;
+	}
+
+	public static load<T>(data: RecurArray<T>) {
+		return new SparseArray2D<T>(nullToUndefined<T>(data) as SparseArray2D<T>["root"]);
+	}
 }