@fluidframework/tree 2.33.2 → 2.40.0

package/lib/tableSchema.js

@@ -3,49 +3,69 @@
  * Licensed under the MIT License.
  */
 import { oob } from "@fluidframework/core-utils/internal";
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { Tree } from "./shared-tree/index.js";
-import { TreeArrayNode, } from "./simple-tree/index.js";
-// Future improvement TODOs (ideally to be done before promoting these APIs to `@alpha`):
-// - Custom fields on Table/Row/Column (props pattern from Nick's demo)
-// - Overloads to make Column/Row schema optional when constructing Tables
+import { TreeArrayNode, SchemaFactory, } from "./simple-tree/index.js";
+// Future improvement TODOs:
+// - Omit `cells` property from Row insertion type.
 // - Record-like type parameters / input parameters?
-// - Move `@system` types into separate / sub scope?
+// - Omit `props` properties from Row and Column schemas when not provided?
+// Longer-term work:
+// - Add constraint APIs to make it possible to avoid situations that could yield "orphaned" cells.
 /**
- * Contains types and factories for creating schema to represent dynamic tabular data.
- * @privateRemarks TODO: document in more detail and add `@example`s.
- * @internal
+ * The sub-scope applied to user-provided {@link SchemaFactory}s by table schema factories.
  */
