@tanstack/table-core 9.0.0-beta.69 → 9.0.0-beta.70

package/dist/features/cell-spanning/cellSpanningFeature.types.d.ts

@@ -0,0 +1,150 @@
+import { CellData, RowData } from "../../types/type-utils.js";
+import { Column } from "../../types/Column.js";
+import { Row } from "../../types/Row.js";
+import { Table } from "../../types/Table.js";
+import { TableFeatures } from "../../types/TableFeatures.js";
+//#region src/features/cell-spanning/cellSpanningFeature.types.d.ts
+/**
+ * The table's cell span index for the rows that are currently rendered.
+ *
+ * Cell APIs read this; it is exposed for devtools and for virtualizers that
+ * need to know where a run's anchor sits relative to the rendered window.
+ */
+interface CellSpanIndex<in out TFeatures extends TableFeatures, in out TData extends RowData> {
+  /**
+   * Column spans per render-order row position, indexed by render-order column
+   * position. Holes are the common case: only rows that declared a column span
+   * get an array. In a stored array, the spanning cell holds its span and the
+   * cells it covers hold `0`; every other cell holds `1`.
+   */
+  colSpans: Array<Int32Array | undefined>;
+  /**
+   * Render-order index for every visible column id. Hidden columns are absent.
+   */
+  columnIndexes: Record<string, number>;
+  /**
+   * Row spans per column id, indexed by render-order row position. Only columns
+   * that produced at least one run longer than one row appear here; a missing
+   * column means every cell in it spans exactly one row. In a stored array, the
+   * run's anchor row holds the run length and the rows it covers hold `0`.
+   */
+  rowSpans: Record<string, Int32Array>;
+  /**
+   * The exact ordered rows this index was built from, in render order:
+   * top-pinned rows, then the (paginated) center rows, then bottom-pinned
+   * rows. Cell reads compare against this to reject stale row positions.
+   */
+  rows: ReadonlyArray<Row<TFeatures, TData>>;
+}
+/**
+ * Context passed to a `spanRows` predicate for each candidate row.
+ *
+ * The run is anchored: `anchorRow` is the row whose cell will render the
+ * merged content, and every later row in the run is tested against it, which
+ * keeps runs transitive by construction. `previousRow` is provided for
+ * predicates that want a step-wise comparison instead.
+ */
+interface RowSpanContext<in out TFeatures extends TableFeatures, in out TData extends RowData, TValue extends CellData = CellData> {
+  anchorRow: Row<TFeatures, TData>;
+  anchorValue: TValue;
+  column: Column<TFeatures, TData, TValue>;
+  previousRow: Row<TFeatures, TData>;
+  row: Row<TFeatures, TData>;
+  table: Table<TFeatures, TData>;
+  value: TValue;
+}
+/**
+ * Context passed to a `spanColumns` resolver for each rendered row.
+ */
+interface ColSpanContext<in out TFeatures extends TableFeatures, in out TData extends RowData, TValue extends CellData = CellData> {
+  column: Column<TFeatures, TData, TValue>;
+  row: Row<TFeatures, TData>;
+  table: Table<TFeatures, TData>;
+}
+interface ColumnDef_CellSpanning<in out TFeatures extends TableFeatures, in out TData extends RowData, TValue extends CellData = CellData> {
+  /**
+   * Turns this column off for cell spanning even when the table allows it.
+   * Defaults to `true`.
+   */
+  enableCellSpanning?: boolean;
+  /**
+   * Makes this column's cell span the given number of columns per row,
+   * starting at itself and counted in the order columns actually render.
+   *
+   * Return `1` or less for no span. Larger values are clamped to the end of
+   * the cell's pinned region, so a span can never cross the start-pinned,
+   * center, or end-pinned boundary; pass `Infinity` for "the rest of my
+   * region". Hidden columns are not counted.
+   *
+   * @example
+   * ```ts
+   * { accessorKey: 'label', spanColumns: ({ row }) => row.original.isSummary ? Infinity : 1 }
+   * ```
+   */
+  spanColumns?: number | ((context: ColSpanContext<TFeatures, TData, TValue>) => number);
+  /**
+   * Merges adjacent rows in this column into a single vertically spanning
+   * cell.
+   *
+   * `true` merges rows whose values for this column are the same value
+   * (`Object.is`). Nullish values never merge under the default comparison.
+   *
+   * A predicate replaces the comparison entirely and decides whether `row`
+   * joins the run anchored at `anchorRow`; it may merge nullish values. It is
+   * called once per candidate row each time the span index rebuilds, and each
+   * call allocates one context object, so keep it cheap.
+   *
+   * Spans are always recomputed from the rows that are actually rendered, so
+   * sorting, filtering, and paging only change which rows are adjacent. Runs
+   * never cross a page boundary, a pinned-row section boundary, a change of
+   * position in the row tree, or a grouped row. Ignored while this column is
+   * grouped.
+   *
+   * @example
+   * ```ts
+   * { accessorKey: 'department', spanRows: true }
+   * ```
+   */
+  spanRows?: boolean | ((context: RowSpanContext<TFeatures, TData, TValue>) => boolean);
+}
+interface TableOptions_CellSpanning {
+  /**
+   * Allows cells to span rows or columns. When `false` every cell reports a
+   * span of `1` and the span index is never built. Defaults to `true`.
+   */
+  enableCellSpanning?: boolean;
+}
+interface Cell_CellSpanning {
+  /**
+   * Number of columns this cell spans when rendered. `1` when it does not
+   * span, and `0` when another cell's column span covers it.
+   *
+   * Never render a `0` as a `colSpan` attribute; skip the cell instead. See
+   * `getIsCovered`.
+   */
+  getColSpan: () => number;
+  /**
+   * Whether another cell's span covers this cell. Skip rendering covered
+   * cells; the cell that covers them carries the content and the span
+   * attributes.
+   */
+  getIsCovered: () => boolean;
+  /**
+   * Number of rows this cell spans when rendered. `1` when it does not span,
+   * and `0` when a spanning cell above it covers it, matching the
+   * `header.rowSpan` convention.
+   *
+   * Never render a `0` as a `rowSpan` attribute: in HTML, `rowspan="0"` means
+   * "span to the end of the row group", which merges the cell down the entire
+   * table section. Skip the cell instead. See `getIsCovered`.
+   */
+  getRowSpan: () => number;
+}
+interface Table_CellSpanning<in out TFeatures extends TableFeatures, in out TData extends RowData> {
+  /**
+   * The memoized span index for the rows that are currently rendered.
+   */
+  getCellSpanIndex: () => CellSpanIndex<TFeatures, TData>;
+}
+//#endregion
+export { CellSpanIndex, Cell_CellSpanning, ColSpanContext, ColumnDef_CellSpanning, RowSpanContext, TableOptions_CellSpanning, Table_CellSpanning };

