@fluidframework/tree 2.72.0 → 2.73.0

package/lib/tableSchema.js

@@ -2,10 +2,16 @@
  * 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);
+};
 import { fail } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
-import { Tree, TreeAlpha } from "./shared-tree/index.js";
-import { TreeArrayNode, SchemaFactory, isArrayNodeSchema, withBufferedTreeEvents, } from "./simple-tree/index.js";
+import { TreeAlpha } from "./shared-tree/index.js";
+import { TreeArrayNode, SchemaFactory, withBufferedTreeEvents, } from "./simple-tree/index.js";
+import { validateIndex, validateIndexRange } from "./util/index.js";
 // Future improvement TODOs:
 // - Omit `cells` property from Row insertion type.
 // - Record-like type parameters / input parameters?
@@ -16,32 +22,10 @@ import { TreeArrayNode, SchemaFactory, isArrayNodeSchema, withBufferedTreeEvents
  * The sub-scope applied to user-provided {@link SchemaFactory}s by table schema factories.
  */
 const tableSchemaFactorySubScope = "table";
-/**
- * Gets the table containing the provided row/column node, if the node is part of a table.
- * @remarks Assumes that the table is the grandparent of the row/column node.
- */
-function getParentTable(rowOrColumnNode) {
-    const rowListNode = Tree.parent(rowOrColumnNode);
-    if (rowListNode === undefined || !isArrayNodeSchema(Tree.schema(rowListNode))) {
-        return undefined;
-    }
-    const tableNode = Tree.parent(rowListNode);
-    if (tableNode === undefined || !isTableNode(tableNode)) {
-        return undefined;
-    }
-    return tableNode;
-}
 /**
  * A private symbol put on table schema to help identify them.
  */
 const tableSchemaSymbol = Symbol("tableNode");
-/**
- * Type-guard to determine if a node is a table node.
- * @remarks Uses {@link tableSchemaSymbol} to identify table nodes.
- */
-function isTableNode(node) {
-    return tableSchemaSymbol in Tree.schema(node);
-}
 /**
  * Not intended for use outside of this package.
  *
@@ -59,7 +43,7 @@ export var System_TableSchema;
      * @system @alpha
      */
     // eslint-disable-next-line @typescript-eslint/explicit-function-return-type -- Return type is too complex to be reasonable to specify
-    function createColumnSchema(inputSchemaFactory, cellSchema, propsSchema) {
+    function createColumnSchema(inputSchemaFactory, propsSchema) {
         const schemaFactory = inputSchemaFactory.scopedFactory(tableSchemaFactorySubScope);
         // Note: `columnFields` is broken into two parts to work around a TypeScript bug
         // that results in broken `.d.ts` output.
@@ -92,23 +76,6 @@ export var System_TableSchema;
             // Will make it easier to evolve this schema in the future.
             allowUnknownOptionalFields: true,
         }) {
-            getCells() {
-                const tableNode = getParentTable(this);
-                if (tableNode === undefined) {
-                    throw new UsageError(`Column with ID "${this.id}" is not contained in a table.`);
-                }
-                const result = [];
-                for (const row of tableNode.rows) {
-                    const cell = row.getCell(this.id);
-                    if (cell !== undefined) {
-                        if (!Tree.is(cell, cellSchema)) {
-                            throw new UsageError("Parent table contains a cell with incompatible with this column.");
-                        }
-                        result.push({ rowId: row.id, cell });
-                    }
-                }
-                return result;
-            }
         }
         // Returning SingletonSchema without a type conversion results in TypeScript generating something like `readonly "__#124291@#brand": unknown;`
         // for the private brand field of TreeNode.
@@ -146,7 +113,7 @@ export var System_TableSchema;
             props: propsSchema,
         };
         /**
-         * {@link Row} fields.
+         * {@link RowSchema} fields.
          * @remarks Extracted for re-use in returned type signature defined later in this function.
          * The implicit typing is intentional.
          * Note: ideally we would add a satisfies clause here to ensure that this satisfies
@@ -160,57 +127,17 @@ export var System_TableSchema;
         /**
          * The Row schema - this is a map of Cells where the key is the column id
          */
