@fluidframework/tree 2.100.0 → 2.101.0

package/lib/tableSchema.js

@@ -7,10 +7,16 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
 import { fail } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { EmptyKey } from "./core/index.js";
-import { TreeAlpha } from "./shared-tree/index.js";
+import { Tree, TreeAlpha } from "./shared-tree/index.js";
 import { TreeArrayNode, SchemaFactory, scoped, withBufferedTreeEvents, objectSchema, eraseSchemaDetailsSubclassable, createCustomizedFluidFrameworkScopedFactory, } from "./simple-tree/index.js";
 import { validateIndex, validateIndexRange } from "./util/index.js";
 /**
@@ -141,7 +147,7 @@ export var System_TableSchema;
      */
     // eslint-disable-next-line @typescript-eslint/explicit-function-return-type -- Return type is too complex to be reasonable to specify
     function createTableSchema(inputSchemaFactory, _cellSchema, columnSchema, rowSchema) {
-        var _Table_instances, _a, _Table_applyEditsInBatch, _Table_tryGetColumn, _Table_getColumn, _Table_tryGetRow, _Table_getRow, _Table_validateNewColumns, _Table_validateNewRows;
+        var _Table_instances, _a, _Table_rowCache, _Table_rowCacheUnsubscribe, _Table_columnCache, _Table_columnCacheUnsubscribe, _Table_applyEditsInBatch, _Table_getColumnCache, _Table_tryGetColumn, _Table_getColumn, _Table_getRowCache, _Table_tryGetRow, _Table_getRow, _Table_validateNewColumns, _Table_validateNewRows;
         const schemaFactory = createTableScopedFactory(inputSchemaFactory);
         /**
          * {@link Table} inner fields.
@@ -183,6 +189,50 @@ export var System_TableSchema;
             constructor(node) {
                 super(node ?? { table: { columns: [], rows: [] } });
                 _Table_instances.add(this);
+                // #region ID lookup caches
+                // Looking up rows/columns by string ID is a hot path (every getCell / setCell / etc. call goes
+                // through #tryGetRow or #tryGetColumn). Rather than scanning the arrays linearly on every call,
+                // we maintain lazily-built Maps from ID → node.
+                //
+                // Cache invalidation:
+                //   Each cache is marked stale (reset to `undefined`) by a `nodeChanged` listener registered on
+                //   the corresponding array node (this.table.rows / this.table.columns). `nodeChanged` fires on
+                //   an array node whenever an element is inserted, removed, or moved — exactly the set of
+                //   operations that could change which ID maps to which node. The event fires after the full
+                //   batch of edits has been applied (including remote edits received from collaborators), so the
+                //   cache is always rebuilt from a consistent, in-schema state.
+                //   TODO: Consider if we should do more fine-grained invalidation here. E.g. look at the specific deltas
+                //   returned by the `nodeChanged` event and only invalidate entries as needed.
+                //
+                // Listener lifetime:
+                //   The listener is registered exactly once per cache (guarded by the non-undefined check on the
+                //   stored unsubscribe callback).  Subsequent cache rebuilds after invalidation reuse the same
+                //   listener — no additional subscriptions accumulate.  The unsubscribe callback is stored so
+                //   that explicit cleanup is possible in the future if needed.
+                /**
+                 * Cache from row ID → row node for O(1) lookups in {@link Table.#tryGetRow}.
+                 * `undefined` means the cache is stale and must be rebuilt before use.
+                 */
+                _Table_rowCache.set(this, undefined);
+                /**
+                 * Unsubscribe function for the `nodeChanged` listener on `this.table.rows`.
+                 * `undefined` means the listener has not yet been registered (first cache build is pending).
+                 * After the first build, this is always defined and the listener remains active for the
+                 * lifetime of the Table node.
+                 */
+                _Table_rowCacheUnsubscribe.set(this, undefined);
+                /**
+                 * Cache from column ID → column node for O(1) lookups in {@link Table.#tryGetColumn}.
+                 * `undefined` means the cache is stale and must be rebuilt before use.
+                 */
+                _Table_columnCache.set(this, undefined);
+                /**
+                 * Unsubscribe function for the `nodeChanged` listener on `this.table.columns`.
+                 * `undefined` means the listener has not yet been registered (first cache build is pending).
+                 * After the first build, this is always defined and the listener remains active for the
+                 * lifetime of the Table node.
+                 */
+                _Table_columnCacheUnsubscribe.set(this, undefined);
             }
             static create(initialContents) {
                 // #region Input validation
@@ -565,7 +615,7 @@ export var System_TableSchema;
                 throw new UsageError(`The specified row node with ID "${rowOrIdOrIndex.id}" does not exist in the table.`);
             }
         }
