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

package/dist/features/cell-selection/cellSelectionGeometry.js

@@ -0,0 +1,121 @@
+//#region src/features/cell-selection/cellSelectionGeometry.ts
+function compareBounds(a, b) {
+	return a.minRowIndex - b.minRowIndex || a.minColumnIndex - b.minColumnIndex || a.maxRowIndex - b.maxRowIndex || a.maxColumnIndex - b.maxColumnIndex;
+}
+function intersectCellSelectionBounds(a, b) {
+	const intersection = {
+		minRowIndex: Math.max(a.minRowIndex, b.minRowIndex),
+		maxRowIndex: Math.min(a.maxRowIndex, b.maxRowIndex),
+		minColumnIndex: Math.max(a.minColumnIndex, b.minColumnIndex),
+		maxColumnIndex: Math.min(a.maxColumnIndex, b.maxColumnIndex)
+	};
+	return intersection.minRowIndex <= intersection.maxRowIndex && intersection.minColumnIndex <= intersection.maxColumnIndex ? intersection : void 0;
+}
+function subtractCellSelectionBounds(source, excluded) {
+	const intersection = intersectCellSelectionBounds(source, excluded);
+	if (!intersection) return [source];
+	const result = [];
+	if (source.minRowIndex < intersection.minRowIndex) result.push({
+		...source,
+		maxRowIndex: intersection.minRowIndex - 1
+	});
+	if (intersection.maxRowIndex < source.maxRowIndex) result.push({
+		...source,
+		minRowIndex: intersection.maxRowIndex + 1
+	});
+	if (source.minColumnIndex < intersection.minColumnIndex) result.push({
+		minRowIndex: intersection.minRowIndex,
+		maxRowIndex: intersection.maxRowIndex,
+		minColumnIndex: source.minColumnIndex,
+		maxColumnIndex: intersection.minColumnIndex - 1
+	});
+	if (intersection.maxColumnIndex < source.maxColumnIndex) result.push({
+		minRowIndex: intersection.minRowIndex,
+		maxRowIndex: intersection.maxRowIndex,
+		minColumnIndex: intersection.maxColumnIndex + 1,
+		maxColumnIndex: source.maxColumnIndex
+	});
+	return result;
+}
+function mergePair(a, b) {
+	if (a.minRowIndex === b.minRowIndex && a.maxRowIndex === b.maxRowIndex && (a.maxColumnIndex + 1 === b.minColumnIndex || b.maxColumnIndex + 1 === a.minColumnIndex)) return {
+		minRowIndex: a.minRowIndex,
+		maxRowIndex: a.maxRowIndex,
+		minColumnIndex: Math.min(a.minColumnIndex, b.minColumnIndex),
+		maxColumnIndex: Math.max(a.maxColumnIndex, b.maxColumnIndex)
+	};
+	if (a.minColumnIndex === b.minColumnIndex && a.maxColumnIndex === b.maxColumnIndex && (a.maxRowIndex + 1 === b.minRowIndex || b.maxRowIndex + 1 === a.minRowIndex)) return {
+		minRowIndex: Math.min(a.minRowIndex, b.minRowIndex),
+		maxRowIndex: Math.max(a.maxRowIndex, b.maxRowIndex),
+		minColumnIndex: a.minColumnIndex,
+		maxColumnIndex: a.maxColumnIndex
+	};
+}
+function mergeAdjacentCellSelectionBounds(input) {
+	const result = input.slice();
+	for (let i = 0; i < result.length; i++) for (let j = i + 1; j < result.length; j++) {
+		const merged = mergePair(result[i], result[j]);
+		if (!merged) continue;
+		result.splice(j, 1);
+		result[i] = merged;
+		i = -1;
+		break;
+	}
+	return result.sort(compareBounds);
+}
+function addCellSelectionBounds(selected, included) {
+	let fragments = [included];
+	for (const existing of selected) {
+		fragments = fragments.flatMap((fragment) => subtractCellSelectionBounds(fragment, existing));
+		if (!fragments.length) return selected.slice();
+	}
+	return mergeAdjacentCellSelectionBounds([...selected, ...fragments]);
+}
+/**
+* Grows a rectangle until it fully contains every merged-cell rectangle it
+* touches.
+*
+* Merged cells make plain rectangles insufficient: a selection that clips part
+* of a merge must cover the whole merge, and covering it can bring the
+* rectangle into contact with further merges, so the expansion runs to a fixed
+* point. The loop is bounded by the merge count, since each pass that changes
+* the rectangle consumes at least one merge.
+*/
+function expandCellSelectionBounds(bounds, merges) {
+	let expanded = bounds;
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const merge of merges) {
+			if (!intersectCellSelectionBounds(expanded, merge)) continue;
+			const union = {
+				minRowIndex: Math.min(expanded.minRowIndex, merge.minRowIndex),
+				maxRowIndex: Math.max(expanded.maxRowIndex, merge.maxRowIndex),
+				minColumnIndex: Math.min(expanded.minColumnIndex, merge.minColumnIndex),
+				maxColumnIndex: Math.max(expanded.maxColumnIndex, merge.maxColumnIndex)
+			};
+			if (union.minRowIndex !== expanded.minRowIndex || union.maxRowIndex !== expanded.maxRowIndex || union.minColumnIndex !== expanded.minColumnIndex || union.maxColumnIndex !== expanded.maxColumnIndex) {
+				expanded = union;
+				changed = true;
+			}
+		}
+	}
+	return expanded;
+}
+function applyCellSelectionBoundsOperations(operations) {
+	let selected = [];
+	for (const operation of operations) {
+		const bounds = {
+			minRowIndex: operation.minRowIndex,
+			maxRowIndex: operation.maxRowIndex,
+			minColumnIndex: operation.minColumnIndex,
+			maxColumnIndex: operation.maxColumnIndex
+		};
+		if (operation.operation === "exclude") selected = mergeAdjacentCellSelectionBounds(selected.flatMap((bound) => subtractCellSelectionBounds(bound, bounds)));
+		else selected = addCellSelectionBounds(selected, bounds);
+	}
+	return selected.sort(compareBounds);
+}
+
+//#endregion
+export { addCellSelectionBounds, applyCellSelectionBoundsOperations, expandCellSelectionBounds, intersectCellSelectionBounds, mergeAdjacentCellSelectionBounds, subtractCellSelectionBounds };

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

