@fluidframework/matrix 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.224419

package/.eslintrc.js

@@ -4,28 +4,26 @@
  */
 
 module.exports = {
-    extends: [require.resolve("@fluidframework/eslint-config-fluid")],
-    parserOptions: {
-        project: ["./tsconfig.json", "./src/test/tsconfig.json"],
-    },
-    rules: {
-        "@typescript-eslint/no-shadow": "off",
-        "space-before-function-paren": "off", // Off because it conflicts with typescript-formatter
+	extends: [require.resolve("@fluidframework/eslint-config-fluid/minimal"), "prettier"],
 
-        // This library is used in the browser, so we don't want dependencies on most node libraries.
-        "import/no-nodejs-modules": ["error", { allow: ["events"] }],
-    },
-    overrides: [
-        {
-            // Rules only for test files
-            files: ["*.spec.ts", "src/test/**"],
-            rules: {
-                // Test files are run in node only so additional node libraries can be used.
-                "import/no-nodejs-modules": [
-                    "error",
-                    { allow: ["assert", "events"] },
-                ],
-            },
-        },
-    ],
+	parserOptions: {
+		project: ["./tsconfig.json", "./src/test/tsconfig.json"],
+	},
+	rules: {
+		"@typescript-eslint/no-shadow": "off",
+		"space-before-function-paren": "off", // Off because it conflicts with typescript-formatter
+
+		// This library is used in the browser, so we don't want dependencies on most node libraries.
+		"import/no-nodejs-modules": ["error", { allow: ["events"] }],
+	},
+	overrides: [
+		{
+			// Rules only for test files
+			files: ["*.spec.ts", "src/test/**"],
+			rules: {
+				// Test files are run in node only so additional node libraries can be used.
+				"import/no-nodejs-modules": ["error", { allow: ["assert", "events"] }],
+			},
+		},
+	],
 };

package/.mocharc.js

@@ -0,0 +1,12 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+"use strict";
+
+const getFluidTestMochaConfig = require("@fluidframework/mocha-test-setup/mocharc-common");
+
+const packageDir = __dirname;
+const config = getFluidTestMochaConfig(packageDir);
+module.exports = config;

package/CHANGELOG.md

