@fluidframework/matrix 2.0.0-internal.3.0.0 → 2.0.0-internal.3.1.0

package/src/split.ts

@@ -9,59 +9,75 @@ import { SetOperations, Pair } from "./bspSet";
 export type Ivl<Index extends number = number> = Pair<Index>;
 
 /** A much faster version of `Math.max` specialized to two numeric arguments. */
-const fastMax = <Index extends number>(x1: Index, x2: Index): Index => x1 < x2 ? x2 : x1;
+const fastMax = <Index extends number>(x1: Index, x2: Index): Index => (x1 < x2 ? x2 : x1);
 
 /** A much faster version of `Math.min` specialized to two numeric arguments. */
-const fastMin = <Index extends number>(x1: Index, x2: Index): Index => x1 < x2 ? x1 : x2;
+const fastMin = <Index extends number>(x1: Index, x2: Index): Index => (x1 < x2 ? x1 : x2);
 
 export function ivlJoin<Index extends number>(ivl1: Ivl<Index>, ivl2: Ivl<Index>): Ivl<Index> {
-    const [x1a, x1b] = ivl1;
-    const [x2a, x2b] = ivl2;
-    return [fastMin(x1a, x2a), fastMax(x1b, x2b)];
+	const [x1a, x1b] = ivl1;
+	const [x2a, x2b] = ivl2;
+	return [fastMin(x1a, x2a), fastMax(x1b, x2b)];
 }
 
 export function ivlMeets(ivl1: Ivl, ivl2: Ivl): boolean {
-    const [x1a, x1b] = ivl1;
-    const [x2a, x2b] = ivl2;
-    return fastMax(x1a, x2a) < fastMin(x1b, x2b);
+	const [x1a, x1b] = ivl1;
+	const [x2a, x2b] = ivl2;
+	return fastMax(x1a, x2a) < fastMin(x1b, x2b);
 }
 
 export function ivlMeetsOrTouches(ivl1: Ivl, ivl2: Ivl): boolean {
-    const [x1a, x1b] = ivl1;
-    const [x2a, x2b] = ivl2;
-    return fastMax(x1a, x2a) <= fastMin(x1b, x2b);
+	const [x1a, x1b] = ivl1;
+	const [x2a, x2b] = ivl2;
+	return fastMax(x1a, x2a) <= fastMin(x1b, x2b);
 }
 
 /** computes the set difference on intervals. Precondition: they meet */