@@ -0,0 +1,13 @@
+import { TableFeature } from "../../types/TableFeatures.js";
+//#region src/features/cell-spanning/cellSpanningFeature.d.ts
+/**
+ * Feature that merges adjacent cells that share a value into row-spanning
+ * cells, and lets a column def declare column-spanning cells per row.
+ *
+ * Stateless: spans are always derived from the rows that are currently
+ * rendered, so there is nothing to persist and nothing to configure beyond the
+ * column defs.
+ */
+declare const cellSpanningFeature: TableFeature;
+//#endregion
+export { cellSpanningFeature };

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

@@ -0,0 +1,47 @@
+import { assignPrototypeAPIs, assignTableAPIs } from "../../utils.js";
+import { cell_getColSpan, cell_getIsCovered, cell_getRowSpan, table_getCellSpanIndex } from "./cellSpanningFeature.utils.js";
+
+//#region src/features/cell-spanning/cellSpanningFeature.ts
+/**
+* Feature that merges adjacent cells that share a value into row-spanning
+* cells, and lets a column def declare column-spanning cells per row.
+*
+* Stateless: spans are always derived from the rows that are currently
+* rendered, so there is nothing to persist and nothing to configure beyond the
+* column defs.
+*/
+const cellSpanningFeature = {
+	getDefaultTableOptions: () => {
+		return { enableCellSpanning: true };
+	},
+	initRowInstanceData: (row) => {
+		row._cellSpanRowIndex = -1;
+	},
+	assignCellPrototype: (prototype, table) => {
+		assignPrototypeAPIs("cellSpanningFeature", prototype, table, {
+			cell_getColSpan: { fn: (cell) => cell_getColSpan(cell) },
+			cell_getIsCovered: { fn: (cell) => cell_getIsCovered(cell) },
+			cell_getRowSpan: { fn: (cell) => cell_getRowSpan(cell) }
+		});
+	},
+	constructTableAPIs: (table) => {
+		assignTableAPIs("cellSpanningFeature", table, { table_getCellSpanIndex: {
+			fn: () => table_getCellSpanIndex(table),
+			memoDeps: () => [
+				table.getRowModel().rows,
+				table.atoms.rowPinning?.get(),
+				table.options.keepPinnedRows,
+				table.atoms.columnVisibility?.get(),
+				table.atoms.columnOrder?.get(),
+				table.atoms.columnPinning?.get(),
+				table.atoms.grouping?.get(),
+				table.options.columns,
+				table.options.groupedColumnMode,
+				table.options.enableCellSpanning
+			]
+		} });
+	}
+};
+
+//#endregion
+export { cellSpanningFeature };

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.d.ts

@@ -1,10 +1,8 @@
 import { TableFeature } from "../../types/TableFeatures.js";
-
 //#region src/features/column-faceting/columnFacetingFeature.d.ts
 /**
  * Feature that derives faceted row models, unique values, and min/max values for filters.
  */
 declare const columnFacetingFeature: TableFeature;
 //#endregion
-export { columnFacetingFeature };
-//# sourceMappingURL=columnFacetingFeature.d.ts.map
+export { columnFacetingFeature };