@fluidframework/tree 2.103.0 → 2.110.0

package/lib/tableSchema.js

@@ -2,23 +2,13 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    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 { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
+import { assert, fail, oob } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { EmptyKey } from "./core/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";
+import { collectContiguousRanges, validateIndex, validateIndexRange } from "./util/index.js";
 /**
  * Not intended for use outside of this package.
  *
@@ -147,7 +137,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_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;
+        var _Table_instances, _a, _Table_rowCache, _Table_rowCacheUnsubscribe, _Table_columnCache, _Table_columnCacheUnsubscribe, _Table_applyEditsInBatch, _Table_buildColumnInDocumentConstraintsForRows, _Table_getColumnCache, _Table_tryGetColumnId, _Table_tryGetColumn, _Table_getColumn, _Table_getRowCache, _Table_tryGetRow, _Table_getRow, _Table_validateNewColumns, _Table_validateNewRows;
         const schemaFactory = createTableScopedFactory(inputSchemaFactory);
         /**
          * {@link Table} inner fields.
@@ -277,13 +267,27 @@ export var System_TableSchema;
                 if (row === undefined) {
                     return undefined;
                 }
-                const column = __classPrivateFieldGet(this, _Table_instances, "m", _Table_tryGetColumn).call(this, columnOrIdOrIndex);
-                if (column === undefined) {
+                const columnId = __classPrivateFieldGet(this, _Table_instances, "m", _Table_tryGetColumnId).call(this, columnOrIdOrIndex);
+                if (columnId === undefined) {
                     return undefined;
                 }
-                return row.cells[column.id];
+                return row.cells[columnId];
             }
-            insertColumns({ columns, index, }) {
+            insertColumns(columnsOrParams, maybeIndex) {
+                // Dispatch on the runtime type of the first argument to disambiguate the two overloads:
+                //  * Array  → positional `(columns, index?)` overload
+                //  * object → deprecated `(params)` property-bag overload
+                let index;
+                let columns;
+                if (Array.isArray(columnsOrParams)) {
+                    index = maybeIndex;
+                    columns = columnsOrParams;
+                }
+                else {
+                    const params = columnsOrParams;
+                    index = params.index;
+                    columns = params.columns;
+                }
                 // #region Input validation
                 // Ensure specified index is valid
                 if (index !== undefined) {
@@ -323,7 +327,21 @@ export var System_TableSchema;
                 // Inserting the input nodes into the tree hydrates them, making them usable as nodes.
                 return columns;
             }
-            insertRows({ index, rows, }) {
+            insertRows(rowsOrParams, maybeIndex) {
+                // Dispatch on the runtime type of the first argument to disambiguate the two overloads:
+                //  * Array  → positional `(rows, index?)` overload
+                //  * object → deprecated `(params)` property-bag overload
+                let index;
+                let rows;
+                if (Array.isArray(rowsOrParams)) {
+                    index = maybeIndex;
+                    rows = rowsOrParams;
+                }
+                else {
+                    const params = rowsOrParams;
+                    index = params.index;
+                    rows = params.rows;
+                }
                 // #region Input validation
                 // Ensure specified index is valid
                 if (index !== undefined) {
@@ -332,16 +350,14 @@ export var System_TableSchema;
                 // Ensure the new rows being inserted are valid
                 __classPrivateFieldGet(this, _Table_instances, "m", _Table_validateNewRows).call(this, rows);
                 // #endregion
-                // Relevant invariant: each cell corresponds to an existing row and column
+                // Relevant invariant: each cell corresponds to an existing row and column.
                 // Prevents cell leaks from concurrently removed columns.
                 // Example scenario: Client A removes a column while concurrently Client B adds a row with cells for those columns (including the one A removed).
                 // If client B is sequenced after A, then B's row could have cells that do not correspond to existing columns.
-                // This constraint ensures all columns that existed when creating the row still exist when the row insertion is applied.
+                // We only need to constrain columns that the new rows actually reference — a removed column with no
+                // corresponding cell in the inserted rows cannot orphan anything from this insertion.
                 // TODO: Replace with "no detach" constraint on the column array when available.
-                const columnConstraints = this.table.columns.map((column) => ({
-                    type: "nodeInDocument",
-                    node: column,
-                }));
+                const columnConstraints = __classPrivateFieldGet(this, _Table_instances, "m", _Table_buildColumnInDocumentConstraintsForRows).call(this, rows);
                 __classPrivateFieldGet(this, _Table_instances, "m", _Table_applyEditsInBatch).call(this, {
                     applyEdits: () => {
                         // TypeScript is unable to narrow the row type correctly here, hence the casts below.
@@ -355,13 +371,29 @@ export var System_TableSchema;
                             this.table.rows.insertAt(index, TreeArrayNode.spread(rows));
                         }
                     },
-                    preconditions: columnConstraints.length > 0 ? columnConstraints : undefined,
+                    preconditions: columnConstraints,
                 });
                 // Inserting the input nodes into the tree hydrates them, making them usable as nodes.
                 return rows;
             }
-            setCell({ key, cell, }) {
-                const { column: columnOrId, row: rowOrId } = key;
+            setCell(rowOrParams, maybeColumn, maybeCell) {
+                // Dispatch on the presence of the second argument to disambiguate the two overloads:
+                //  * `maybeColumn === undefined` → deprecated `(params)` property-bag overload; unpack from `params.key`/`params.cell`
+                //  * otherwise                   → positional `(row, column, cell)` overload
+                let rowOrId;
+                let columnOrId;
+                let cell;
+                if (maybeColumn === undefined) {
+                    const params = rowOrParams;
+                    rowOrId = params.key.row;
+                    columnOrId = params.key.column;
+                    cell = params.cell;
+                }
+                else {
+                    rowOrId = rowOrParams;
+                    columnOrId = maybeColumn;
+                    cell = maybeCell;
+                }
                 const row = __classPrivateFieldGet(this, _Table_instances, "m", _Table_getRow).call(this, rowOrId);
                 const column = __classPrivateFieldGet(this, _Table_instances, "m", _Table_getColumn).call(this, columnOrId);
                 __classPrivateFieldGet(this, _Table_instances, "m", _Table_applyEditsInBatch).call(this, {
@@ -412,13 +444,15 @@ export var System_TableSchema;
                     __classPrivateFieldGet(this, _Table_instances, "m", _Table_applyEditsInBatch).call(this, {
                         applyEdits: () => {
                             const columnsToRemove = this.table.columns.slice(startIndex, endIndex);
-                            // First, remove all cells that correspond to each column from each row:
-                            for (const column of columnsToRemove) {
-                                for (const row of this.table.rows) {
-                                    // TypeScript is unable to narrow the row type correctly here, hence the cast.
-                                    // See: https://github.com/microsoft/TypeScript/issues/52144
+                            // First, remove all cells that correspond to each column from each row.
+                            // Rows are the outer loop so each row's `cells` record is touched contiguously,
+                            // and the per-column `id` values are read once up front instead of per (column, row) pair.
+                            const idsToDelete = columnsToRemove.map((column) => column.id);
+                            for (const row of this.table.rows) {
+                                const cells = row.cells;
+                                for (const id of idsToDelete) {
                                     // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- This is currently how Record node entries are deleted.
-                                    delete row.cells[column.id];
+                                    delete cells[id];
                                 }
                             }
                             // Second, remove the column nodes:
@@ -435,44 +469,45 @@ export var System_TableSchema;
                         return [];
                     }
                     // Resolve any IDs to actual nodes.
-                    // This validates that all of the rows exist before starting transaction.
+                    // This validates that all of the columns exist before starting transaction.
                     // This improves user-facing error experience.
-                    const columnsToRemove = [];
+                    // Set insertion order is preserved on iteration, which matches the caller-supplied order
+                    // expected by both the cell-deletion loop and the returned array.
+                    const columnsToRemove = new Set();
                     for (const columnOrIdToRemove of indexOrColumns) {
-                        columnsToRemove.push(__classPrivateFieldGet(this, _Table_instances, "m", _Table_getColumn).call(this, columnOrIdToRemove));
+                        columnsToRemove.add(__classPrivateFieldGet(this, _Table_instances, "m", _Table_getColumn).call(this, columnOrIdToRemove));
                     }
+                    // Collect contiguous runs of columns-to-remove as [start, end) ranges so they can be
+                    // removed via a small number of `removeRange` calls below.
+                    const ranges = collectContiguousRanges(this.table.columns, (column) => columnsToRemove.has(column));
+                    // Note, throwing an error within a transaction will abort the entire transaction.
+                    // So if we throw an error here for any column, no columns will be removed.
                     __classPrivateFieldGet(this, _Table_instances, "m", _Table_applyEditsInBatch).call(this, {
                         applyEdits: () => {
-                            // Note, throwing an error within a transaction will abort the entire transaction.
-                            // So if we throw an error here for any column, no columns will be removed.
-                            for (const columnToRemove of columnsToRemove) {
-                                // Remove the corresponding cell from all rows.
-                                for (const row of this.table.rows) {
-                                    // TypeScript is unable to narrow the row type correctly here, hence the cast.
-                                    // See: https://github.com/microsoft/TypeScript/issues/52144
+                            // Remove the corresponding cell from every row.
+                            // The per-column `id` values are hoisted out of the row loop so each row's `cells`
+                            // record is indexed by a plain string rather than re-reading a tree-node property.
+                            const idsToDelete = Array.from(columnsToRemove, (column) => column.id);
+                            for (const row of this.table.rows) {
+                                const cells = row.cells;
+                                for (const id of idsToDelete) {
                                     // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- This is currently how Record node entries are deleted.
-                                    delete row.cells[columnToRemove.id];
+                                    delete cells[id];
                                 }
-                                // We have already validated that all of the columns exist above, so this is safe.
-                                this.table.columns.removeAt(this.table.columns.indexOf(columnToRemove));
+                            }
+                            // Remove column nodes. Ranges are iterated in reverse so each `removeRange`
+                            // call doesn't shift the indices of yet-to-remove ranges at lower positions.
+                            for (let r = ranges.length - 1; r >= 0; r--) {
+                                const { start, end } = ranges[r] ?? oob();
+                                this.table.columns.removeRange(start, end);
                             }
                         },
                         preconditions,
                     });
-                    return columnsToRemove;
+                    return [...columnsToRemove];
                 }
             }
             removeRows(indexOrRows, count) {
-                // Relevant invariant: each cell corresponds to an existing row and column
-                // Adding a constraint on columns here to prevent cells being orphaned.  The relevant scenario is:
-                // Client A removes rows
-                // Client B (either concurrently or not, so long as B's edit is sequenced after A's edit) removes a column,
-                // Client A reverts the removal of the rows
-                // TODO: Replace with "no detach on revert" constraint on the column array when available.
-                const columnConstraints = this.table.columns.map((column) => ({
-                    type: "nodeInDocument",
-                    node: column,
-                }));
                 if (typeof indexOrRows === "number" || indexOrRows === undefined) {
                     let removedRows;
                     const startIndex = indexOrRows ?? 0;
@@ -482,11 +517,18 @@ export var System_TableSchema;
                         return [];
                     }
                     validateIndexRange(startIndex, endIndex, this.table.rows, "Table.removeRows");
+                    // Compute revert constraints from the rows being removed.
+                    const rowsBeingRemoved = this.table.rows.slice(startIndex, endIndex);
                     __classPrivateFieldGet(this, _Table_instances, "m", _Table_applyEditsInBatch).call(this, {
                         applyEdits: () => {
                             removedRows = removeRangeFromArray(startIndex, endIndex, this.table.rows, "Table.removeRows");
                         },
-                        preconditionsOnRevert: columnConstraints.length > 0 ? columnConstraints : undefined,
+                        // Relevant invariant: each cell corresponds to an existing row and column.
+                        // On revert, the removed rows come back with their original cells, so we need
+                        // each column referenced by those cells to still exist. Columns the removed rows
+                        // don't reference cannot be orphaned by the revert and need not be constrained.
+                        // TODO: Replace with "no detach on revert" constraint on the column array when available.
+                        preconditionsOnRevert: __classPrivateFieldGet(this, _Table_instances, "m", _Table_buildColumnInDocumentConstraintsForRows).call(this, rowsBeingRemoved),
                     });
                     return removedRows ?? fail(0xccd /* Transaction did not complete */);
                 }