package/dist/features/cell-spanning/cellSpanningFeature.utils.d.ts

@@ -0,0 +1,74 @@
+import { CellData, RowData } from "../../types/type-utils.js";
+import { Column } from "../../types/Column.js";
+import { Table } from "../../types/Table.js";
+import { CellSpanIndex } from "./cellSpanningFeature.types.js";
+import { Cell } from "../../types/Cell.js";
+import { TableFeatures } from "../../types/TableFeatures.js";
+//#region src/features/cell-spanning/cellSpanningFeature.utils.d.ts
+/**
+ * Checks whether this column takes part in cell spanning.
+ *
+ * A column def opting out with `enableCellSpanning: false` wins over the table
+ * option, matching how the other per-column enable flags resolve.
+ *
+ * @example
+ * ```ts
+ * const canSpan = column_getCanSpan(column)
+ * ```
+ */
+declare function column_getCanSpan<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column<TFeatures, TData, TValue>): boolean;
+/**
+ * Builds the table's cell span index for the rows that are currently rendered.
+ *
+ * Spans are always derived from scratch from the final row model, so sorting,
+ * filtering, pagination, expansion, and row pinning only change adjacency and
+ * the index follows. Nothing is persisted and there is nothing to configure.
+ *
+ * @example
+ * ```ts
+ * const spanIndex = table_getCellSpanIndex(table)
+ * ```
+ */
+declare function table_getCellSpanIndex<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>): CellSpanIndex<TFeatures, TData>;
+/**
+ * Returns how many rows this cell spans.
+ *
+ * `1` when it does not span, and `0` when a spanning cell above it covers it,
+ * matching the `header.rowSpan` convention where `0` means "skip this cell".
+ *
+ * Deliberately not memoized: a per-cell memo would allocate a closure and a
+ * dependency array for every cell, costing more than the two lookups this
+ * performs against the table-level span index.
+ *
+ * @example
+ * ```ts
+ * const rowSpan = cell_getRowSpan(cell)
+ * ```
+ */
+declare function cell_getRowSpan<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(cell: Cell<TFeatures, TData, TValue>): number;
+/**
+ * Returns how many columns this cell spans.
+ *
+ * `1` when it does not span, and `0` when another cell's column span covers
+ * it.
+ *
+ * @example
+ * ```ts
+ * const colSpan = cell_getColSpan(cell)
+ * ```
+ */
+declare function cell_getColSpan<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(cell: Cell<TFeatures, TData, TValue>): number;
+/**
+ * Checks whether another cell's span covers this cell.
+ *
+ * Covered cells must not be rendered; the cell that covers them carries the
+ * content and the span attributes.
+ *
+ * @example
+ * ```ts
+ * const isCovered = cell_getIsCovered(cell)
+ * ```
+ */
+declare function cell_getIsCovered<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(cell: Cell<TFeatures, TData, TValue>): boolean;
+//#endregion
+export { cell_getColSpan, cell_getIsCovered, cell_getRowSpan, column_getCanSpan, table_getCellSpanIndex };