-        class Row extends schemaFactory.object("Row", rowFields, {
+        class RowSchema extends schemaFactory.object("Row", rowFields, {
             // Will make it easier to evolve this schema in the future.
             allowUnknownOptionalFields: true,
         }) {
-            getCell(columnOrId) {
-                const columnId = typeof columnOrId === "string" ? columnOrId : columnOrId.id;
-                // Unlike most objects, RecordNodes don't have the default inherited object properties, so this is safe
-                return this.cells[columnId];
-            }
-            setCell(columnOrId, value) {
-                // TODO: throw if column does not exist in the owning table.
-                if (value === undefined) {
-                    this.removeCell(columnOrId);
-                }
-                else {
-                    const columnId = typeof columnOrId === "string" ? columnOrId : columnOrId.id;
-                    // TypeScript is unable to narrow the types correctly here, hence the casts.
-                    // See: https://github.com/microsoft/TypeScript/issues/52144
-                    this.cells[columnId] = TreeAlpha.create(cellSchema, value);
-                }
-            }
-            removeCell(columnOrId) {
-                // TODO: throw if column does not exist in the owning table.
-                const columnId = typeof columnOrId === "string" ? columnOrId : columnOrId.id;
-                const cell = this.getCell(columnId);
-                if (cell === undefined) {
-                    return undefined;
-                }
-                // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- The record's values are non-optional, so setting `undefined` as a means to remove the cell is not supported.
-                delete this.cells[columnId];
-                return cell;
-            }
-            getCells() {
-                const result = [];
-                for (const [columnId, cell] of Object.entries(this.cells)) {
-                    if (cell !== undefined) {
-                        result.push({
-                            columnId,
-                            cell,
-                        });
-                    }
-                }
-                return result;
-            }
         }
         // Returning SingletonSchema without a type conversion results in TypeScript generating something like `readonly "__#124291@#brand": unknown;`
         // for the private brand field of TreeNode.
         // This numeric id doesn't seem to be stable over incremental builds, and thus causes diffs in the API extractor reports.
         // This is avoided by doing this type conversion.
         // The conversion is done via assignment instead of `as` to get stronger type safety.
-        const RowSchemaType = Row;
+        const RowSchemaType = RowSchema;
         return RowSchemaType;
     }
     System_TableSchema.createRowSchema = createRowSchema;
@@ -220,6 +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_removeCells, _Table_applyEditsInBatch, _Table_tryGetColumn, _Table_getColumn, _Table_containsColumnWithId, _Table_tryGetRow, _Table_getRow;
         const schemaFactory = inputSchemaFactory.scopedFactory(tableSchemaFactorySubScope);
         /**
          * {@link Table} fields.
@@ -237,32 +165,32 @@ export var System_TableSchema;
             // Will make it easier to evolve this schema in the future.
             allowUnknownOptionalFields: true,
         }) {
+            constructor() {
+                super(...arguments);
+                _Table_instances.add(this);
+            }
             static empty() {
                 return new this({ columns: [], rows: [] });
             }
             getColumn(indexOrId) {
-                return this._tryGetColumn(indexOrId);
+                return __classPrivateFieldGet(this, _Table_instances, "m", _Table_tryGetColumn).call(this, indexOrId);
             }
             getRow(indexOrId) {
-                return this._tryGetRow(indexOrId);
+                return __classPrivateFieldGet(this, _Table_instances, "m", _Table_tryGetRow).call(this, indexOrId);
             }
             getCell(key) {
                 const { column: columnOrIdOrIndex, row: rowOrIdOrIndex } = key;
-                const row = this._tryGetRow(rowOrIdOrIndex);
+                const row = __classPrivateFieldGet(this, _Table_instances, "m", _Table_tryGetRow).call(this, rowOrIdOrIndex);
                 if (row === undefined) {
                     return undefined;
                 }
-                const column = this._tryGetColumn(columnOrIdOrIndex);
+                const column = __classPrivateFieldGet(this, _Table_instances, "m", _Table_tryGetColumn).call(this, columnOrIdOrIndex);
                 if (column === undefined) {
                     return undefined;
                 }
-                return row.getCell(column);
+                return row.cells[column.id];
             }
             insertColumns({ columns, index, }) {
-                // Ensure index is valid
-                if (index !== undefined) {
-                    Table.validateInsertionIndex(index, this.columns);
-                }
                 // TypeScript is unable to narrow the column type correctly here, hence the casts below.
                 // See: https://github.com/microsoft/TypeScript/issues/52144
                 if (index === undefined) {
@@ -270,6 +198,8 @@ export var System_TableSchema;
                     this.columns.insertAtEnd(TreeArrayNode.spread(columns));
                 }
                 else {
+                    // Ensure specified index is valid
+                    validateIndex(index, this.columns, "Table.insertColumns", true);
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     this.columns.insertAt(index, TreeArrayNode.spread(columns));
                 }
@@ -278,9 +208,9 @@ export var System_TableSchema;
             }
             insertRows({ index, rows, }) {
                 // #region Input validation
-                // Ensure index is valid
+                // Ensure specified index is valid
                 if (index !== undefined) {
-                    Table.validateInsertionIndex(index, this.rows);
+                    validateIndex(index, this.rows, "Table.insertRows", true);
                 }
                 // Note: TypeScript is unable to narrow the type of the row type correctly here, hence the casts below.
                 // See: https://github.com/microsoft/TypeScript/issues/52144
@@ -292,7 +222,7 @@ export var System_TableSchema;
                         // eslint-disable-next-line @typescript-eslint/no-explicit-any
                         const keys = Object.keys(newRow.cells);
                         for (const key of keys) {
-                            if (!this._containsColumnWithId(key)) {
+                            if (!__classPrivateFieldGet(this, _Table_instances, "m", _Table_containsColumnWithId).call(this, key)) {
                                 throw new UsageError(`Attempted to insert row a cell under column ID "${key}", but the table does not contain a column with that ID.`);
                             }
                         }
@@ -314,31 +244,28 @@ export var System_TableSchema;
             }
             setCell({ key, cell, }) {
                 const { column: columnOrId, row: rowOrId } = key;
-                const row = this._getRow(rowOrId);
-                const column = this._getColumn(columnOrId);
-                row.setCell(column, cell);
+                const row = __classPrivateFieldGet(this, _Table_instances, "m", _Table_getRow).call(this, rowOrId);
+                const column = __classPrivateFieldGet(this, _Table_instances, "m", _Table_getColumn).call(this, columnOrId);
+                row.cells[column.id] = cell;
             }
             removeColumns(indexOrColumns, count = undefined) {
                 if (typeof indexOrColumns === "number" || indexOrColumns === undefined) {
                     let removedColumns;
                     const startIndex = indexOrColumns ?? 0;
-                    const _count = count ?? this.columns.length - startIndex;
+                    const endIndex = count === undefined ? this.columns.length : startIndex + count;
                     // If there are no columns to remove, do nothing
-                    if (_count === 0) {
+                    if (startIndex === endIndex) {
                         return [];
                     }
-                    Table._assertValidRange({ index: startIndex, count: _count }, this.columns);
-                    this._applyEditsInBatch(() => {
-                        const columnsToRemove = this.columns.slice(startIndex, startIndex + _count);
+                    validateIndexRange(startIndex, endIndex, this.columns, "Table.removeColumns");
+                    __classPrivateFieldGet(this, _Table_instances, "m", _Table_applyEditsInBatch).call(this, () => {
+                        const columnsToRemove = this.columns.slice(startIndex, endIndex);
                         // First, remove all cells that correspond to each column from each row:
                         for (const column of columnsToRemove) {
-                            this._removeCells(column);
+                            __classPrivateFieldGet(this, _Table_instances, "m", _Table_removeCells).call(this, column);
                         }
                         // Second, remove the column nodes:
-                        Table._removeRange({
-                            index: startIndex,
-                            count: _count,
-                        }, this.columns);
+                        removeRangeFromArray(startIndex, endIndex, this.columns, "Table.removeColumns");
                         removedColumns = columnsToRemove;
                     });
                     return removedColumns ?? fail(0xc1f /* Transaction did not complete. */);