@@ -497,26 +539,50 @@ export var System_TableSchema;
                 // Resolve any IDs to actual nodes.
                 // This validates that all of the rows exist before starting transaction.
                 // This improves user-facing error experience.
-                const rowsToRemove = [];
+                // Set insertion order is preserved on iteration, which matches the caller-supplied order
+                // expected by the returned array.
+                const rowsToRemove = new Set();
                 for (const rowToRemove of indexOrRows) {
-                    rowsToRemove.push(__classPrivateFieldGet(this, _Table_instances, "m", _Table_getRow).call(this, rowToRemove));
+                    rowsToRemove.add(__classPrivateFieldGet(this, _Table_instances, "m", _Table_getRow).call(this, rowToRemove));
                 }
+                // Collect contiguous runs of rows-to-remove as [start, end) ranges so they can be
+                // removed via a small number of `removeRange` calls below.
+                const ranges = collectContiguousRanges(this.table.rows, (row) => rowsToRemove.has(row));
+                // Note, throwing an error within a transaction will abort the entire transaction.
+                // So if we throw an error here for any row, no rows will be removed.
                 __classPrivateFieldGet(this, _Table_instances, "m", _Table_applyEditsInBatch).call(this, {
                     applyEdits: () => {
-                        // Note, throwing an error within a transaction will abort the entire transaction.
-                        // So if we throw an error here for any row, no rows will be removed.
-                        for (const rowToRemove of rowsToRemove) {
-                            // We have already validated that all of the rows exist above, so this is safe.
-                            const index = this.table.rows.indexOf(rowToRemove);
-                            this.table.rows.removeAt(index);
+                        // Ranges are iterated in reverse so each `removeRange` call doesn't shift
+                        // the indices of yet-to-remove ranges at lower positions.
+                        for (let r = ranges.length - 1; r >= 0; r--) {
+                            const { start, end } = ranges[r] ?? oob();
+                            this.table.rows.removeRange(start, end);
                         }
                     },
-                    preconditionsOnRevert: columnConstraints.length > 0 ? columnConstraints : undefined,
+                    // Relevant invariant: each cell corresponds to an existing row and column.
+                    // On revert, the removed rows come back with their original cells, so we need
+                    // each column referenced by those cells to still exist. Columns the removed rows
+                    // don't reference cannot be orphaned by the revert and need not be constrained.
+                    // TODO: Replace with "no detach on revert" constraint on the column array when available.
+                    preconditionsOnRevert: __classPrivateFieldGet(this, _Table_instances, "m", _Table_buildColumnInDocumentConstraintsForRows).call(this, rowsToRemove),
                 });
-                return rowsToRemove;
+                return [...rowsToRemove];
             }