@@ -0,0 +1,168 @@
+# @fluidframework/matrix
+
+## 2.0.0-internal.8.0.0
+
+### Major Changes
+
+-   sequence: Some function return types are now void instead of any [9a451d4946](https://github.com/microsoft/FluidFramework/commits/9a451d4946b5c51a52e4d1ab5bf51e7b285b0d74)
+
+    The return types of some functions have changed from `any` to `void` because the projects are now being compiled with
+    the `noImplicitAny` TypeScript compilation option. This does not represent a logic change and only serves to make the
+    typing of these functions more accurate.
+
+-   datastore-definitions: Jsonable and Serializable now require a generic parameter [9a451d4946](https://github.com/microsoft/FluidFramework/commits/9a451d4946b5c51a52e4d1ab5bf51e7b285b0d74)
+
+    The `Jsonable` and `Serializable` types from @fluidframework/datastore-definitions now require a generic parameter and
+    if that type is `any` or `unknown`will return a new result `JsonableTypeWith<>` that more accurately represents the
+    limitation of serialization.
+
+    Additional modifications:
+
+    -   `Jsonable`'s `TReplacement` parameter default has also been changed from `void` to `never`, which now disallows
+        `void`.
+    -   Unrecognized primitive types like `symbol` are now filtered to `never` instead of `{}`.
+    -   Recursive types with arrays (`[]`) are now supported.
+
+    `Serializable` is commonly used for DDS values and now requires more precision when using them. For example SharedMatrix
+    (unqualified) has an `any` default that meant values were `Serializable<any>` (i.e. `any`), but now `Serializable<any>`
+    is `JsonableTypeWith<IFluidHandle>` which may be problematic for reading or writing. Preferred correction is to specify
+    the value type but casting through `any` may provide a quick fix.
+
+## 2.0.0-internal.7.4.0
+
+Dependency updates only.
+
+## 2.0.0-internal.7.3.0
+
+Dependency updates only.
+
+## 2.0.0-internal.7.2.0
+
+Dependency updates only.
+
+## 2.0.0-internal.7.1.0
+
+Dependency updates only.
+
+## 2.0.0-internal.7.0.0
+
+### Major Changes
+
+-   Dependencies on @fluidframework/protocol-definitions package updated to 3.0.0 [871b3493dd](https://github.com/microsoft/FluidFramework/commits/871b3493dd0d7ea3a89be64998ceb6cb9021a04e)
+
+    This included the following changes from the protocol-definitions release:
+
+    -   Updating signal interfaces for some planned improvements. The intention is split the interface between signals
+        submitted by clients to the server and the resulting signals sent from the server to clients.
+        -   A new optional type member is available on the ISignalMessage interface and a new ISentSignalMessage interface has
+            been added, which will be the typing for signals sent from the client to the server. Both extend a new
+            ISignalMessageBase interface that contains common members.
+    -   The @fluidframework/common-definitions package dependency has been updated to version 1.0.0.
+
+-   Server upgrade: dependencies on Fluid server packages updated to 2.0.1 [871b3493dd](https://github.com/microsoft/FluidFramework/commits/871b3493dd0d7ea3a89be64998ceb6cb9021a04e)
+
+    Dependencies on the following Fluid server package have been updated to version 2.0.1:
+
+    -   @fluidframework/gitresources: 2.0.1
+    -   @fluidframework/server-kafka-orderer: 2.0.1
+    -   @fluidframework/server-lambdas: 2.0.1
+    -   @fluidframework/server-lambdas-driver: 2.0.1
+    -   @fluidframework/server-local-server: 2.0.1
+    -   @fluidframework/server-memory-orderer: 2.0.1
+    -   @fluidframework/protocol-base: 2.0.1
+    -   @fluidframework/server-routerlicious: 2.0.1
+    -   @fluidframework/server-routerlicious-base: 2.0.1
+    -   @fluidframework/server-services: 2.0.1
+    -   @fluidframework/server-services-client: 2.0.1
+    -   @fluidframework/server-services-core: 2.0.1
+    -   @fluidframework/server-services-ordering-kafkanode: 2.0.1
+    -   @fluidframework/server-services-ordering-rdkafka: 2.0.1
+    -   @fluidframework/server-services-ordering-zookeeper: 2.0.1
+    -   @fluidframework/server-services-shared: 2.0.1
+    -   @fluidframework/server-services-telemetry: 2.0.1
+    -   @fluidframework/server-services-utils: 2.0.1
+    -   @fluidframework/server-test-utils: 2.0.1
+    -   tinylicious: 2.0.1
+
+-   Minimum TypeScript version now 5.1.6 [871b3493dd](https://github.com/microsoft/FluidFramework/commits/871b3493dd0d7ea3a89be64998ceb6cb9021a04e)
+
+    The minimum supported TypeScript version for Fluid 2.0 clients is now 5.1.6.
+
+## 2.0.0-internal.6.4.0
+
+Dependency updates only.
+
+## 2.0.0-internal.6.3.0
+
+Dependency updates only.
+
+## 2.0.0-internal.6.2.0
+
+### Minor Changes
+
+-   Remove use of @fluidframework/common-definitions ([#16638](https://github.com/microsoft/FluidFramework/issues/16638)) [a8c81509c9](https://github.com/microsoft/FluidFramework/commits/a8c81509c9bf09cfb2092ebcf7265205f9eb6dbf)
+
+    The **@fluidframework/common-definitions** package is being deprecated, so the following interfaces and types are now
+    imported from the **@fluidframework/core-interfaces** package:
+
+    -   interface IDisposable
+    -   interface IErrorEvent
+    -   interface IErrorEvent
+    -   interface IEvent
+    -   interface IEventProvider
+    -   interface ILoggingError
+    -   interface ITaggedTelemetryPropertyType
+    -   interface ITelemetryBaseEvent
+    -   interface ITelemetryBaseLogger
+    -   interface ITelemetryErrorEvent
+    -   interface ITelemetryGenericEvent
+    -   interface ITelemetryLogger
+    -   interface ITelemetryPerformanceEvent
+    -   interface ITelemetryProperties
+    -   type ExtendEventProvider
+    -   type IEventThisPlaceHolder
+    -   type IEventTransformer
+    -   type ReplaceIEventThisPlaceHolder
+    -   type ReplaceIEventThisPlaceHolder
+    -   type TelemetryEventCategory
+    -   type TelemetryEventPropertyType
+
+## 2.0.0-internal.6.1.0
+
+Dependency updates only.
+
+## 2.0.0-internal.6.0.0
+
+### Major Changes
+
+-   Upgraded typescript transpilation target to ES2020 [8abce8cdb4](https://github.com/microsoft/FluidFramework/commits/8abce8cdb4e2832fb6405fb44e393bef03d5648a)
+
+    Upgraded typescript transpilation target to ES2020. This is done in order to decrease the bundle sizes of Fluid Framework packages. This has provided size improvements across the board for ex. Loader, Driver, Runtime etc. Reduced bundle sizes helps to load lesser code in apps and hence also helps to improve the perf.If any app wants to target any older versions of browsers with which this target version is not compatible, then they can use packages like babel to transpile to a older target.
+
+## 2.0.0-internal.5.4.0
+
+Dependency updates only.
+
+## 2.0.0-internal.5.3.0
+
+Dependency updates only.
+
+## 2.0.0-internal.5.2.0
+
+Dependency updates only.
+
+## 2.0.0-internal.5.1.0
+
+Dependency updates only.
+
+## 2.0.0-internal.5.0.0
+
+Dependency updates only.
+
+## 2.0.0-internal.4.4.0
+
+Dependency updates only.
+
+## 2.0.0-internal.4.1.0
+
+Dependency updates only.

package/README.md

@@ -1,14 +1,35 @@
 # @fluidframework/matrix
 
-SharedMatrix is a rectangular 2D array of values.  Matrix values are a superset of JSON serializable types that includes embedded IFluidHandle references to Fluid object.
+SharedMatrix is a rectangular 2D array of values. Matrix values are a superset of JSON serializable types that includes embedded IFluidHandle references to Fluid object.
+
+<!-- AUTO-GENERATED-CONTENT:START (README_DEPENDENCY_GUIDELINES_SECTION:includeHeading=TRUE) -->
+
+<!-- prettier-ignore-start -->
+<!-- NOTE: This section is automatically generated using @fluid-tools/markdown-magic. Do not update these generated contents directly. -->
+
+## Using Fluid Framework libraries
+
+When taking a dependency on a Fluid Framework library, we recommend using a `^` (caret) version range, such as `^1.3.4`.
+While Fluid Framework libraries may use different ranges with interdependencies between other Fluid Framework libraries,
+library consumers should always prefer `^`.
+
+Note that when depending on a library version of the form `2.0.0-internal.x.y.z`, called the Fluid internal version scheme,
+you must use a `>= <` dependency range (such as `>=2.0.0-internal.x.y.z <2.0.0-internal.w.0.0` where `w` is `x+1`).
+Standard `^` and `~` ranges will not work as expected.
+See the [@fluid-tools/version-tools](https://github.com/microsoft/FluidFramework/blob/main/build-tools/packages/version-tools/README.md)
+package for more information including tools to convert between version schemes.
+
+<!-- prettier-ignore-end -->
+
+<!-- AUTO-GENERATED-CONTENT:END -->
 
 ## Operations
 
 The SharedMatrix currently supports the following operations:
 
-* `insertCols(col, numCols)` / `removeCols(col, numCols)`
-* `insertRows(row, numRows)` / `removeRows(row, numRows)`
-* `setCells(row, col, numCols, values)` (values is a 1D array in row-major order)
+-   `insertCols(col, numCols)` / `removeCols(col, numCols)`
+-   `insertRows(row, numRows)` / `removeRows(row, numRows)`
+-   `setCells(row, col, numCols, values)` (values is a 1D array in row-major order)
 
 Insertion / removal operations are reconciled using Fluid sequence semantics, while setCells() uses Fluid map semantics.
 
@@ -16,8 +37,8 @@ Insertion / removal operations are reconciled using Fluid sequence semantics, wh
 
 The SharedMatrix data structure is comprised of:
 
-* Two 'PermutationVectors', which are used to process row/col insertion and removal ops
-* A sparse quadtree-like "physical store" for holding the cell values
+-   Two 'PermutationVectors', which are used to process row/col insertion and removal ops
+-   A sparse quadtree-like "physical store" for holding the cell values
 
 ### Permutation Vectors
 
@@ -57,7 +78,7 @@ physical row -> 1 | 8 .
 ```
 
 The next row/column to be inserted is assigned the next available physical address, regardless of
-where the row/col was logically inserted.  Deleted rows/cols are recycled after clearing the physical store.
+where the row/col was logically inserted. Deleted rows/cols are recycled after clearing the physical store.
 
 This indirection between logical row/col and storage row/col provides three functions:
 
@@ -66,12 +87,12 @@ This indirection between logical row/col and storage row/col provides three func
    updated).
 3. It enables us to "time-travel" to previous matrix versions when reconciling ops from remote clients.
 
-To support reconciliation, we use a MergeTree for each PermutationVector.  MergeTree is a B-Tree of order 7 that
+To support reconciliation, we use a MergeTree for each PermutationVector. MergeTree is a B-Tree of order 7 that
 temporarily maintains some extra metadata to reconcile ops while they are within the current collab window.
 
 ### Physical Storage
 
-Cell data is stored in a quadtree-like data structure that is a recursive subdivision of 16x16 tiles.  The
+Cell data is stored in a quadtree-like data structure that is a recursive subdivision of 16x16 tiles. The
 implementation leverages [Morton coding](https://en.wikipedia.org/wiki/Z-order_curve) to implement this as a cascade of
 fast 1D array accesses.
 
@@ -81,20 +102,59 @@ const keyLo = r0c0ToMorton2x16((row << 16) >>> 16, (col << 16) >>> 16);
 
 const level0 = this.root[keyHi];
 if (level0 !== undefined) {
-    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)];
-            }
-        }
-    }
+	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;   // Empty region
+return undefined; // Empty region
 ```
 
 A benefit of storing the cell data in [Z-order](https://en.wikipedia.org/wiki/Z-order_curve) is that both row-major and
-col-major traversal benefit from prefetching and cache coherence.  Reading/writing to the physical storage along either
+col-major traversal benefit from prefetching and cache coherence. Reading/writing to the physical storage along either
 axis is typically within an order of magnitude compared to sequentially accessing a cache hot native JavaScript array.
+
+### Switching From Last Write Win(LWW) to First Write Win(FWW) mode
+
+Shared Matrix allows to make to make one way switch from LWW to FWW. This is introduced in order to handle conflict
+when multiple clients at once initialize a cell. Using FWW, will help clients to receive a `conflict` event in case
+their change was rejected. They can resolve conflict with the new information that they received in the event.
+This event is only emitted when the SetCell Resolution Policy is First Write Win(FWW). This is emitted when two clients
+race and send changes without observing each other changes, the changes that gets sequenced last would be rejected, and
+only client who's changes rejected would be notified via this event, with expectation that it will merge its changes
+back by accounting new information (state from winner of the race).
+
+Some cases which documents how the Set op changes are applied or rejected during LWW -> FWW switch as some clients will
+be in FWW mode and some will in LWW mode. When app calls `switchSetCellPolicy` the policy is changed to FWW mode
+immediately and then later communicated to other clients via next SetOp which is made on the matrix.
+
+**Case 1:** When all clients have switched to FWW mode, then any race between 2 Set Op, will result in a `conflict` event
+at the loser client until it receives its own latest Set op. For example, client has sent op for cell C1. It receives remote
+ops R1 and R2 for cell C1. It will first raise `conflict` event when it receives R1 and then another `conflict` event when
+it receives R2. This will keep happening until it receives its own op, so that its changes are not lost due to conflict.
+
+**Case 2:** Client switches policy to FWW locally. No SetOp is made yet. This client has no pending changes yet. On receiving
+remote Set ops, this client will apply them all.
+
+**Case 3:** Client switches policy to FWW locally. This client has pending changes for cell C1. On
+receiving remote LWW Set op for C1, this client will reject it as its own op will finally be applied. So the first FWW
+SetOp is still treated as LWW op in a way. Now lets say it has received a remote FWW op for C1 instead of a LWW op, then
+the remote op would have been applied causing client's policy to shift to FWW with that op. It will also raise a conflict
+event locally as its Op for cell c1 will be rejected by other clients as it is a loser op.
+
+**Case 4:** In FWW mode, when there is no conflict, clients will still be able to overwrite cells. We track the sequence
+number for each cell when it was last edited and also track the clientId which made that change. If the receive a Op for
+cell C1, and its ref Sequence number is >= to sequence number at which it was last edited, then the cell would be
+overwritten. Otherwise, if the same client made the changes, then the op will still be applied as the client knew about
+the previous edit.
+
+**Case 5: Reconnection:** When a client makes an op in LWW mode in disconnected state for cell C1, then when it comes online
+later on, and catches up it sees a FWW op for C1, it will raise a `conflict` event for C1 and will not send it own op.
+It can receive many ops for C1 during catchup and will raise `conflict` event for each of those in case they are winner
+ops for C1.

package/api-extractor-lint.json

@@ -0,0 +1,4 @@
+{
+	"$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
+	"extends": "../../../common/build/build-common/api-extractor-lint.json"
+}

package/api-extractor.json

@@ -1,4 +1,4 @@
 {
-  "$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
-  "extends": "@fluidframework/build-common/api-extractor-common-report.json"
+	"$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
+	"extends": "../../../common/build/build-common/api-extractor-base.json"
 }

package/api-report/matrix.api.md

@@ -0,0 +1,130 @@
+## API Report File for "@fluidframework/matrix"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { IChannel } from '@fluidframework/datastore-definitions';
+import { IChannelAttributes } from '@fluidframework/datastore-definitions';
+import { IChannelFactory } from '@fluidframework/datastore-definitions';
+import { IChannelServices } from '@fluidframework/datastore-definitions';
+import { IChannelStorageService } from '@fluidframework/datastore-definitions';
+import { IEventThisPlaceHolder } from '@fluidframework/core-interfaces';
+import { IFluidDataStoreRuntime } from '@fluidframework/datastore-definitions';
+import { IFluidSerializer } from '@fluidframework/shared-object-base';
+import { IJSONSegment } from '@fluidframework/merge-tree';
+import { IMatrixConsumer } from '@tiny-calc/nano';
+import { IMatrixProducer } from '@tiny-calc/nano';
+import { IMatrixReader } from '@tiny-calc/nano';
+import { IMatrixWriter } from '@tiny-calc/nano';
+import { ISequencedDocumentMessage } from '@fluidframework/protocol-definitions';
+import { ISharedObjectEvents } from '@fluidframework/shared-object-base';
+import { ISummaryTreeWithStats } from '@fluidframework/runtime-definitions';
+import { Serializable } from '@fluidframework/datastore-definitions';
+import { SharedObject } from '@fluidframework/shared-object-base';
+
+// @alpha (undocumented)
+export interface IRevertible {
+    // (undocumented)
+    discard(): void;
+    // (undocumented)
+    revert(): void;
+}
+
+// @alpha
+export interface ISharedMatrixEvents<T> extends ISharedObjectEvents {
+    (event: "conflict", listener: (row: number, col: number, currentValue: MatrixItem<T>, conflictingValue: MatrixItem<T>, target: IEventThisPlaceHolder) => void): void;
+}
+
+// @alpha (undocumented)
+export interface IUndoConsumer {
+    // (undocumented)
+    pushToCurrentOperation(revertible: IRevertible): void;
+}
+
+// @alpha
+export type MatrixItem<T> = Serializable<Exclude<T, null>> | undefined;
+
+// @alpha
+export class SharedMatrix<T = any> extends SharedObject<ISharedMatrixEvents<T>> implements IMatrixProducer<MatrixItem<T>>, IMatrixReader<MatrixItem<T>>, IMatrixWriter<MatrixItem<T>> {
+    constructor(runtime: IFluidDataStoreRuntime, id: string, attributes: IChannelAttributes, _isSetCellConflictResolutionPolicyFWW?: boolean);
+    // (undocumented)
+    protected applyStashedOp(content: any): unknown;
+    // (undocumented)
+    closeMatrix(consumer: IMatrixConsumer<MatrixItem<T>>): void;
+    // (undocumented)
+    get colCount(): number;
+    // (undocumented)
+    static create<T>(runtime: IFluidDataStoreRuntime, id?: string): SharedMatrix<T>;
+    // (undocumented)
+    protected didAttach(): void;
+    // (undocumented)
+    getCell(row: number, col: number): MatrixItem<T>;
+    // (undocumented)
+    static getFactory(): SharedMatrixFactory;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    insertCols(colStart: number, count: number): void;
+    // (undocumented)
+    insertRows(rowStart: number, count: number): void;
+    // (undocumented)
+    isSetCellConflictResolutionPolicyFWW(): boolean;
+    // (undocumented)
+    protected loadCore(storage: IChannelStorageService): Promise<void>;
+    // (undocumented)
+    get matrixProducer(): IMatrixProducer<MatrixItem<T>>;
+    // (undocumented)
+    protected onConnect(): void;
+    // (undocumented)
+    protected onDisconnect(): void;
+    // (undocumented)
+    openMatrix(consumer: IMatrixConsumer<MatrixItem<T>>): IMatrixReader<MatrixItem<T>>;
+    openUndo(consumer: IUndoConsumer): void;
+    // (undocumented)
+    protected processCore(rawMessage: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown): void;
+    protected processGCDataCore(serializer: IFluidSerializer): void;
+    // (undocumented)
+    removeCols(colStart: number, count: number): void;
+    // (undocumented)
+    removeRows(rowStart: number, count: number): void;
+    // (undocumented)
+    protected reSubmitCore(content: any, localOpMetadata: unknown): void;
+    // (undocumented)
+    get rowCount(): number;
+    // (undocumented)
+    setCell(row: number, col: number, value: MatrixItem<T>): void;
+    // (undocumented)
+    setCells(rowStart: number, colStart: number, colCount: number, values: readonly MatrixItem<T>[]): void;
+    // (undocumented)
+    protected submitLocalMessage(message: any, localOpMetadata?: any): void;
+    // (undocumented)
+    protected summarizeCore(serializer: IFluidSerializer): ISummaryTreeWithStats;
+    switchSetCellPolicy(): void;
+    // (undocumented)
+    toString(): string;
+    // (undocumented)
+    _undoRemoveCols(colStart: number, spec: IJSONSegment): void;
+    // (undocumented)
+    _undoRemoveRows(rowStart: number, spec: IJSONSegment): void;
+}
+
+// @alpha
+export class SharedMatrixFactory implements IChannelFactory {
+    // (undocumented)
+    static readonly Attributes: IChannelAttributes;
+    // (undocumented)
+    get attributes(): IChannelAttributes;
+    // (undocumented)
+    create(document: IFluidDataStoreRuntime, id: string): IChannel;
+    // (undocumented)
+    load(runtime: IFluidDataStoreRuntime, id: string, services: IChannelServices, attributes: IChannelAttributes): Promise<IChannel>;
+    // (undocumented)
+    static Type: string;
+    // (undocumented)
+    get type(): string;
+}
+
+// (No @packageDocumentation comment for this package)
+
+```

package/dist/{handlecache.js → handlecache.cjs}

@@ -6,14 +6,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HandleCache = void 0;
 /* eslint-disable no-bitwise */
-const common_utils_1 = require("@fluidframework/common-utils");
-const handletable_1 = require("./handletable");
-const range_1 = require("./range");
+const core_utils_1 = require("@fluidframework/core-utils");
+const handletable_1 = require("./handletable.cjs");
+const range_1 = require("./range.cjs");
 /**
  * Used by PermutationVector to cache position -\> handle lookups.
  *
  * Perf: Possibly, this should eventually be inlined into PermutationVector itself, but
- *       so far there's no measurable perf penalty for being a separate object (node 12 x64)
+ * so far there's no measurable perf penalty for being a separate object (node 12 x64)
  */
 class HandleCache {
     constructor(vector) {
@@ -43,16 +43,14 @@ class HandleCache {
         // Perf: A cache hit implies that 'position' was in bounds.  Therefore, we can defer
         //       checking that 'position' is in bounds until 'cacheMiss(..)'.  This yields an
         //       ~40% speedup when the position is in the cache (node v12 x64).
-        return index < this.handles.length
-            ? this.handles[index]
-            : this.cacheMiss(position);
+        return index < this.handles.length ? this.handles[index] : this.cacheMiss(position);
     }
     /** Update the cache when a handle has been allocated for a given position. */
     addHandle(position, handle) {
-        (0, common_utils_1.assert)((0, handletable_1.isHandleValid)(handle), 0x017 /* "Trying to add invalid handle!" */);
+        (0, core_utils_1.assert)((0, handletable_1.isHandleValid)(handle), 0x017 /* "Trying to add invalid handle!" */);
         const index = this.getIndex(position);
         if (index < this.handles.length) {
-            (0, common_utils_1.assert)(!(0, handletable_1.isHandleValid)(this.handles[index]), 0x018 /* "Trying to insert handle into position with already valid handle!" */);
+            (0, core_utils_1.assert)(!(0, handletable_1.isHandleValid)(this.handles[index]), 0x018 /* "Trying to insert handle into position with already valid handle!" */);
             this.handles[index] = handle;
         }
     }
@@ -110,4 +108,4 @@ class HandleCache {
     }
 }
 exports.HandleCache = HandleCache;
-//# sourceMappingURL=handlecache.js.map
+//# sourceMappingURL=handlecache.cjs.map

package/dist/handlecache.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlecache.cjs","sourceRoot":"","sources":["../src/handlecache.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/* eslint-disable no-bitwise */\n\nimport { assert } from \"@fluidframework/core-utils\";\nimport { IVectorConsumer } from \"@tiny-calc/nano\";\nimport { Handle, isHandleValid } from \"./handletable\";\nimport { PermutationVector, PermutationSegment } from \"./permutationvector\";\nimport { ensureRange } from \"./range\";\n\n/**\n * Used by PermutationVector to cache position -\\> handle lookups.\n *\n * Perf: Possibly, this should eventually be inlined into PermutationVector itself, but\n * so far there's no measurable perf penalty for being a separate object (node 12 x64)\n */\nexport class HandleCache implements IVectorConsumer<Handle> {\n\tprivate handles: Handle[] = [];\n\tprivate start = 0;\n\n\tconstructor(public readonly vector: PermutationVector) {}\n\n\t/**\n\t * Returns the index of the given position in the 'handles' array as a Uint32.\n\t * (If the position is not in the array, returns an integer greater than 'handles.length').\n\t */\n\tprivate getIndex(position: number) {\n\t\treturn (position - this.start) >>> 0;\n\t}\n\n\t/**\n\t * Returns the handle currently assigned to the given 'position' (if any).  Check\n\t * the result with 'isValidHandle(..)' to see if a handle has been allocated for\n\t * the given position.\n\t *\n\t * Throws a 'RangeError' if the provided 'position' is out-of-bounds wrt. the\n\t * PermutationVector's length.\n\t */\n\tpublic getHandle(position: number) {\n\t\tconst index = this.getIndex(position);\n\n\t\t// Perf: To encourage inlining, handling of the 'cacheMiss(..)' case has been extracted\n\t\t//       to a separate method.\n\n\t\t// Perf: A cache hit implies that 'position' was in bounds.  Therefore, we can defer\n\t\t//       checking that 'position' is in bounds until 'cacheMiss(..)'.  This yields an\n\t\t//       ~40% speedup when the position is in the cache (node v12 x64).\n\n\t\treturn index < this.handles.length ? this.handles[index] : this.cacheMiss(position);\n\t}\n\n\t/** Update the cache when a handle has been allocated for a given position. */\n\tpublic addHandle(position: number, handle: Handle) {\n\t\tassert(isHandleValid(handle), 0x017 /* \"Trying to add invalid handle!\" */);\n\n\t\tconst index = this.getIndex(position);\n\t\tif (index < this.handles.length) {\n\t\t\tassert(\n\t\t\t\t!isHandleValid(this.handles[index]),\n\t\t\t\t0x018 /* \"Trying to insert handle into position with already valid handle!\" */,\n\t\t\t);\n\t\t\tthis.handles[index] = handle;\n\t\t}\n\t}\n\n\t/** Used by 'CacheMiss()' to retrieve handles for a range of positions. */\n\tprivate getHandles(start: number, end: number) {\n\t\t// TODO: This can be accelerated substantially using 'walkSegments()'.  The only catch\n\t\t//       is that\n\n\t\tconst handles: Handle[] = [];\n\t\tconst { vector } = this;\n\n\t\tfor (let pos = start; pos < end; pos++) {\n\t\t\tconst { segment, offset } = vector.getContainingSegment(pos);\n\t\t\tconst asPerm = segment as PermutationSegment;\n\t\t\t// eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n\t\t\thandles.push(asPerm.start + offset!);\n\t\t}\n\n\t\treturn handles;\n\t}\n\n\tprivate cacheMiss(position: number) {\n\t\t// Coercing 'position' to an Uint32 allows us to handle a negative 'position' value\n\t\t// with the same logic that handles 'position' >= length.\n\t\tconst _position = position >>> 0;\n\n\t\t// TODO: To bound memory usage, there should be a limit on the maximum size of\n\t\t//       handle[].\n\n\t\t// TODO: To reduce MergeTree lookups, this code should opportunistically grow\n\t\t//       the cache to the next MergeTree segment boundary (within the limits of\n\t\t//       the handle cache).\n\n\t\tif (_position < this.start) {\n\t\t\tthis.handles = this.getHandles(_position, this.start).concat(this.handles);\n\t\t\tthis.start = _position;\n\t\t\treturn this.handles[0];\n\t\t} else {\n\t\t\tensureRange(_position, this.vector.getLength());\n\n\t\t\tthis.handles = this.handles.concat(\n\t\t\t\tthis.getHandles(this.start + this.handles.length, _position + 1),\n\t\t\t);\n\t\t\treturn this.handles[this.handles.length - 1];\n\t\t}\n\t}\n\n\t// #region IVectorConsumer\n\n\titemsChanged(start: number, removedCount: number, insertedCount: number): void {\n\t\t// If positions were inserted/removed, our current policy is to trim the array\n\t\t// at the beginning of the invalidate range and lazily repopulate the handles\n\t\t// on demand.\n\t\t//\n\t\t// Some alternatives to consider that preserve the previously cached handles\n\t\t// that are still valid:\n\t\t//\n\t\t//      * Eagerly populate the 'handles[]' with the newly insert values (currently guaranteed\n\t\t//        to be Handle.unallocated, so we don't even need to look them up.)\n\t\t//\n\t\t//      * Use a sentinel value or other mechanism to allow \"holes\" in the cache.\n\n\t\tconst index = this.getIndex(start);\n\t\tif (index < this.handles.length) {\n\t\t\tthis.handles.length = index;\n\t\t}\n\t}\n\n\t// #endregion IVectorConsumer\n}\n"]}

package/dist/handlecache.d.ts

@@ -9,7 +9,7 @@ import { PermutationVector } from "./permutationvector";
  * Used by PermutationVector to cache position -\> handle lookups.
  *
  * Perf: Possibly, this should eventually be inlined into PermutationVector itself, but
- *       so far there's no measurable perf penalty for being a separate object (node 12 x64)
+ * so far there's no measurable perf penalty for being a separate object (node 12 x64)
  */
 export declare class HandleCache implements IVectorConsumer<Handle> {
     readonly vector: PermutationVector;

package/dist/handlecache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"handlecache.d.ts","sourceRoot":"","sources":["../src/handlecache.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,MAAM,EAAiB,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAsB,MAAM,qBAAqB,CAAC;AAG5E;;;;;GAKG;AACH,qBAAa,WAAY,YAAW,eAAe,CAAC,MAAM,CAAC;aAI3B,MAAM,EAAE,iBAAiB;IAHrD,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,KAAK,CAAK;gBAEU,MAAM,EAAE,iBAAiB;IAErD;;;OAGG;IACH,OAAO,CAAC,QAAQ;IAIhB;;;;;;;OAOG;IACI,SAAS,CAAC,QAAQ,EAAE,MAAM;IAejC,8EAA8E;IACvE,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAWjD,0EAA0E;IAC1E,OAAO,CAAC,UAAU;IAiBlB,OAAO,CAAC,SAAS;IA0BjB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,IAAI;CAoBjF"}
+{"version":3,"file":"handlecache.d.ts","sourceRoot":"","sources":["../src/handlecache.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,MAAM,EAAiB,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAsB,MAAM,qBAAqB,CAAC;AAG5E;;;;;GAKG;AACH,qBAAa,WAAY,YAAW,eAAe,CAAC,MAAM,CAAC;aAI9B,MAAM,EAAE,iBAAiB;IAHrD,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,KAAK,CAAK;gBAEU,MAAM,EAAE,iBAAiB;IAErD;;;OAGG;IACH,OAAO,CAAC,QAAQ;IAIhB;;;;;;;OAOG;IACI,SAAS,CAAC,QAAQ,EAAE,MAAM;IAajC,8EAA8E;IACvE,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAajD,0EAA0E;IAC1E,OAAO,CAAC,UAAU;IAiBlB,OAAO,CAAC,SAAS;IA4BjB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,IAAI;CAoB9E"}