@@ -353,9 +280,9 @@ export var System_TableSchema;
                     // This improves user-facing error experience.
                     const columnsToRemove = [];
                     for (const columnOrIdToRemove of indexOrColumns) {
-                        columnsToRemove.push(this._getColumn(columnOrIdToRemove));
+                        columnsToRemove.push(__classPrivateFieldGet(this, _Table_instances, "m", _Table_getColumn).call(this, columnOrIdToRemove));
                     }
-                    this._applyEditsInBatch(() => {
+                    __classPrivateFieldGet(this, _Table_instances, "m", _Table_applyEditsInBatch).call(this, () => {
                         // 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) {
@@ -363,7 +290,10 @@ export var System_TableSchema;
                             for (const row of this.rows) {
                                 // TypeScript is unable to narrow the row type correctly here, hence the cast.
                                 // See: https://github.com/microsoft/TypeScript/issues/52144
-                                row.removeCell(columnToRemove);
+                                this.removeCell({
+                                    column: columnToRemove,
+                                    row: row,
+                                });
                             }
                             // We have already validated that all of the columns exist above, so this is safe.
                             this.columns.removeAt(this.columns.indexOf(columnToRemove));
@@ -375,15 +305,12 @@ export var System_TableSchema;
             removeRows(indexOrRows, count) {
                 if (typeof indexOrRows === "number" || indexOrRows === undefined) {
                     const startIndex = indexOrRows ?? 0;
-                    const _count = count ?? this.columns.length - startIndex;
+                    const endIndex = count === undefined ? this.columns.length : startIndex + count;
                     // If there are no rows to remove, do nothing
-                    if (_count === 0) {
+                    if (startIndex === endIndex) {
                         return [];
                     }
-                    return Table._removeRange({
-                        index: startIndex,
-                        count: _count,
-                    }, this.rows);
+                    return removeRangeFromArray(startIndex, endIndex, this.rows, "Table.removeRows");
                 }
                 // If there are no rows to remove, do nothing
                 if (indexOrRows.length === 0) {
@@ -394,9 +321,9 @@ export var System_TableSchema;
                 // This improves user-facing error experience.
                 const rowsToRemove = [];
                 for (const rowToRemove of indexOrRows) {
-                    rowsToRemove.push(this._getRow(rowToRemove));
+                    rowsToRemove.push(__classPrivateFieldGet(this, _Table_instances, "m", _Table_getRow).call(this, rowToRemove));
                 }
-                this._applyEditsInBatch(() => {
+                __classPrivateFieldGet(this, _Table_instances, "m", _Table_applyEditsInBatch).call(this, () => {
                     // 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) {
@@ -409,110 +336,16 @@ export var System_TableSchema;
             }
             removeCell(key) {
                 const { column: columnOrIdOrIndex, row: rowOrIdOrIndex } = key;
-                const row = this._getRow(rowOrIdOrIndex);
-                const column = this._getColumn(columnOrIdOrIndex);
-                const cell = row.getCell(column.id);
+                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];
                 if (cell === undefined) {
                     return undefined;
                 }
-                row.removeCell(column.id);
+                // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+                delete row.cells[column.id];
                 return cell;
             }
-            /**
-             * Removes the cell corresponding with the specified column from each row in the table.
-             */
-            _removeCells(column) {
-                for (const row of this.rows) {
-                    // TypeScript is unable to narrow the row type correctly here, hence the cast.
-                    // See: https://github.com/microsoft/TypeScript/issues/52144
-                    row.removeCell(column);
-                }
-            }
-            static _assertValidRange(range, array) {
-                const { index, count } = range;
-                if (index < 0 || index >= array.length) {
-                    throw new UsageError(`Start index out of bounds. Expected index to be on [0, ${array.length - 1}], but got ${index}.`);
-                }
-                if (count < 0) {
-                    throw new UsageError(`Expected non-negative count. Got ${count}.`);
-                }
-                const end = index + count; // exclusive
-                if (end > array.length) {
-                    throw new UsageError(`End index out of bounds. Expected end to be on [${index}, ${array.length}], but got ${end}.`);
-                }
-            }
-            /**
-             * Applies the provided edits in a "batch".
-             *
-             * @remarks
-             * For hydrated trees, this will be done in a transaction to ensure atomicity.
-             *
-             * Transactions are not supported for unhydrated trees, so we cannot run a transaction in that case.
-             * But since there are no collaborators, this is not an issue.
-             */
-            _applyEditsInBatch(applyEdits) {
-                const branch = TreeAlpha.branch(this);
-                // Ensure events are paused until all of the edits are applied.
-                // This ensures that the user sees the corresponding table-level edit as atomic,
-                // and ensures they are not spammed with intermediate events.
-                withBufferedTreeEvents(() => {
-                    if (branch === undefined) {
-                        // If this node does not have a corresponding branch, then it is unhydrated.
-                        // I.e., it is not part of a collaborative session yet.
-                        // Therefore, we don't need to run the edits as a transaction.
-                        applyEdits();
-                    }
-                    else {
-                        branch.runTransaction(() => {
-                            applyEdits();
-                        });
-                    }
-                });
-            }
-            /**
-             * Attempts to resolve the provided Column node or ID to a Column node in the table.
-             * Returns `undefined` if there is no match.
-             * @remarks Searches for a match based strictly on the ID and returns that result.
-             */
-            _tryGetColumn(columnOrIdOrIndex) {
-                if (typeof columnOrIdOrIndex === "number") {
-                    if (columnOrIdOrIndex < 0 || columnOrIdOrIndex >= this.columns.length) {
-                        return undefined;
-                    }
-                    // TypeScript is unable to narrow the types correctly here, hence the cast.
-                    // See: https://github.com/microsoft/TypeScript/issues/52144
-                    return this.columns[columnOrIdOrIndex];
-                }
-                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.columns.find((col) => col.id === columnId);
-                }
-                // If the user provided a node, ensure it actually exists in this table.
-                if (!this.columns.includes(columnOrIdOrIndex)) {
-                    return undefined;
-                }
-                return columnOrIdOrIndex;
-            }
-            /**
-             * Attempts to resolve the provided Column node or ID to a Column node in the table.
-             * @throws Throws a `UsageError` if there is no match.
-             * @remarks Searches for a match based strictly on the ID and returns that result.
-             */
-            _getColumn(columnOrIdOrIndex) {
-                const column = this._tryGetColumn(columnOrIdOrIndex);
-                if (column === undefined) {
-                    Table._throwMissingColumnError(columnOrIdOrIndex);
-                }
-                return column;
-            }
-            /**
-             * Checks if a Column with the specified ID exists in the table.
-             */
-            _containsColumnWithId(columnId) {
-                return this._tryGetColumn(columnId) !== undefined;
-            }
             /**
              * Throw a `UsageError` for a missing Column by its ID or index.
              */
@@ -525,44 +358,6 @@ export var System_TableSchema;
                 }
                 throw new UsageError(`The specified column node with ID "${columnOrIdOrIndex.id}" does not exist in the table.`);
             }
-            /**
-             * Attempts to resolve the provided Row node or ID to a Row node in the table.
-             * Returns `undefined` if there is no match.
-             * @remarks Searches for a match based strictly on the ID and returns that result.
-             */
-            _tryGetRow(rowOrIdOrIndex) {
-                if (typeof rowOrIdOrIndex === "number") {
-                    if (rowOrIdOrIndex < 0 || rowOrIdOrIndex >= this.rows.length) {
-                        return undefined;
-                    }
-                    // TypeScript is unable to narrow the types correctly here, hence the cast.
-                    // See: https://github.com/microsoft/TypeScript/issues/52144
-                    return this.rows[rowOrIdOrIndex];
-                }
-                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.rows.find((row) => row.id === rowId);
-                }
-                // If the user provided a node, ensure it actually exists in this table.
-                if (!this.rows.includes(rowOrIdOrIndex)) {
-                    return undefined;
-                }
-                return rowOrIdOrIndex;
-            }
-            /**
-             * Attempts to resolve the provided Row node, ID, or index to a Row node in the table.
-             * @throws Throws a `UsageError` if there is no match.
-             * @remarks Searches for a match based strictly on the ID and returns that result.
-             */
-            _getRow(rowOrIdOrIndex) {
-                const row = this._tryGetRow(rowOrIdOrIndex);
-                if (row === undefined) {
-                    Table._throwMissingRowError(rowOrIdOrIndex);
-                }
-                return row;
-            }
             /**
              * Throw a `UsageError` for a missing Row by its ID or index.
              */
@@ -575,32 +370,89 @@ export var System_TableSchema;
                 }
                 throw new UsageError(`The specified row node with ID "${rowOrIdOrIndex.id}" does not exist in the table.`);
             }
-            static _removeRange(range, array) {
-                Table._assertValidRange(range, array);
-                const { index, count } = range;
-                const end = index + count; // exclusive
-                // TypeScript is unable to narrow the array element type correctly here, hence the cast.
+        }
+        _a = Table, _Table_instances = new WeakSet(), _Table_removeCells = function _Table_removeCells(column) {
+            for (const row of this.rows) {
+                // TypeScript is unable to narrow the row type correctly here, hence the cast.
                 // See: https://github.com/microsoft/TypeScript/issues/52144
-                const removedRows = array.slice(index, end);
-                array.removeRange(index, end);
-                return removedRows;
+                this.removeCell({
+                    column,
+                    row: row,
+                });
             }
-            /**
-             * Ensure that the specified index is a valid location for item insertion in the destination list.
-             * @throws Throws a usage error if the destination is invalid.
-             */
-            static validateInsertionIndex(index, destinationList) {
-                if (index < 0) {
-                    throw new UsageError("The index must be greater than or equal to 0.");
+        }, _Table_applyEditsInBatch = function _Table_applyEditsInBatch(applyEdits) {
+            const branch = TreeAlpha.branch(this);
+            // Ensure events are paused until all of the edits are applied.
+            // This ensures that the user sees the corresponding table-level edit as atomic,
+            // and ensures they are not spammed with intermediate events.
+            withBufferedTreeEvents(() => {
+                if (branch === undefined) {
+                    // If this node does not have a corresponding branch, then it is unhydrated.
+                    // I.e., it is not part of a collaborative session yet.
+                    // Therefore, we don't need to run the edits as a transaction.
+                    applyEdits();
                 }
-                if (index > destinationList.length) {
-                    throw new UsageError("The index specified for insertion is out of bounds.");
+                else {
+                    branch.runTransaction(() => {
+                        applyEdits();
+                    });
                 }
-                if (!Number.isInteger(index)) {
-                    throw new UsageError("The index must be an integer.");
+            });
+        }, _Table_tryGetColumn = function _Table_tryGetColumn(columnOrIdOrIndex) {
+            if (typeof columnOrIdOrIndex === "number") {
+                if (columnOrIdOrIndex < 0 || columnOrIdOrIndex >= this.columns.length) {
+                    return undefined;
                 }
+                // TypeScript is unable to narrow the types correctly here, hence the cast.
+                // See: https://github.com/microsoft/TypeScript/issues/52144
+                return this.columns[columnOrIdOrIndex];
             }
-        }
+            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.columns.find((col) => col.id === columnId);
+            }
+            // If the user provided a node, ensure it actually exists in this table.
+            if (!this.columns.includes(columnOrIdOrIndex)) {
+                return undefined;
+            }
+            return columnOrIdOrIndex;
+        }, _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_containsColumnWithId = function _Table_containsColumnWithId(columnId) {
+            return __classPrivateFieldGet(this, _Table_instances, "m", _Table_tryGetColumn).call(this, columnId) !== undefined;
+        }, _Table_tryGetRow = function _Table_tryGetRow(rowOrIdOrIndex) {
+            if (typeof rowOrIdOrIndex === "number") {
+                if (rowOrIdOrIndex < 0 || rowOrIdOrIndex >= this.rows.length) {
+                    return undefined;
+                }
+                // TypeScript is unable to narrow the types correctly here, hence the cast.
+                // See: https://github.com/microsoft/TypeScript/issues/52144
+                return this.rows[rowOrIdOrIndex];
+            }
+            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.rows.find((row) => row.id === rowId);
+            }
+            // If the user provided a node, ensure it actually exists in this table.
+            if (!this.rows.includes(rowOrIdOrIndex)) {
+                return undefined;
+            }
+            return rowOrIdOrIndex;
+        }, _Table_getRow = function _Table_getRow(rowOrIdOrIndex) {
+            const row = __classPrivateFieldGet(this, _Table_instances, "m", _Table_tryGetRow).call(this, rowOrIdOrIndex);
+            if (row === undefined) {
+                _a._throwMissingRowError(rowOrIdOrIndex);
+            }
+            return row;
+        };
         // Set a private symbol on the schema class that marks it as having been generated by this factory.
         // Column / Row functionality use this to validate that they are being used in a table.
         // This is effectively a work-around that allows columns and rows to invoke table methods
@@ -619,6 +471,18 @@ export var System_TableSchema;
     System_TableSchema.createTableSchema = createTableSchema;
     // #endregion
 })(System_TableSchema || (System_TableSchema = {}));
+/**
+ * Removes the specified range of elements from the array.
+ * @returns The removed elements.
+ */
+function removeRangeFromArray(startIndex, endIndex, array, methodName) {
+    validateIndexRange(startIndex, endIndex, array, methodName);
+    // TypeScript is unable to narrow the array element type correctly here, hence the cast.
+    // See: https://github.com/microsoft/TypeScript/issues/52144
+    const removedRows = array.slice(startIndex, endIndex);
+    array.removeRange(startIndex, endIndex);
+    return removedRows;
+}
 /**
  * Contains types and factories for creating schema to represent dynamic tabular data.
  *
@@ -740,7 +604,7 @@ export var TableSchema;
      * Overload implementation
      */
     function column({ schemaFactory, cell, props = SchemaFactory.optional(SchemaFactory.null), }) {
-        return System_TableSchema.createColumnSchema(schemaFactory, cell, props);
+        return System_TableSchema.createColumnSchema(schemaFactory, props);
     }
     TableSchema.column = column;
     /**