package/dist/features/cell-spanning/cellSpanningFeature.utils.js

@@ -0,0 +1,262 @@
+import { callMemoOrStaticFn, isFunction, makeObjectMap } from "../../utils.js";
+
+//#region src/features/cell-spanning/cellSpanningFeature.utils.ts
+const EMPTY_ROW_SPANS = makeObjectMap();
+const EMPTY_COLUMN_INDEXES = makeObjectMap();
+const EMPTY_COL_SPANS = [];
+const NO_SECTION_STARTS = [];
+/**
+* Resolves the rows in the order a renderer actually draws them, plus the
+* positions at which a new visual section begins.
+*
+* Without row pinning this is the final row model itself, returned by
+* reference so the common path allocates nothing. With row pinning it is the
+* concatenation the three-list renderer walks: `getTopRows()`,
+* `getCenterRows()`, `getBottomRows()`. `getCenterRows()` filters the row
+* model by the pinned ids, so no row appears in two sections and every row
+* gets exactly one position; with `keepPinnedRows` a pinned row that filtering
+* removed from the row model still appears exactly once, in its pinned
+* section.
+*
+* The pinning reads are optional-chained so the feature stays correct when
+* `rowPinningFeature` is not registered.
+*/
+function getRenderedRows(table) {
+	const rows = table.getRowModel().rows;
+	const rowPinning = table.atoms.rowPinning?.get();
+	if (!rowPinning || !rowPinning.top.length && !rowPinning.bottom.length) return {
+		rows,
+		sectionStarts: NO_SECTION_STARTS
+	};
+	const pinnedTable = table;
+	const top = pinnedTable.getTopRows?.() ?? [];
+	const center = pinnedTable.getCenterRows?.() ?? rows;
+	const bottom = pinnedTable.getBottomRows?.() ?? [];
+	return {
+		rows: [
+			...top,
+			...center,
+			...bottom
+		],
+		sectionStarts: [top.length, top.length + center.length]
+	};
+}
+/**
+* Resolves the visible columns in the order cells render, plus the two
+* boundaries between the start-pinned, center, and end-pinned regions.
+*
+* Read off a rendered row's visible cells rather than re-derived, so the
+* ordering is the renderer's own by construction. `getVisibleCells` only
+* exists when `columnVisibilityFeature` is registered; without it renderers
+* walk `row.getAllCells()`, whose order is `table.getAllLeafColumns()`.
+*/
+function getRenderedColumns(table, firstRow) {
+	const cells = firstRow.getVisibleCells?.() ?? firstRow.getAllCells();
+	const columns = new Array(cells.length);
+	for (let i = 0; i < cells.length; i++) columns[i] = cells[i].column;
+	const pinning = table.atoms.columnPinning?.get();
+	let centerStart = 0;
+	let centerEnd = columns.length;
+	if (pinning) {
+		while (centerStart < centerEnd && pinning.start.includes(columns[centerStart].id)) centerStart++;
+		while (centerEnd > centerStart && pinning.end.includes(columns[centerEnd - 1].id)) centerEnd--;
+	}
+	return {
+		columns,
+		centerStart,
+		centerEnd
+	};
+}
+/**
+* Checks whether this column takes part in cell spanning.
+*
+* A column def opting out with `enableCellSpanning: false` wins over the table
+* option, matching how the other per-column enable flags resolve.
+*
+* @example
+* ```ts
+* const canSpan = column_getCanSpan(column)
+* ```
+*/
+function column_getCanSpan(column) {
+	if (column.columnDef.enableCellSpanning === false) return false;
+	return column.table.options.enableCellSpanning ?? true;
+}
+/**
+* Builds the table's cell span index for the rows that are currently rendered.
+*
+* Spans are always derived from scratch from the final row model, so sorting,
+* filtering, pagination, expansion, and row pinning only change adjacency and
+* the index follows. Nothing is persisted and there is nothing to configure.
+*
+* @example
+* ```ts
+* const spanIndex = table_getCellSpanIndex(table)
+* ```
+*/
+function table_getCellSpanIndex(table) {
+	const { rows, sectionStarts } = getRenderedRows(table);
+	const rowCount = rows.length;
+	const empty = {
+		colSpans: EMPTY_COL_SPANS,
+		columnIndexes: EMPTY_COLUMN_INDEXES,
+		rowSpans: EMPTY_ROW_SPANS,
+		rows
+	};
+	if (!rowCount || table.options.enableCellSpanning === false) return empty;
+	const { columns, centerStart, centerEnd } = getRenderedColumns(table, rows[0]);
+	const columnCount = columns.length;
+	if (!columnCount) return empty;
+	const columnIndexes = makeObjectMap();
+	for (let c = 0; c < columnCount; c++) columnIndexes[columns[c].id] = c;
+	const breaks = new Uint8Array(rowCount);
+	for (let s = 0; s < sectionStarts.length; s++) {
+		const start = sectionStarts[s];
+		if (start < rowCount) breaks[start] = 1;
+	}
+	for (let r = 0; r < rowCount; r++) {
+		const row = rows[r];
+		row._cellSpanRowIndex = r;
+		const prev = r > 0 ? rows[r - 1] : void 0;
+		if (prev && (row.depth !== prev.depth || row.parentId !== prev.parentId) || row.getIsGrouped?.() === true) breaks[r] = 1;
+	}
+	const colSpans = [];
+	let anyColSpan = false;
+	for (let c = 0; c < columnCount; c++) {
+		const column = columns[c];
+		const spanColumns = column.columnDef.spanColumns;
+		if (spanColumns === void 0 || !column_getCanSpan(column)) continue;
+		const regionEnd = c < centerStart ? centerStart : c < centerEnd ? centerEnd : columnCount;
+		for (let r = 0; r < rowCount; r++) {
+			const existing = colSpans[r];
+			if (existing && existing[c] === 0) continue;
+			const requested = isFunction(spanColumns) ? spanColumns({
+				column,
+				row: rows[r],
+				table
+			}) : spanColumns;
+			if (!(requested > 1)) continue;
+			const span = Math.min(requested, regionEnd - c);
+			if (span < 2) continue;
+			const target = existing ?? (colSpans[r] = new Int32Array(columnCount).fill(1));
+			target[c] = span;
+			for (let k = c + 1; k < c + span; k++) target[k] = 0;
+			anyColSpan = true;
+		}
+	}
+	const rowSpans = makeObjectMap();
+	for (let c = 0; c < columnCount; c++) {
+		const column = columns[c];
+		const spanRows = column.columnDef.spanRows;
+		if (!spanRows || !column_getCanSpan(column)) continue;
+		if (column.getIsGrouped?.() === true) continue;
+		const columnId = column.id;
+		const predicate = isFunction(spanRows) ? spanRows : void 0;
+		const spans = new Int32Array(rowCount).fill(1);
+		let anyRun = false;
+		let anchorIndex = -1;
+		let anchorValue;
+		let anchorColSpan = 1;
+		for (let r = 0; r < rowCount; r++) {
+			const row = rows[r];
+			const rowColSpans = anyColSpan ? colSpans[r] : void 0;
+			const cellColSpan = rowColSpans ? rowColSpans[c] : 1;
+			if (cellColSpan === 0) {
+				anchorIndex = -1;
+				continue;
+			}
+			const value = row.getValue(columnId);
+			if (anchorIndex !== -1 && !breaks[r] && cellColSpan === anchorColSpan && (predicate ? predicate({
+				anchorRow: rows[anchorIndex],
+				anchorValue,
+				column,
+				previousRow: rows[r - 1],
+				row,
+				table,
+				value
+			}) : value != null && Object.is(value, anchorValue))) {
+				spans[r] = 0;
+				spans[anchorIndex] = spans[anchorIndex] + 1;
+				anyRun = true;
+				continue;
+			}
+			anchorIndex = r;
+			anchorValue = value;
+			anchorColSpan = cellColSpan;
+		}
+		if (anyRun) rowSpans[columnId] = spans;
+	}
+	return {
+		colSpans,
+		columnIndexes,
+		rowSpans,
+		rows
+	};
+}
+function resolveRowIndex(index, cell) {
+	const rowIndex = cell.row._cellSpanRowIndex;
+	if (rowIndex === void 0 || index.rows[rowIndex] !== cell.row) return -1;
+	return rowIndex;
+}
+/**
+* Returns how many rows this cell spans.
+*
+* `1` when it does not span, and `0` when a spanning cell above it covers it,
+* matching the `header.rowSpan` convention where `0` means "skip this cell".
+*
+* Deliberately not memoized: a per-cell memo would allocate a closure and a
+* dependency array for every cell, costing more than the two lookups this
+* performs against the table-level span index.
+*
+* @example
+* ```ts
+* const rowSpan = cell_getRowSpan(cell)
+* ```
+*/
+function cell_getRowSpan(cell) {
+	const table = cell.row.table;
+	const index = callMemoOrStaticFn(table, "getCellSpanIndex", table_getCellSpanIndex);
+	const spans = index.rowSpans[cell.column.id];
+	if (!spans) return 1;
+	const rowIndex = resolveRowIndex(index, cell);
+	if (rowIndex === -1) return 1;
+	return spans[rowIndex];
+}
+/**
+* Returns how many columns this cell spans.
+*
+* `1` when it does not span, and `0` when another cell's column span covers
+* it.
+*
+* @example
+* ```ts
+* const colSpan = cell_getColSpan(cell)
+* ```
+*/
+function cell_getColSpan(cell) {
+	const table = cell.row.table;
+	const index = callMemoOrStaticFn(table, "getCellSpanIndex", table_getCellSpanIndex);
+	const rowIndex = resolveRowIndex(index, cell);
+	if (rowIndex === -1) return 1;
+	const spans = index.colSpans[rowIndex];
+	if (!spans) return 1;
+	const columnIndex = index.columnIndexes[cell.column.id];
+	return columnIndex === void 0 ? 1 : spans[columnIndex];
+}
+/**
+* Checks whether another cell's span covers this cell.
+*
+* Covered cells must not be rendered; the cell that covers them carries the
+* content and the span attributes.
+*
+* @example
+* ```ts
+* const isCovered = cell_getIsCovered(cell)
+* ```
+*/
+function cell_getIsCovered(cell) {
+	return cell_getRowSpan(cell) === 0 || cell_getColSpan(cell) === 0;
+}
+
+//#endregion
+export { cell_getColSpan, cell_getIsCovered, cell_getRowSpan, column_getCanSpan, table_getCellSpanIndex };