-export function ivlExcept<Index extends number>(ivl1: Ivl<Index>, ivl2: Ivl<Index>): Ivl<Index> | undefined {
-    const [x1a, x1b] = ivl1;
-    const [x2a, x2b] = ivl2;
-    if (x1a < x2a && x2b >= x1b) { return [x1a, x2a]; }
-    if (x1a >= x2a && x2b < x1b) { return [x2b, x1b]; }
-    return undefined;
+export function ivlExcept<Index extends number>(
+	ivl1: Ivl<Index>,
+	ivl2: Ivl<Index>,
+): Ivl<Index> | undefined {
+	const [x1a, x1b] = ivl1;
+	const [x2a, x2b] = ivl2;
+	if (x1a < x2a && x2b >= x1b) {
+		return [x1a, x2a];
+	}
+	if (x1a >= x2a && x2b < x1b) {
+		return [x2b, x1b];
+	}
+	return undefined;
 }
 
 function ivlMeet<Index extends number>(ivl1: Ivl<Index>, ivl2: Ivl<Index>): Ivl<Index> {
-    const [x1a, x1b] = ivl1;
-    const [x2a, x2b] = ivl2;
-    return [fastMax(x1a, x2a), fastMin(x1b, x2b)];
+	const [x1a, x1b] = ivl1;
+	const [x2a, x2b] = ivl2;
+	return [fastMax(x1a, x2a), fastMin(x1b, x2b)];
 }
 
-export function ivlCompare<Index extends number>(ivl1: Ivl<Index>, ivl2: Ivl<Index>): -1 | 0 | 1 | undefined {
-    const [x1a, x1b] = ivl1;
-    const [x2a, x2b] = ivl2;
-    if (x1a === x2a && x1b === x2b) { return 0; }
-    if (x1a >= x2a && x1b <= x2b) { return -1; }
-    if (x1a <= x2a && x1b >= x2b) { return 1; }
-    return undefined;
+export function ivlCompare<Index extends number>(
+	ivl1: Ivl<Index>,
+	ivl2: Ivl<Index>,
+): -1 | 0 | 1 | undefined {
+	const [x1a, x1b] = ivl1;
+	const [x2a, x2b] = ivl2;
+	if (x1a === x2a && x1b === x2b) {
+		return 0;
+	}
+	if (x1a >= x2a && x1b <= x2b) {
+		return -1;
+	}
+	if (x1a <= x2a && x1b >= x2b) {
+		return 1;
+	}
+	return undefined;
 }
 
 export interface Distribution {
-    /** The cummulative distribution function. This is used to compute the probabilty mass of a given interval. */
-    readonly cdf: (x: number) => number;
+	/** The cummulative distribution function. This is used to compute the probabilty mass of a given interval. */
+	readonly cdf: (x: number) => number;
 
-    /** The inverse cummulative distribution function. This is used to estimate a point given a quantile. */
-    readonly invCdf: (x: number) => number;
+	/** The inverse cummulative distribution function. This is used to estimate a point given a quantile. */
+	readonly invCdf: (x: number) => number;
 }
 
 /** This is a bounded pareto distribution with a shape parameter `alpha`, a lower bound `L` and an upper bound `H`.
@@ -75,76 +91,81 @@ export interface Distribution {
  * to cut next.
  */
 export function boundedPareto(alpha: number, L: number, H: number): Distribution {
-    const lAlpha = L ** alpha;
-    const cdfDenom = 1 - (L / H) ** alpha;
-    const hAlpha = H ** alpha;
-    const hlAlpha = hAlpha * lAlpha;
-    const hAlphaSubLAlpha = hAlpha - lAlpha;
-    const negAlphaInv = -1 / alpha;
-
-    const cdf =
-        alpha === 1 ? (x: number) => (1 - lAlpha / x) / cdfDenom : (x: number) => (1 - lAlpha * x ** -alpha) / cdfDenom;
-    const invCdf =
-        alpha === 1
-            ? (y: number) => 1 / ((hAlpha - y * hAlphaSubLAlpha) / hlAlpha)
-            : (y: number) => ((hAlpha - y * hAlphaSubLAlpha) / hlAlpha) ** negAlphaInv;
-
-    return { cdf, invCdf };
+	const lAlpha = L ** alpha;
+	const cdfDenom = 1 - (L / H) ** alpha;
+	const hAlpha = H ** alpha;
+	const hlAlpha = hAlpha * lAlpha;
+	const hAlphaSubLAlpha = hAlpha - lAlpha;
+	const negAlphaInv = -1 / alpha;
+
+	const cdf =
+		alpha === 1
+			? (x: number) => (1 - lAlpha / x) / cdfDenom
+			: (x: number) => (1 - lAlpha * x ** -alpha) / cdfDenom;
+	const invCdf =
+		alpha === 1
+			? (y: number) => 1 / ((hAlpha - y * hAlphaSubLAlpha) / hlAlpha)
+			: (y: number) => ((hAlpha - y * hAlphaSubLAlpha) / hlAlpha) ** negAlphaInv;
+
+	return { cdf, invCdf };
 }
 
 /** Creates a dimension splitter that operates on integer interval values and is based on a bounded Pareto
  * distribution. */
 export function boundedParetoSplitter<Index extends number>(
-    alpha: number,
-    L: number,
-    H: number,
+	alpha: number,
+	L: number,
+	H: number,
 ): DimensionSplitter<Pair<Index>> {
-    const distribution = boundedPareto(alpha, L, H);
-    return {
-        canSplit: ([keyLb, keyUb]) => keyUb - keyLb > 1,
-        split([keyLb, keyUb]: Pair<Index>) {
-            const ubCdf = distribution.cdf(keyUb);
-            const lbCdf = distribution.cdf(keyLb + 1);
-            const cuttingPoint = distribution.invCdf((ubCdf + lbCdf) / 2);
-            // pick a cutting point, but making sure either side has at least one element in it.
-            const discreteCuttingPoint = Math.min(Math.max(Math.round(cuttingPoint), keyLb + 1), keyUb - 1) as Index;
-
-            const leftProb = distribution.cdf(discreteCuttingPoint) - distribution.cdf(keyLb + 1);
-            const rightProb = distribution.cdf(keyUb) - distribution.cdf(discreteCuttingPoint);
-
-            const result: Pair<Pair<Pair<Index>, number>> = [
-                [[keyLb, discreteCuttingPoint], leftProb],
-                [[discreteCuttingPoint, keyUb], rightProb],
-            ];
-            return result;
-        },
-    };
+	const distribution = boundedPareto(alpha, L, H);
+	return {
+		canSplit: ([keyLb, keyUb]) => keyUb - keyLb > 1,
+		split([keyLb, keyUb]: Pair<Index>) {
+			const ubCdf = distribution.cdf(keyUb);
+			const lbCdf = distribution.cdf(keyLb + 1);
+			const cuttingPoint = distribution.invCdf((ubCdf + lbCdf) / 2);
+			// pick a cutting point, but making sure either side has at least one element in it.
+			const discreteCuttingPoint = Math.min(
+				Math.max(Math.round(cuttingPoint), keyLb + 1),
+				keyUb - 1,
+			) as Index;
+
+			const leftProb = distribution.cdf(discreteCuttingPoint) - distribution.cdf(keyLb + 1);
+			const rightProb = distribution.cdf(keyUb) - distribution.cdf(discreteCuttingPoint);
+
+			const result: Pair<Pair<Pair<Index>, number>> = [
+				[[keyLb, discreteCuttingPoint], leftProb],
+				[[discreteCuttingPoint, keyUb], rightProb],
+			];
+			return result;
+		},
+	};
 }
 
 export function boundedParetoSetOperations<Index extends number, Id>(
-    alpha: number,
-    L: number,
-    H: number,
-    top: Pair<Index>,
-    id: Id,
+	alpha: number,
+	L: number,
+	H: number,
+	top: Pair<Index>,
+	id: Id,
 ): SetOperations<Pair<Index>, Id> {
-    const splitter = boundedParetoSplitter<Index>(alpha, L, H);
-    return {
-        id,
-        split: (key) => splitter.split(key),
-        canSplit: (key) => splitter.canSplit(key),
-        meets: ivlMeets,
-        intersect: ivlMeet,
-        union: (x, y) => (ivlMeetsOrTouches(x, y) ? ivlJoin(x, y) : undefined),
-        except: ivlExcept,
-        compare: ivlCompare,
-        top,
-    };
+	const splitter = boundedParetoSplitter<Index>(alpha, L, H);
+	return {
+		id,
+		split: (key) => splitter.split(key),
+		canSplit: (key) => splitter.canSplit(key),
+		meets: ivlMeets,
+		intersect: ivlMeet,
+		union: (x, y) => (ivlMeetsOrTouches(x, y) ? ivlJoin(x, y) : undefined),
+		except: ivlExcept,
+		compare: ivlCompare,
+		top,
+	};
 }
 
 export interface DimensionSplitter<Key> {
-    /** For a given key, returns if the key can be further sub-divided. */
-    canSplit(key: Key): boolean;
-    /** Splits a key and returns the probability mass for either half. */
-    split(key: Key): Pair<Pair<Key, number>>;
+	/** For a given key, returns if the key can be further sub-divided. */
+	canSplit(key: Key): boolean;
+	/** Splits a key and returns the probability mass for either half. */
+	split(key: Key): Pair<Pair<Key, number>>;
 }

package/src/types.ts

@@ -7,10 +7,10 @@
 //       of SharedMatrix undo while we decide on the correct layering for undo.
 
 export interface IRevertible {
-    revert();
-    discard();
+	revert();
+	discard();
 }
 
 export interface IUndoConsumer {
-    pushToCurrentOperation(revertible: IRevertible);
+	pushToCurrentOperation(revertible: IRevertible);
 }

package/src/undoprovider.ts

@@ -4,157 +4,174 @@
  */
 
 import { assert } from "@fluidframework/common-utils";
-import { TrackingGroup, MergeTreeDeltaOperationType, MergeTreeDeltaType } from "@fluidframework/merge-tree";
+import {
+	TrackingGroup,
+	MergeTreeDeltaOperationType,
+	MergeTreeDeltaType,
+} from "@fluidframework/merge-tree";
 import { MatrixItem, SharedMatrix } from "./matrix";
 import { Handle, isHandleValid } from "./handletable";
 import { PermutationSegment, PermutationVector } from "./permutationvector";
 import { IUndoConsumer } from "./types";
 
 export class VectorUndoProvider {
-    // 'currentGroup' and 'currentOp' are used while applying an IRevertable.revert() to coalesce
-    // the recorded into a single IRevertable / tracking group as they move between the undo <->
-    // redo stacks.
-    private currentGroup?: TrackingGroup;
-    private currentOp?: MergeTreeDeltaType;
-
-    constructor(
-        private readonly manager: IUndoConsumer,
-        private readonly undoInsert: (segment: PermutationSegment) => void,
-        private readonly undoRemove: (segment: PermutationSegment) => void,
-    ) { }
-
-    public record(operation: MergeTreeDeltaOperationType, ranges: { segment: PermutationSegment; }[]) {
-        if (ranges.length > 0) {
-            // Link each segment to a new TrackingGroup.  A TrackingGroup keeps track of the original
-            // set of linked segments, including any fragmentatiton that occurs due to future splitting.
-            //
-            // A TrackingGroup also prevents removed segments from being unlinked from the tree during
-            // Zamboni and guarantees segments will not be merged/coalesced with segments outside of the
-            // current tracking group.
-            //
-            // These properties allow us to rely on MergeTree.getPosition() to find the locations/lengths
-            // of all content contained within the tracking group in the future.
-
-            // 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
-            // ops between the undo <-> redo stacks.
-            const trackingGroup = this.currentGroup ?? new TrackingGroup();
-            for (const range of ranges) {
-                trackingGroup.link(range.segment);
-            }
-
-            // For SharedMatrix, each IRevertibles always holds a single row/col operation.
-            // Therefore, 'currentOp' must either be undefined or equal to the current op.
-            assert(this.currentOp === undefined || this.currentOp === operation,
-                0x02a /* "On vector undo, unexpected 'currentOp' type/state!" */);
-
-            switch (operation) {
-                case MergeTreeDeltaType.INSERT:
-                    if (this.currentOp !== MergeTreeDeltaType.INSERT) {
-                        this.pushRevertible(trackingGroup, this.undoInsert);
-                    }
-                    break;
-
-                case MergeTreeDeltaType.REMOVE: {
-                    if (this.currentOp !== MergeTreeDeltaType.REMOVE) {
-                        this.pushRevertible(trackingGroup, this.undoRemove);
-                    }
-                    break;
-                }
-
-                default:
-                    throw new Error("operation type not revertible");
-            }
-
-            // If we are in the process of reverting, set 'currentOp' to remind ourselves not to push
-            // another revertible until `IRevertable.revert()` finishes the current op and clears this
-            // field.
-            if (this.currentGroup !== undefined) {
-                this.currentOp = operation;
-            }
-        }
-    }
-
-    private pushRevertible(trackingGroup: TrackingGroup, callback: (segment: PermutationSegment) => void) {
-        const revertible = {
-            revert: () => {
-                assert(this.currentGroup === undefined && this.currentOp === undefined,
-                    0x02b /* "Must not nest calls to IRevertible.revert()" */);
-
-                this.currentGroup = new TrackingGroup();
-
-                try {
-                    while (trackingGroup.size > 0) {
-                        const segment = trackingGroup.segments[0] as PermutationSegment;
-
-                        // Unlink 'segment' from the current tracking group before invoking the callback
-                        // to exclude the current undo/redo segment from those copied to the replacement
-                        // segment (if any). (See 'PermutationSegment.transferToReplacement()')
-                        segment.trackingCollection.unlink(trackingGroup);
-
-                        callback(segment);
-                    }
-                } finally {
-                    this.currentOp = undefined;
-                    this.currentGroup = undefined;
-                }
-            },
-            discard: () => {
-                while (trackingGroup.size > 0) {
-                    trackingGroup.unlink(trackingGroup.segments[0]);
-                }
-            },
-        };
-
-        this.manager.pushToCurrentOperation(revertible);
-
-        return revertible;
-    }
+	// 'currentGroup' and 'currentOp' are used while applying an IRevertable.revert() to coalesce
+	// the recorded into a single IRevertable / tracking group as they move between the undo <->
+	// redo stacks.
+	private currentGroup?: TrackingGroup;
+	private currentOp?: MergeTreeDeltaType;
+
+	constructor(
+		private readonly manager: IUndoConsumer,
+		private readonly undoInsert: (segment: PermutationSegment) => void,
+		private readonly undoRemove: (segment: PermutationSegment) => void,
+	) {}
+
+	public record(
+		operation: MergeTreeDeltaOperationType,
+		ranges: { segment: PermutationSegment }[],
+	) {
+		if (ranges.length > 0) {
+			// Link each segment to a new TrackingGroup.  A TrackingGroup keeps track of the original
+			// set of linked segments, including any fragmentatiton that occurs due to future splitting.
+			//
+			// A TrackingGroup also prevents removed segments from being unlinked from the tree during
+			// Zamboni and guarantees segments will not be merged/coalesced with segments outside of the
+			// current tracking group.
+			//
+			// These properties allow us to rely on MergeTree.getPosition() to find the locations/lengths
+			// of all content contained within the tracking group in the future.
+
+			// 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
+			// ops between the undo <-> redo stacks.
+			const trackingGroup = this.currentGroup ?? new TrackingGroup();
+			for (const range of ranges) {
+				trackingGroup.link(range.segment);
+			}
+
+			// For SharedMatrix, each IRevertibles always holds a single row/col operation.
+			// Therefore, 'currentOp' must either be undefined or equal to the current op.
+			assert(
+				this.currentOp === undefined || this.currentOp === operation,
+				0x02a /* "On vector undo, unexpected 'currentOp' type/state!" */,
+			);
+
+			switch (operation) {
+				case MergeTreeDeltaType.INSERT:
+					if (this.currentOp !== MergeTreeDeltaType.INSERT) {
+						this.pushRevertible(trackingGroup, this.undoInsert);
+					}
+					break;
+
+				case MergeTreeDeltaType.REMOVE: {
+					if (this.currentOp !== MergeTreeDeltaType.REMOVE) {
+						this.pushRevertible(trackingGroup, this.undoRemove);
+					}
+					break;
+				}
+
+				default:
+					throw new Error("operation type not revertible");
+			}
+
+			// If we are in the process of reverting, set 'currentOp' to remind ourselves not to push
+			// another revertible until `IRevertable.revert()` finishes the current op and clears this
+			// field.
+			if (this.currentGroup !== undefined) {
+				this.currentOp = operation;
+			}
+		}
+	}
+
+	private pushRevertible(
+		trackingGroup: TrackingGroup,
+		callback: (segment: PermutationSegment) => void,
+	) {
+		const revertible = {
+			revert: () => {
+				assert(
+					this.currentGroup === undefined && this.currentOp === undefined,
+					0x02b /* "Must not nest calls to IRevertible.revert()" */,
+				);
+
+				this.currentGroup = new TrackingGroup();
+
+				try {
+					while (trackingGroup.size > 0) {
+						const segment = trackingGroup.segments[0] as PermutationSegment;
+
+						// Unlink 'segment' from the current tracking group before invoking the callback
+						// to exclude the current undo/redo segment from those copied to the replacement
+						// segment (if any). (See 'PermutationSegment.transferToReplacement()')
+						segment.trackingCollection.unlink(trackingGroup);
+
+						callback(segment);
+					}
+				} finally {
+					this.currentOp = undefined;
+					this.currentGroup = undefined;
+				}
+			},
+			discard: () => {
+				while (trackingGroup.size > 0) {
+					trackingGroup.unlink(trackingGroup.segments[0]);
+				}
+			},
+		};
+
+		this.manager.pushToCurrentOperation(revertible);
+
+		return revertible;
+	}
 }
 
 export class MatrixUndoProvider<T> {
-    constructor(
-        private readonly consumer: IUndoConsumer,
-        private readonly matrix: SharedMatrix<T>,
-        private readonly rows: PermutationVector,
-        private readonly cols: PermutationVector,
-    ) {
-        rows.undo = new VectorUndoProvider(
-            consumer,
-            /* undoInsert: */ (segment: PermutationSegment) => {
-                const start = this.rows.getPosition(segment);
-                this.matrix.removeRows(start, segment.cachedLength);
-            },
-            /* undoRemove: */ (segment: PermutationSegment) => {
-                this.matrix._undoRemoveRows(segment);
-            },
-        );
-        cols.undo = new VectorUndoProvider(
-            consumer,
-            /* undoInsert: */ (segment: PermutationSegment) => {
-                const start = this.cols.getPosition(segment);
-                this.matrix.removeCols(start, segment.cachedLength);
-            },
-            /* undoRemove: */ (segment: PermutationSegment) => {
-                this.matrix._undoRemoveCols(segment);
-            },
-        );
-    }
-
-    cellSet(rowHandle: Handle, colHandle: Handle, oldValue: MatrixItem<T>) {
-        assert(isHandleValid(rowHandle) && isHandleValid(colHandle),
-            0x02c /* "On cellSet(), invalid row and/or column handles!" */);
-
-        if (this.consumer !== undefined) {
-            this.consumer.pushToCurrentOperation({
-                revert: () => {
-                    this.matrix.setCell(
-                        this.rows.handleToPosition(rowHandle),
-                        this.cols.handleToPosition(colHandle),
-                        oldValue);
-                },
-                discard: () => {},
-            });
-        }
-    }
+	constructor(
+		private readonly consumer: IUndoConsumer,
+		private readonly matrix: SharedMatrix<T>,
+		private readonly rows: PermutationVector,
+		private readonly cols: PermutationVector,
+	) {
+		rows.undo = new VectorUndoProvider(
+			consumer,
+			/* undoInsert: */ (segment: PermutationSegment) => {
+				const start = this.rows.getPosition(segment);
+				this.matrix.removeRows(start, segment.cachedLength);
+			},
+			/* undoRemove: */ (segment: PermutationSegment) => {
+				this.matrix._undoRemoveRows(segment);
+			},
+		);
+		cols.undo = new VectorUndoProvider(
+			consumer,
+			/* undoInsert: */ (segment: PermutationSegment) => {
+				const start = this.cols.getPosition(segment);
+				this.matrix.removeCols(start, segment.cachedLength);
+			},
+			/* undoRemove: */ (segment: PermutationSegment) => {
+				this.matrix._undoRemoveCols(segment);
+			},
+		);
+	}
+
+	cellSet(rowHandle: Handle, colHandle: Handle, oldValue: MatrixItem<T>) {
+		assert(
+			isHandleValid(rowHandle) && isHandleValid(colHandle),
+			0x02c /* "On cellSet(), invalid row and/or column handles!" */,
+		);
+
+		if (this.consumer !== undefined) {
+			this.consumer.pushToCurrentOperation({
+				revert: () => {
+					this.matrix.setCell(
+						this.rows.handleToPosition(rowHandle),
+						this.cols.handleToPosition(colHandle),
+						oldValue,
+					);
+				},
+				discard: () => {},
+			});
+		}
+	}
 }

package/tsconfig.esnext.json

@@ -1,7 +1,7 @@
 {
-    "extends": "./tsconfig.json",
-    "compilerOptions": {
-        "outDir": "./lib",
-        "module": "esnext"
-    },
-}
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"outDir": "./lib",
+		"module": "esnext",
+	},
+}

package/tsconfig.json

@@ -1,14 +1,10 @@
 {
-    "extends": "@fluidframework/build-common/ts-common-config.json",
-    "compilerOptions": {
-        "rootDir": "./src",
-        "outDir": "./dist",
-        "composite": true,
-    },
-    "include": [
-        "src/**/*"
-    ],
-    "exclude": [
-        "src/test/**/*"
-    ]
+	"extends": "@fluidframework/build-common/ts-common-config.json",
+	"compilerOptions": {
+		"rootDir": "./src",
+		"outDir": "./dist",
+		"composite": true,
+	},
+	"include": ["src/**/*"],
+	"exclude": ["src/test/**/*"],
 }