-        _a = Table, _Table_instances = new WeakSet(), _Table_applyEditsInBatch = function _Table_applyEditsInBatch(options) {
+        _a = Table, _Table_rowCache = new WeakMap(), _Table_rowCacheUnsubscribe = new WeakMap(), _Table_columnCache = new WeakMap(), _Table_columnCacheUnsubscribe = new WeakMap(), _Table_instances = new WeakSet(), _Table_applyEditsInBatch = function _Table_applyEditsInBatch(options) {
             const { applyEdits, preconditions, preconditionsOnRevert } = options;
             const branch = TreeAlpha.branch(this);
             // Ensure events are paused until all of the edits are applied.
@@ -587,6 +637,26 @@ export var System_TableSchema;
                     }, preconditions === undefined ? undefined : { preconditions });
                 }
             });
+        }, _Table_getColumnCache = function _Table_getColumnCache() {
+            let cache = __classPrivateFieldGet(this, _Table_columnCache, "f");
+            if (cache === undefined) {
+                cache = new Map();
+                for (const column of this.table.columns) {
+                    // TypeScript is unable to narrow array element types correctly here.
+                    // See: https://github.com/microsoft/TypeScript/issues/52144
+                    cache.set(column.id, column);
+                }
+                __classPrivateFieldSet(this, _Table_columnCache, cache, "f");
+                // Register the invalidation listener once. The `nodeChanged` event fires on the
+                // array node itself after any structural change (insert / remove / move), which is
+                // exactly the set of changes that can alter the ID → node mapping.
+                if (__classPrivateFieldGet(this, _Table_columnCacheUnsubscribe, "f") === undefined) {
+                    __classPrivateFieldSet(this, _Table_columnCacheUnsubscribe, Tree.on(this.columns, "nodeChanged", () => {
+                        __classPrivateFieldSet(this, _Table_columnCache, undefined, "f");
+                    }), "f");
+                }
+            }
+            return cache;
         }, _Table_tryGetColumn = function _Table_tryGetColumn(columnOrIdOrIndex) {
             if (typeof columnOrIdOrIndex === "number") {
                 if (columnOrIdOrIndex < 0 || columnOrIdOrIndex >= this.table.columns.length) {
@@ -596,23 +666,39 @@ export var System_TableSchema;
                 // See: https://github.com/microsoft/TypeScript/issues/52144
                 return this.table.columns[columnOrIdOrIndex];
             }
+            const columnCache = __classPrivateFieldGet(this, _Table_instances, "m", _Table_getColumnCache).call(this);
             if (typeof columnOrIdOrIndex === "string") {
-                const columnId = columnOrIdOrIndex;
-                // TypeScript is unable to narrow the types correctly here, hence the casts.
-                // See: https://github.com/microsoft/TypeScript/issues/52144
-                return this.table.columns.find((col) => col.id === columnId);
+                return columnCache.get(columnOrIdOrIndex);
             }
             // If the user provided a node, ensure it actually exists in this table.
-            if (!this.table.columns.includes(columnOrIdOrIndex)) {
-                return undefined;
-            }
-            return columnOrIdOrIndex;
+            const cached = columnCache.get(columnOrIdOrIndex.id);
+            return cached === columnOrIdOrIndex ? columnOrIdOrIndex : undefined;
         }, _Table_getColumn = function _Table_getColumn(columnOrIdOrIndex) {
             const column = __classPrivateFieldGet(this, _Table_instances, "m", _Table_tryGetColumn).call(this, columnOrIdOrIndex);
             if (column === undefined) {
                 _a._throwMissingColumnError(columnOrIdOrIndex);
             }
             return column;
+        }, _Table_getRowCache = function _Table_getRowCache() {
+            let cache = __classPrivateFieldGet(this, _Table_rowCache, "f");
+            if (cache === undefined) {
+                cache = new Map();
+                for (const row of this.table.rows) {
+                    // TypeScript is unable to narrow array element types correctly here.
+                    // See: https://github.com/microsoft/TypeScript/issues/52144
+                    cache.set(row.id, row);
+                }
+                __classPrivateFieldSet(this, _Table_rowCache, cache, "f");
+                // Register the invalidation listener once. The `nodeChanged` event fires on the
+                // array node itself after any structural change (insert / remove / move), which is
+                // exactly the set of changes that can alter the ID → node mapping.
+                if (__classPrivateFieldGet(this, _Table_rowCacheUnsubscribe, "f") === undefined) {
+                    __classPrivateFieldSet(this, _Table_rowCacheUnsubscribe, Tree.on(this.rows, "nodeChanged", () => {
+                        __classPrivateFieldSet(this, _Table_rowCache, undefined, "f");
+                    }), "f");
+                }
+            }
+            return cache;
         }, _Table_tryGetRow = function _Table_tryGetRow(rowOrIdOrIndex) {
             if (typeof rowOrIdOrIndex === "number") {
                 if (rowOrIdOrIndex < 0 || rowOrIdOrIndex >= this.table.rows.length) {
@@ -622,17 +708,13 @@ export var System_TableSchema;
                 // See: https://github.com/microsoft/TypeScript/issues/52144
                 return this.table.rows[rowOrIdOrIndex];
             }
+            const rowCache = __classPrivateFieldGet(this, _Table_instances, "m", _Table_getRowCache).call(this);
             if (typeof rowOrIdOrIndex === "string") {
-                const rowId = rowOrIdOrIndex;
-                // TypeScript is unable to narrow the types correctly here, hence the casts.
-                // See: https://github.com/microsoft/TypeScript/issues/52144
-                return this.table.rows.find((row) => row.id === rowId);
+                return rowCache.get(rowOrIdOrIndex);
             }
             // If the user provided a node, ensure it actually exists in this table.
-            if (!this.table.rows.includes(rowOrIdOrIndex)) {
-                return undefined;
-            }
-            return rowOrIdOrIndex;
+            const cached = rowCache.get(rowOrIdOrIndex.id);
+            return cached === rowOrIdOrIndex ? rowOrIdOrIndex : undefined;
         }, _Table_getRow = function _Table_getRow(rowOrIdOrIndex) {
             const row = __classPrivateFieldGet(this, _Table_instances, "m", _Table_tryGetRow).call(this, rowOrIdOrIndex);
             if (row === undefined) {
@@ -640,9 +722,9 @@ export var System_TableSchema;
             }
             return row;
         }, _Table_validateNewColumns = function _Table_validateNewColumns(newColumns) {
-            return _a._validateNewColumns(newColumns, new Set(this.table.columns.map((column) => column.id)));
+            return _a._validateNewColumns(newColumns, __classPrivateFieldGet(this, _Table_instances, "m", _Table_getColumnCache).call(this));
         }, _Table_validateNewRows = function _Table_validateNewRows(newRows) {
-            return _a._validateNewRows(newRows, new Set(this.table.rows.map((row) => row.id)), new Set(this.table.columns.map((column) => column.id)));
+            return _a._validateNewRows(newRows, __classPrivateFieldGet(this, _Table_instances, "m", _Table_getRowCache).call(this), __classPrivateFieldGet(this, _Table_instances, "m", _Table_getColumnCache).call(this));
         };
         // Returning SingletonSchema without a type conversion results in TypeScript generating something like `readonly "__#124291@#brand": unknown;`
         // for the private brand field of TreeNode.