-            removeCell(key) {
-                const { column: columnOrIdOrIndex, row: rowOrIdOrIndex } = key;
+            removeCell(rowOrKey, maybeColumn) {
+                // Dispatch on the presence of the second argument to disambiguate the two overloads:
+                //  * `maybeColumn === undefined` → deprecated `(key)` overload; unpack from `key.row`/`key.column`
+                //  * otherwise                   → positional `(row, column)` overload
+                let rowOrIdOrIndex;
+                let columnOrIdOrIndex;
+                if (maybeColumn === undefined) {
+                    const key = rowOrKey;
+                    rowOrIdOrIndex = key.row;
+                    columnOrIdOrIndex = key.column;
+                }
+                else {
+                    rowOrIdOrIndex = rowOrKey;
+                    columnOrIdOrIndex = maybeColumn;
+                }
                 const row = __classPrivateFieldGet(this, _Table_instances, "m", _Table_getRow).call(this, rowOrIdOrIndex);
                 const column = __classPrivateFieldGet(this, _Table_instances, "m", _Table_getColumn).call(this, columnOrIdOrIndex);
                 const cell = row.cells[column.id];
@@ -590,10 +656,9 @@ export var System_TableSchema;
                     // #region If the row contains cells, verify that the table contains the columns for those cells
                     // Note: we intentionally hide `cells` on `IRow` to avoid leaking the internal data representation as much as possible, so we have to cast here.
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
-                    if (newRow.cells !== undefined) {
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
-                        const keys = Object.keys(newRow.cells);
-                        for (const key of keys) {
+                    const cells = newRow.cells;
+                    if (cells !== undefined) {
+                        for (const key of Object.keys(cells)) {
                             if (!columnIds.has(key)) {
                                 throw new UsageError(`Attempted to insert a row containing a cell under column ID "${key}", but the table does not contain a column with that ID.`);
                             }
@@ -637,6 +702,32 @@ export var System_TableSchema;
                     }, preconditions === undefined ? undefined : { preconditions });
                 }
             });
+        }, _Table_buildColumnInDocumentConstraintsForRows = function _Table_buildColumnInDocumentConstraintsForRows(rows) {
+            if (!TreeAlpha.context(this).isBranch()) {
+                return undefined;
+            }
+            const referencedColumnIds = new Set();
+            for (const row of rows) {
+                // `cells` is intentionally hidden on the public row type, so cast to read it.
+                const cells = row.cells;
+                if (cells === undefined) {
+                    continue;
+                }
+                for (const id of Object.keys(cells)) {
+                    referencedColumnIds.add(id);
+                }
+            }
+            if (referencedColumnIds.size === 0) {
+                return undefined;
+            }
+            const columnCache = __classPrivateFieldGet(this, _Table_instances, "m", _Table_getColumnCache).call(this);
+            const constraints = [];
+            for (const id of referencedColumnIds) {
+                const column = columnCache.get(id) ?? fail(0xd05 /* Column ID not found in cache */);
+                constraints.push({ type: "nodeInDocument", node: column });
+            }
+            assert(constraints.length > 0, 0xd06 /* No constraints generated for column references. */);
+            return constraints;
         }, _Table_getColumnCache = function _Table_getColumnCache() {
             let cache = __classPrivateFieldGet(this, _Table_columnCache, "f");
             if (cache === undefined) {
@@ -657,6 +748,11 @@ export var System_TableSchema;
                 }
             }
             return cache;
+        }, _Table_tryGetColumnId = function _Table_tryGetColumnId(columnOrIdOrIndex) {
+            if (typeof columnOrIdOrIndex === "string") {
+                return columnOrIdOrIndex;
+            }
+            return __classPrivateFieldGet(this, _Table_instances, "m", _Table_tryGetColumn).call(this, columnOrIdOrIndex)?.id;
         }, _Table_tryGetColumn = function _Table_tryGetColumn(columnOrIdOrIndex) {
             if (typeof columnOrIdOrIndex === "number") {
                 if (columnOrIdOrIndex < 0 || columnOrIdOrIndex >= this.table.columns.length) {