-export var TableSchema;
-(function (TableSchema) {
-    const tableSchemaFactorySubScope = "table";
+const tableSchemaFactorySubScope = "table";
+/**
+ * Not intended for use outside of this package.
+ *
+ * @privateRemarks
+ * This namespace is a collection of internal system types relate to {@link TableSchema}.
+ * This namespace should be strictly type-exported by the package.
+ * All members should be tagged with `@system`.
+ *
+ * @system @internal
+ */
+export var System_TableSchema;
+(function (System_TableSchema) {
     /**
      * Factory for creating new table column schema.
-     * @privateRemarks
-     * TODO:
-     * - Add overloads to make propsSchema optional.
-     * - Take field schema rather than node schema for `propsSchema`, in particular to allow making
-     * the additional properties optional.
-     * @internal
+     * @system @internal
      */
     // eslint-disable-next-line @typescript-eslint/explicit-function-return-type -- Return type is too complex to be reasonable to specify
-    function createColumn(inputSchemaFactory, propsSchema) {
+    function createColumnInternal(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.
+        // See definition of `ColumnInsertableType` below.
+        const columnFieldsBuiltInParts = {
+            id: schemaFactory.identifier,
+        };
+        const columnFieldsPropsPart = {
+            props: propsSchema,
+        };
         /**
          * {@link Column} fields.
-         * @remarks Extracted for re-use in returned type signature defined later in this function.
+         *
+         * @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
          * `Record<string, ImplicitFieldSchema>`, but doing so causes TypeScript to prematurely and incorrectly evaluate the type of `propsSchema`.
          * Likely related to the following issue: https://github.com/microsoft/TypeScript/issues/52394
          */
         const columnFields = {
-            id: schemaFactory.identifier,
-            props: schemaFactory.required(propsSchema),
-        };
+            ...columnFieldsBuiltInParts,
+            ...columnFieldsPropsPart,
+        }; // satisfies Record<string, ImplicitFieldSchema>;
         /**
          * A column in a table.
          */
-        class Column extends schemaFactory.object("Column", columnFields) {
+        class Column extends schemaFactory.objectAlpha("Column", columnFields, {
+            // Will make it easier to evolve this schema in the future.
+            allowUnknownOptionalFields: true,
+        }) {
         }
         // Returning SingletonSchema without a type conversion results in TypeScript generating something like `readonly "__#124291@#brand": unknown;`
         // for the private brand field of TreeNode.
@@ -55,21 +75,29 @@ export var TableSchema;
         const ColumnSchemaType = Column;
         return ColumnSchemaType;
     }
-    TableSchema.createColumn = createColumn;
+    System_TableSchema.createColumnInternal = createColumnInternal;
     /**
      * Factory for creating new table row schema.
      *
-     * @privateRemarks
-     * TODO:
-     * - Add overloads to make propsSchema optional.
-     * - Take field schema rather than node schema for `propsSchema`, in particular to allow making
-     * the additional properties optional.
-     *
      * @sealed @internal
      */
     // eslint-disable-next-line @typescript-eslint/explicit-function-return-type -- Return type is too complex to be reasonable to specify
-    function createRow(inputSchemaFactory, cellSchema, propsSchema) {
+    function createRowInternal(inputSchemaFactory, cellSchema, propsSchema) {
         const schemaFactory = inputSchemaFactory.scopedFactory(tableSchemaFactorySubScope);
+        // Note: `rowFields` is broken into two parts to work around a TypeScript bug
+        // that results in broken `.d.ts` output.
+        // See definition of `RowInsertableType` below.
+        const rowFieldsBuiltInParts = {
+            id: schemaFactory.identifier,
+            cells: schemaFactory.required(schemaFactory.map("Row.cells", cellSchema), {
+                metadata: {
+                    description: "The cells of the table row, keyed by column ID.",
+                },
+            }),
+        };
+        const rowFieldsPropsPart = {
+            props: propsSchema,
+        };
         /**
          * {@link Row} fields.
          * @remarks Extracted for re-use in returned type signature defined later in this function.
@@ -79,28 +107,34 @@ export var TableSchema;
          * Likely related to the following issue: https://github.com/microsoft/TypeScript/issues/52394
          */
         const rowFields = {
-            id: schemaFactory.identifier,
-            cells: schemaFactory.map("Row.cells", cellSchema),
-            props: schemaFactory.required(propsSchema),
-        };
+            ...rowFieldsBuiltInParts,
+            ...rowFieldsPropsPart,
+        }; // satisfies Record<string, ImplicitFieldSchema>;
         /**
          * The Row schema - this is a map of Cells where the key is the column id
          */
-        class Row extends schemaFactory.object("Row", rowFields) {
+        class Row extends schemaFactory.objectAlpha("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;
                 return this.cells.get(columnId);
             }
             setCell(columnOrId, value) {
+                // TODO: throw if column does not exist in the owning table.
                 const columnId = typeof columnOrId === "string" ? columnOrId : columnOrId.id;
                 this.cells.set(columnId, value);
             }
             removeCell(columnOrId) {
+                // TODO: throw if column does not exist in the owning table.
                 const columnId = typeof columnOrId === "string" ? columnOrId : columnOrId.id;
-                if (!this.cells.has(columnId)) {
-                    return;
+                const cell = this.cells.get(columnId);
+                if (cell === undefined) {
+                    return undefined;
                 }
                 this.cells.delete(columnId);
+                return cell;
             }
         }
         // Returning SingletonSchema without a type conversion results in TypeScript generating something like `readonly "__#124291@#brand": unknown;`
@@ -111,14 +145,7 @@ export var TableSchema;
         const RowSchemaType = Row;
         return RowSchemaType;
     }
-    TableSchema.createRow = createRow;
-    /** `createTable` implementation */
-    function createTable(inputSchemaFactory, _cellSchema, columnSchema, rowSchema) {
-        const column = columnSchema ?? createColumn(inputSchemaFactory, inputSchemaFactory.null);
-        return createTableInternal(inputSchemaFactory, _cellSchema, column, rowSchema ??
-            createRow(inputSchemaFactory, _cellSchema, inputSchemaFactory.null));
-    }
-    TableSchema.createTable = createTable;
+    System_TableSchema.createRowInternal = createRowInternal;
     /**
      * Factory for creating new table schema.
      * @system @internal
@@ -138,7 +165,10 @@ export var TableSchema;
         /**
          * The Table schema
          */
-        class Table extends schemaFactory.object("Table", tableFields) {
+        class Table extends schemaFactory.objectAlpha("Table", tableFields, {
+            // Will make it easier to evolve this schema in the future.
+            allowUnknownOptionalFields: true,
+        }) {
             getColumn(id) {
                 // TypeScript is unable to narrow the types correctly here, hence the casts.
                 // See: https://github.com/microsoft/TypeScript/issues/52144
@@ -150,98 +180,245 @@ export var TableSchema;
                 return this.rows.find((_row) => _row.id === id);
             }
             getCell(key) {
-                const { columnId, rowId } = key;
-                const row = this.getRow(rowId);
-                if (row !== undefined) {
-                    const column = this.getColumn(columnId);
-                    if (column !== undefined) {
-                        return row.getCell(column.id);
-                    }
+                const { column: columnOrId, row: rowOrId } = key;
+                const row = this._getRow(rowOrId);
+                if (row === undefined) {
+                    return undefined;
                 }
-                // If the cell does not exist return undefined
-                return undefined;
+                const column = this._getColumn(columnOrId);
+                if (column === undefined) {
+                    return undefined;
+                }
+                return row.getCell(column);
             }
             insertColumn({ column, index, }) {
-                if (index === undefined) {
-                    // TypeScript is unable to narrow the types correctly here, hence the cast.
+                const inserted = this.insertColumns({
+                    columns: [column],
+                    index,
+                });
+                return inserted[0] ?? oob();
+            }
+            insertColumns({ columns, index, }) {
+                // #region Input validation
+                // Ensure index is valid
+                if (index !== undefined) {
+                    Table.validateInsertionIndex(index, this.columns);
+                }
+                // Check all of the columns being inserted an ensure the table does not already contain any with the same ID.
+                for (const column of columns) {
+                    // TypeScript is unable to narrow the type of the column type correctly here, hence the casts below.
                     // See: https://github.com/microsoft/TypeScript/issues/52144
+                    const maybeId = column.id;
+                    if (maybeId !== undefined && this.containsColumnWithId(maybeId)) {
+                        throw new UsageError(`A column with ID "${column.id}" already exists in the table.`);
+                    }
+                }
+                // #endregion
+                // 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) {
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    this.columns.insertAtEnd(column);
+                    this.columns.insertAtEnd(TreeArrayNode.spread(columns));
                 }
                 else {
-                    // TypeScript is unable to narrow the types correctly here, hence the cast.
-                    // See: https://github.com/microsoft/TypeScript/issues/52144
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    this.columns.insertAt(index, column);
+                    this.columns.insertAt(index, TreeArrayNode.spread(columns));
                 }
-                // Inserting the input node into the tree hydrates it, making it usable as a node.
-                return column;
+                // Inserting the input nodes into the tree hydrates them, making them usable as nodes.
+                return columns;
+            }
+            insertRow({ row, index, }) {
+                const inserted = this.insertRows({
+                    rows: [row],
+                    index,
+                });
+                return inserted[0] ?? oob();
             }
             insertRows({ index, rows, }) {
+                // #region Input validation
+                // Ensure index is valid
+                if (index !== undefined) {
+                    Table.validateInsertionIndex(index, this.rows);
+                }
+                // 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
+                for (const newRow of rows) {
+                    // Check all of the rows being inserted an ensure the table does not already contain any with the same ID.
+                    const maybeId = newRow.id;
+                    if (maybeId !== undefined && this.containsRowWithId(maybeId)) {
+                        throw new UsageError(`A row with ID "${newRow.id}" already exists in the table.`);
+                    }
+                    // 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
+                    if (newRow.cells !== undefined) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        const keys = Object.keys(newRow.cells);
+                        for (const key of keys) {
+                            if (!this.containsColumnWithId(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.`);
+                            }
+                        }
+                    }
+                }
+                // #endregion
+                // TypeScript is unable to narrow the row type correctly here, hence the casts below.
+                // See: https://github.com/microsoft/TypeScript/issues/52144
                 if (index === undefined) {
-                    // TypeScript is unable to narrow the types correctly here, hence the cast.
-                    // See: https://github.com/microsoft/TypeScript/issues/52144
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     this.rows.insertAtEnd(TreeArrayNode.spread(rows));
                 }
                 else {
-                    // TypeScript is unable to narrow the types correctly here, hence the cast.
-                    // See: https://github.com/microsoft/TypeScript/issues/52144
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     this.rows.insertAt(index, TreeArrayNode.spread(rows));
                 }
                 // Inserting the input nodes into the tree hydrates them, making them usable as nodes.
                 return rows;
             }
-            setCell({ key, cell }) {
-                const { columnId, rowId } = key;
-                const row = this.getRow(rowId);
-                if (row !== undefined) {
-                    const column = this.getColumn(columnId);
-                    if (column !== undefined) {
-                        row.setCell(column.id, cell);
-                    }
+            setCell({ key, cell, }) {
+                const { column: columnOrId, row: rowOrId } = key;
+                const row = this._getRow(rowOrId);
+                if (row === undefined) {
+                    const rowId = this._getRowId(rowOrId);
+                    throw new UsageError(`No row with ID "${rowId}" exists in the table.`);
                 }
+                const column = this._getColumn(columnOrId);
+                if (column === undefined) {
+                    const columnId = this._getColumnId(columnOrId);
+                    throw new UsageError(`No column with ID "${columnId}" exists in the table.`);
+                }
+                row.setCell(column, cell);
+            }
+            removeColumns(columns) {
+                // If there are no columns to remove, do nothing
+                if (columns.length === 0) {
+                    return [];
+                }
+                // If there is only one column to remove, remove it (and don't incur cost of transaction)
+                if (columns.length === 1) {
+                    const removedColumn = this.removeColumn(columns[0] ?? oob());
+                    return [removedColumn];
+                }
+                // If there are multiple columns to remove, remove them in a transaction.
+                const removedColumns = [];
+                Tree.runTransaction(this, () => {
+                    // Note, throwing an error within a transaction will abort the entire transaction.
+                    // So if we throw an error here for any row, no columns will be removed.
+                    for (const columnToRemove of columns) {
+                        const removedRow = this.removeColumn(columnToRemove);
+                        removedColumns.push(removedRow);
+                    }
+                });
+                return removedColumns;
             }
-            removeColumn(column) {
-                const index = this.columns.indexOf(column);
-                // If the column is not in the table, do nothing
-                if (index === -1)
-                    return;
+            removeColumn(columnOrId) {
+                const column = this._getColumn(columnOrId);
+                const index = column === undefined ? -1 : this.columns.indexOf(column);
+                if (index === -1) {
+                    const columnId = this._getColumnId(columnOrId);
+                    throw new UsageError(`Specified column with ID "${columnId}" does not exist in the table.`);
+                }
                 this.columns.removeAt(index);
+                return column;
+            }
+            removeAllColumns() {
+                // TypeScript is unable to narrow the row type correctly here, hence the cast.
+                // See: https://github.com/microsoft/TypeScript/issues/52144
+                return this.removeColumns(this.columns);
             }
             removeRows(rows) {
                 // If there are no rows to remove, do nothing
                 if (rows.length === 0) {
-                    return;
+                    return [];
                 }
-                // If there is only one row to remove, remove it
+                // If there is only one row to remove, remove it (and don't incur cost of transaction)
                 if (rows.length === 1) {
-                    const index = this.rows.indexOf(rows[0] ?? oob());
-                    this.rows.removeAt(index);
-                    return;
+                    const removedRow = this.removeRow(rows[0] ?? oob());
+                    return [removedRow];
                 }
-                // If there are multiple rows to remove, remove them in a transaction
-                // This is to avoid the performance issues of deleting multiple rows at once
+                // If there are multiple rows to remove, remove them in a transaction.
+                const removedRows = [];
                 Tree.runTransaction(this, () => {
-                    // Iterate over the rows and remove them
-                    for (const row of rows) {
-                        const index = this.rows.indexOf(row);
-                        this.rows.removeAt(index);
+                    // 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 rows) {
+                        const removedRow = this.removeRow(rowToRemove);
+                        removedRows.push(removedRow);
                     }
                 });
+                return removedRows;
+            }
+            removeRow(rowOrId) {
+                const rowToRemove = this._getRow(rowOrId);
+                const index = rowToRemove === undefined ? -1 : this.rows.indexOf(rowToRemove);
+                // If the row does not exist in the table, throw an error.
+                if (index === -1) {
+                    const rowId = this._getRowId(rowOrId);
+                    throw new UsageError(`Specified row with ID "${rowId}" does not exist in the table.`);
+                }
+                this.rows.removeAt(index);
+                return rowToRemove;
             }
             removeAllRows() {
-                this.rows.removeRange();
+                // TypeScript is unable to narrow the row type correctly here, hence the cast.
+                // See: https://github.com/microsoft/TypeScript/issues/52144
+                return this.removeRows(this.rows);
             }
             removeCell(key) {
-                const { columnId, rowId } = key;
-                const row = this.getRow(rowId);
-                if (row !== undefined) {
-                    const column = this.getColumn(columnId);
-                    if (column !== undefined) {
-                        row.removeCell(column.id);
-                    }
+                const { column: columnOrId, row: rowOrId } = key;
+                const row = this._getRow(rowOrId);
+                if (row === undefined) {
+                    const rowId = this._getRowId(rowOrId);
+                    throw new UsageError(`Specified row with ID "${rowId}" does not exist in the table.`);
+                }
+                const column = this._getColumn(columnOrId);
+                if (column === undefined) {
+                    const columnId = this._getColumnId(columnOrId);
+                    throw new UsageError(`Specified column with ID "${columnId}" does not exist in the table.`);
+                }
+                const cell = row.getCell(column.id);
+                if (cell === undefined) {
+                    return undefined;
+                }
+                row.removeCell(column.id);
+                return cell;
+            }
+            _getColumn(columnOrId) {
+                return typeof columnOrId === "string" ? this.getColumn(columnOrId) : columnOrId;
+            }
+            _getColumnId(columnOrId) {
+                return typeof columnOrId === "string" ? columnOrId : columnOrId.id;
+            }
+            _getRow(rowOrId) {
+                return typeof rowOrId === "string" ? this.getRow(rowOrId) : rowOrId;
+            }
+            _getRowId(rowOrId) {
+                return typeof rowOrId === "string" ? rowOrId : rowOrId.id;
+            }
+            containsColumnWithId(columnId) {
+                // TypeScript is unable to narrow the types correctly here, hence the cast.
+                // See: https://github.com/microsoft/TypeScript/issues/52144
+                return (this.columns.find((column) => column.id === columnId) !==
+                    undefined);
+            }
+            containsRowWithId(rowId) {
+                // TypeScript is unable to narrow the types correctly here, hence the cast.
+                // See: https://github.com/microsoft/TypeScript/issues/52144
+                return this.rows.find((row) => row.id === rowId) !== undefined;
+            }
+            /**
+             * 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.");
+                }
+                if (index > destinationList.length) {
+                    throw new UsageError("The index specified for insertion is out of bounds.");
+                }
+                if (!Number.isInteger(index)) {
+                    throw new UsageError("The index must be an integer.");
                 }
             }
         }
@@ -254,7 +431,127 @@ export var TableSchema;
         // Return the table schema
         return TableSchemaType;
     }
-    TableSchema.createTableInternal = createTableInternal;
+    System_TableSchema.createTableInternal = createTableInternal;
+    // #endregion
+})(System_TableSchema || (System_TableSchema = {}));
+/**
+ * Contains types and factories for creating schema to represent dynamic tabular data.
+ *
+ * @remarks
+ *
+ * Tables created using these APIs are...
+ *
+ * - sparse, meaning that cells may be omitted, and new rows are empty by default.
+ *
+ * - dynamic, meaning that their structure can be modified at runtime.
+ * Columns and rows can be inserted, removed, modified, and reordered.
+ * Cells can be inserted, removed, and modified.
+ *
+ * - row-major, meaning that operating on rows (including inserts, removal, moves, and traversal) is more efficient than operating on columns.
+ *
+ * Column and Row schema created using these APIs are extensible via the `props` field.
+ * This allows association of additional properties with column and row nodes.
+ *
+ * Note: for now it is possible for table cells to become "orphaned".
+ * That is, it is possible to enter a state where one or more rows contain cells with no corresponding column.
+ * To help avoid this situation, you can manually remove corresponding cells when removing columns.
+ * Either way, it is possible to enter such a state via the merging of edits.
+ * For example: one client might add a row while another concurrently removes a column, orphaning the cell where the column and row intersected.
+ *
+ * @example Using default Column and Row schema
+ *
+ * ```typescript
+ * class Cell extends schemaFactory.object("TableCell", {
+ * 	value: schemaFactory.string,
+ * }) {}
+ *
+ * class Table extends TableSchema.createTable({
+ * 	schemaFactory,
+ * 	cell: Cell,
+ * }) {}
+ *
+ * const table = new Table({
+ * 	columns: [{ id: "column-0" }],
+ * 	rows: [{ id: "row-0", cells: {} }],
+ * });
+ * ```
+ *
+ * @example Customizing Column and Row schema
+ *
+ * ```typescript
+ * class Cell extends schemaFactory.object("TableCell", {
+ * 	value: schemaFactory.string,
+ * }) {}
+ *
+ * class ColumnProps extends schemaFactory.object("TableColumnProps", {
+ * 	// Column label to display.
+ * 	label: schemaFactory.string,
+ * 	// The type of data represented by the cells. Default: string.
+ * 	dataType: schemaFactory.optional(schemaFactory.string),
+ * }) {}
+ *
+ * class Column extends TableSchema.createColumn({
+ * 	schemaFactory,
+ * 	props: ColumnProps,
+ * }) {}
+ *
+ * class Row extends TableSchema.createRow({
+ * 	schemaFactory,
+ * 	cell: Cell,
+ * }) {}
+ *
+ * class Table extends TableSchema.createTable({
+ * 	schemaFactory,
+ * 	cell: Cell,
+ * 	column: Column,
+ * 	row: Row,
+ * }) {}
+ *
+ * const table = new Table({
+ * 	columns: [
+ * 		new Column({ props: { label: "Entry", dataType: "string" } }),
+ * 		new Column({ props: { label: "Date", dataType: "date" } }),
+ * 		new Column({ props: { label: "Amount", dataType: "number" } }),
+ * 	],
+ * 	rows: [],
+ * });
+ * ```
+ *
+ * @privateRemarks
+ * The above examples are backed by tests in `tableSchema.spec.ts`.
+ * Those tests and these examples should be kept in-sync to ensure that the examples are correct.
+ *
+ * @internal
+ */
+export var TableSchema;
+(function (TableSchema) {
+    // #region Column
+    /**
+     * Overload implementation
+     */
+    function createColumn({ schemaFactory, props = SchemaFactory.optional(SchemaFactory.null), }) {
+        return System_TableSchema.createColumnInternal(schemaFactory, props);
+    }
+    TableSchema.createColumn = createColumn;
+    /**
+     * Overload implementation
+     */
+    function createRow({ schemaFactory, cell, props = SchemaFactory.optional(SchemaFactory.null), }) {
+        return System_TableSchema.createRowInternal(schemaFactory, cell, props);
+    }
+    TableSchema.createRow = createRow;
+    /**
+     * Overload implementation
+     */
+    function createTable({ schemaFactory, cell, column = createColumn({
+        schemaFactory,
+    }), row = createRow({
+        schemaFactory,
+        cell,
+    }), }) {
+        return System_TableSchema.createTableInternal(schemaFactory, cell, column, row);
+    }
+    TableSchema.createTable = createTable;
     // #endregion
 })(TableSchema || (TableSchema = {}));
 //# sourceMappingURL=tableSchema.js.map