package/dist/features/column-faceting/columnFacetingFeature.utils.d.ts

@@ -1,7 +1,7 @@
 import { CellData, RowData } from "../../types/type-utils.js";
-import { Table } from "../../types/Table.js";
 import { Column } from "../../types/Column.js";
 import { RowModel } from "../../core/row-models/coreRowModelsFeature.types.js";
+import { Table } from "../../types/Table.js";
 import { TableFeatures } from "../../types/TableFeatures.js";
 //#region src/features/column-faceting/columnFacetingFeature.utils.d.ts
 /**

package/dist/features/column-faceting/createFacetedRowModel.d.ts

@@ -1,6 +1,6 @@
 import { RowData } from "../../types/type-utils.js";
-import { Table } from "../../types/Table.js";
 import { RowModel } from "../../core/row-models/coreRowModelsFeature.types.js";
+import { Table } from "../../types/Table.js";
 import { TableFeatures } from "../../types/TableFeatures.js";
 //#region src/features/column-faceting/createFacetedRowModel.d.ts
 /**

package/dist/features/column-filtering/columnFilteringFeature.utils.d.ts

@@ -1,7 +1,7 @@
 import { CellData, RowData, Updater } from "../../types/type-utils.js";
-import { Table } from "../../types/Table.js";
 import { Column } from "../../types/Column.js";
 import { ColumnFiltersState, FilterFn } from "./columnFilteringFeature.types.js";
+import { Table } from "../../types/Table.js";
 import { TableFeatures } from "../../types/TableFeatures.js";
 //#region src/features/column-filtering/columnFilteringFeature.utils.d.ts
 /**

package/dist/features/column-filtering/createFilteredRowModel.d.ts

@@ -1,6 +1,6 @@
 import { RowData } from "../../types/type-utils.js";
-import { Table } from "../../types/Table.js";
 import { RowModel } from "../../core/row-models/coreRowModelsFeature.types.js";
+import { Table } from "../../types/Table.js";
 import { TableFeatures } from "../../types/TableFeatures.js";
 //#region src/features/column-filtering/createFilteredRowModel.d.ts
 /**

package/dist/features/column-grouping/columnGroupingFeature.utils.d.ts

@@ -1,8 +1,8 @@
 import { CellData, RowData, Updater } from "../../types/type-utils.js";
-import { Table } from "../../types/Table.js";
+import { GroupingState, Row_ColumnGrouping } from "./columnGroupingFeature.types.js";
 import { Column } from "../../types/Column.js";
 import { Row } from "../../types/Row.js";
-import { GroupingState, Row_ColumnGrouping } from "./columnGroupingFeature.types.js";
+import { Table } from "../../types/Table.js";
 import { Cell } from "../../types/Cell.js";
 import { TableFeatures } from "../../types/TableFeatures.js";
 //#region src/features/column-grouping/columnGroupingFeature.utils.d.ts

package/dist/features/column-grouping/createGroupedRowModel.d.ts

@@ -1,6 +1,6 @@
 import { RowData } from "../../types/type-utils.js";
-import { Table } from "../../types/Table.js";
 import { RowModel } from "../../core/row-models/coreRowModelsFeature.types.js";
+import { Table } from "../../types/Table.js";
 import { TableFeatures } from "../../types/TableFeatures.js";
 //#region src/features/column-grouping/createGroupedRowModel.d.ts
 /**

package/dist/features/column-ordering/columnOrderingFeature.utils.d.ts

@@ -1,8 +1,8 @@
 import { CellData, RowData, Updater } from "../../types/type-utils.js";
 import { ColumnPinningPosition } from "../column-pinning/columnPinningFeature.types.js";
 import { ColumnIndexes, ColumnOrderState } from "./columnOrderingFeature.types.js";
-import { Table } from "../../types/Table.js";
 import { Column } from "../../types/Column.js";
+import { Table } from "../../types/Table.js";
 import { TableFeatures } from "../../types/TableFeatures.js";
 //#region src/features/column-ordering/columnOrderingFeature.utils.d.ts
 /**

package/dist/features/column-pinning/columnPinningFeature.utils.d.ts

@@ -1,10 +1,10 @@
 import { CellData, RowData, Updater } from "../../types/type-utils.js";
 import { HeaderGroup } from "../../types/HeaderGroup.js";
-import { Header } from "../../types/Header.js";
 import { ColumnPinningPosition, ColumnPinningState } from "./columnPinningFeature.types.js";
-import { Table } from "../../types/Table.js";
+import { Header } from "../../types/Header.js";
 import { Column } from "../../types/Column.js";
 import { Row } from "../../types/Row.js";
+import { Table } from "../../types/Table.js";
 import { Cell } from "../../types/Cell.js";
 import { TableFeatures } from "../../types/TableFeatures.js";
 //#region src/features/column-pinning/columnPinningFeature.utils.d.ts

package/dist/features/column-resizing/columnResizingFeature.utils.d.ts

@@ -1,8 +1,8 @@
 import { CellData, RowData, Updater } from "../../types/type-utils.js";
 import { columnResizingState } from "./columnResizingFeature.types.js";
 import { Header } from "../../types/Header.js";
-import { Table } from "../../types/Table.js";
 import { Column } from "../../types/Column.js";
+import { Table } from "../../types/Table.js";
 import { TableFeatures } from "../../types/TableFeatures.js";
 //#region src/features/column-resizing/columnResizingFeature.utils.d.ts
 /**

package/dist/features/column-sizing/columnSizingFeature.utils.d.ts

@@ -1,9 +1,9 @@
 import { CellData, RowData, Updater } from "../../types/type-utils.js";
+import { ColumnPinningPosition } from "../column-pinning/columnPinningFeature.types.js";
 import { ColumnOffsetsByPosition, ColumnSizingState } from "./columnSizingFeature.types.js";
 import { Header } from "../../types/Header.js";
-import { ColumnPinningPosition } from "../column-pinning/columnPinningFeature.types.js";
-import { Table } from "../../types/Table.js";
 import { Column } from "../../types/Column.js";
+import { Table } from "../../types/Table.js";
 import { TableFeatures } from "../../types/TableFeatures.js";
 //#region src/features/column-sizing/columnSizingFeature.utils.d.ts
 /**

package/dist/features/column-visibility/columnVisibilityFeature.utils.d.ts

@@ -1,8 +1,8 @@
 import { CellData, RowData, Updater } from "../../types/type-utils.js";
-import { Table } from "../../types/Table.js";
 import { Column } from "../../types/Column.js";
 import { ColumnVisibilityState } from "./columnVisibilityFeature.types.js";
 import { Row } from "../../types/Row.js";
+import { Table } from "../../types/Table.js";
 import { Cell } from "../../types/Cell.js";
 import { TableFeatures } from "../../types/TableFeatures.js";
 import "../../index.js";

package/dist/features/global-filtering/globalFilteringFeature.utils.d.ts

@@ -1,7 +1,7 @@
 import { CellData, RowData } from "../../types/type-utils.js";
-import { Table } from "../../types/Table.js";
 import { Column } from "../../types/Column.js";
 import { CreatedFilterFn, FilterFn } from "../column-filtering/columnFilteringFeature.types.js";
+import { Table } from "../../types/Table.js";
 import { TableFeatures } from "../../types/TableFeatures.js";
 import "../../index.js";
 //#region src/features/global-filtering/globalFilteringFeature.utils.d.ts

package/dist/features/row-aggregation/rowAggregationFeature.types.d.ts

@@ -1,9 +1,9 @@
 import { CellData, RowData } from "../../types/type-utils.js";
 import { BuiltInAggregationFn } from "./aggregationFns.js";
 import { ColumnDefTemplate } from "../../types/ColumnDef.js";
-import { Table } from "../../types/Table.js";
 import { Column } from "../../types/Column.js";
 import { Row } from "../../types/Row.js";
+import { Table } from "../../types/Table.js";
 import { Cell } from "../../types/Cell.js";
 import { IsAny, TableFeatures } from "../../types/TableFeatures.js";
 //#region src/features/row-aggregation/rowAggregationFeature.types.d.ts

package/dist/features/row-expanding/createExpandedRowModel.d.ts

@@ -1,6 +1,6 @@
 import { RowData } from "../../types/type-utils.js";
-import { Table } from "../../types/Table.js";
 import { RowModel } from "../../core/row-models/coreRowModelsFeature.types.js";
+import { Table } from "../../types/Table.js";
 import { TableFeatures } from "../../types/TableFeatures.js";
 //#region src/features/row-expanding/createExpandedRowModel.d.ts
 /**

package/dist/features/row-expanding/rowExpandingFeature.utils.d.ts

@@ -1,7 +1,7 @@
 import { RowData, Updater } from "../../types/type-utils.js";
 import { ExpandedState } from "./rowExpandingFeature.types.js";
-import { Table } from "../../types/Table.js";
 import { Row } from "../../types/Row.js";
+import { Table } from "../../types/Table.js";
 import { TableFeatures } from "../../types/TableFeatures.js";
 //#region src/features/row-expanding/rowExpandingFeature.utils.d.ts
 /**

package/dist/features/row-pagination/createPaginatedRowModel.d.ts

@@ -1,6 +1,6 @@
 import { RowData } from "../../types/type-utils.js";
-import { Table } from "../../types/Table.js";
 import { RowModel } from "../../core/row-models/coreRowModelsFeature.types.js";
+import { Table } from "../../types/Table.js";
 import { TableFeatures } from "../../types/TableFeatures.js";
 //#region src/features/row-pagination/createPaginatedRowModel.d.ts
 /**

package/dist/features/row-pinning/rowPinningFeature.utils.d.ts

@@ -1,7 +1,7 @@
 import { RowData, Updater } from "../../types/type-utils.js";
 import { RowPinningPosition, RowPinningState } from "./rowPinningFeature.types.js";
-import { Table } from "../../types/Table.js";
 import { Row } from "../../types/Row.js";
+import { Table } from "../../types/Table.js";
 import { TableFeatures } from "../../types/TableFeatures.js";
 //#region src/features/row-pinning/rowPinningFeature.utils.d.ts
 /**