@tanstack/table-core 9.0.0-beta.9 → 9.0.1

package/dist/core/headers/buildHeaderGroups.js

@@ -3,101 +3,115 @@ import { column_getIsVisible } from "../../features/column-visibility/columnVisi
 import { constructHeader } from "./constructHeader.js";
 
 //#region src/core/headers/buildHeaderGroups.ts
+function getMaxHeaderDepth(columns, depth = 1) {
+	let maxDepth = depth;
+	for (let i = 0; i < columns.length; i++) {
+		const column = columns[i];
+		if (callMemoOrStaticFn(column, "getIsVisible", column_getIsVisible) && column.columns.length) maxDepth = Math.max(maxDepth, getMaxHeaderDepth(column.columns, depth + 1));
+	}
+	return maxDepth;
+}
+function formatHeaderGroupId(headerFamily, depth) {
+	return headerFamily ? `${headerFamily}_${depth}` : String(depth);
+}
+function formatHeaderId(headerFamily, depth, columnId, childHeaderId) {
+	let id = headerFamily ?? "";
+	if (depth) id = id ? `${id}_${depth}` : String(depth);
+	if (columnId) id = id ? `${id}_${columnId}` : columnId;
+	if (childHeaderId) id = id ? `${id}_${childHeaderId}` : childHeaderId;
+	return id;
+}
+function countPendingHeadersForColumn(headers, column) {
+	let count = 0;
+	for (let i = 0; i < headers.length; i++) if (headers[i].column === column) count++;
+	return count;
+}
+function constructHeaderGroup(headersToGroup, depth, table, headerFamily, headerGroups, headerGroupInitFns) {
+	const headerGroup = {
+		depth,
+		id: formatHeaderGroupId(headerFamily, depth),
+		headers: []
+	};
+	const pendingParentHeaders = [];
+	for (let i = 0; i < headersToGroup.length; i++) {
+		if (!(i in headersToGroup)) continue;
+		const headerToGroup = headersToGroup[i];
+		const latestPendingParentHeader = pendingParentHeaders[pendingParentHeaders.length - 1];
+		const isLeafHeader = headerToGroup.column.depth === headerGroup.depth;
+		let column;
+		let isPlaceholder = false;
+		if (isLeafHeader && headerToGroup.column.parent) column = headerToGroup.column.parent;
+		else {
+			column = headerToGroup.column;
+			isPlaceholder = true;
+		}
+		if (latestPendingParentHeader && latestPendingParentHeader.column === column) latestPendingParentHeader.subHeaders.push(headerToGroup);
+		else {
+			const header = constructHeader(table, column, {
+				id: formatHeaderId(headerFamily, depth, column.id, headerToGroup.id),
+				isPlaceholder,
+				placeholderId: isPlaceholder ? String(countPendingHeadersForColumn(pendingParentHeaders, column)) : void 0,
+				depth,
+				index: pendingParentHeaders.length
+			});
+			header.subHeaders.push(headerToGroup);
+			pendingParentHeaders.push(header);
+		}
+		headerGroup.headers.push(headerToGroup);
+		headerToGroup.headerGroup = headerGroup;
+	}
+	for (let i = 0; i < headerGroupInitFns.length; i++) headerGroupInitFns[i](headerGroup);
+	headerGroups.push(headerGroup);
+	if (depth > 0) constructHeaderGroup(pendingParentHeaders, depth - 1, table, headerFamily, headerGroups, headerGroupInitFns);
+}
+function updateHeaderSpans(headers) {
+	for (let i = 0; i < headers.length; i++) {
+		const header = headers[i];
+		if (!callMemoOrStaticFn(header.column, "getIsVisible", column_getIsVisible)) continue;
+		let colSpan = 0;
+		if (header.subHeaders.length) {
+			updateHeaderSpans(header.subHeaders);
+			for (let j = 0; j < header.subHeaders.length; j++) {
+				const child = header.subHeaders[j];
+				if (!callMemoOrStaticFn(child.column, "getIsVisible", column_getIsVisible)) continue;
+				colSpan += child.colSpan;
+			}
+		} else colSpan = 1;
+		header.colSpan = colSpan;
+		if (header.isPlaceholder && header.subHeaders.length === 1 && header.subHeaders[0].column === header.column) {
+			let rowSpan = 1;
+			let chainChild = header.subHeaders[0];
+			while (chainChild) {
+				chainChild.rowSpan = 0;
+				rowSpan++;
+				chainChild = chainChild.subHeaders.length === 1 && chainChild.subHeaders[0].column === header.column ? chainChild.subHeaders[0] : void 0;
+			}
+			header.rowSpan = rowSpan;
+		} else header.rowSpan = 1;
+	}
+}
 /**
 * Builds the nested header group structure for a table.
 *
 * The result accounts for visible leaf columns, pinned column groups, and placeholder headers needed to render multi-level headers.
 */
 function buildHeaderGroups(allColumns, columnsToGroup, table, headerFamily) {
-	var _headerGroups$;
-	let maxDepth = 0;
-	const findMaxDepth = (columns, depth = 1) => {
-		maxDepth = Math.max(maxDepth, depth);
-		for (let i = 0; i < columns.length; i++) {
-			const column = columns[i];
-			if (callMemoOrStaticFn(column, "getIsVisible", column_getIsVisible)) {
-				if (column.columns.length) findMaxDepth(column.columns, depth + 1);
-			}
-		}
-	};
-	findMaxDepth(allColumns);
+	const maxDepth = getMaxHeaderDepth(allColumns);
 	const headerGroups = [];
-	const constructHeaderGroup = (headersToGroup, depth) => {
-		const headerGroup = {
-			depth,
-			id: [headerFamily, `${depth}`].filter(Boolean).join("_"),
-			headers: []
-		};
-		const pendingParentHeaders = [];
-		headersToGroup.forEach((headerToGroup) => {
-			const latestPendingParentHeader = pendingParentHeaders[pendingParentHeaders.length - 1];
-			const isLeafHeader = headerToGroup.column.depth === headerGroup.depth;
-			let column;
-			let isPlaceholder = false;
-			if (isLeafHeader && headerToGroup.column.parent) column = headerToGroup.column.parent;
-			else {
-				column = headerToGroup.column;
-				isPlaceholder = true;
-			}
-			if (latestPendingParentHeader && latestPendingParentHeader.column === column) latestPendingParentHeader.subHeaders.push(headerToGroup);
-			else {
-				const header = constructHeader(table, column, {
-					id: [
-						headerFamily,
-						depth,
-						column.id,
-						headerToGroup.id
-					].filter(Boolean).join("_"),
-					isPlaceholder,
-					placeholderId: isPlaceholder ? `${pendingParentHeaders.filter((d) => d.column === column).length}` : void 0,
-					depth,
-					index: pendingParentHeaders.length
-				});
-				header.subHeaders.push(headerToGroup);
-				pendingParentHeaders.push(header);
-			}
-			headerGroup.headers.push(headerToGroup);
-			headerToGroup.headerGroup = headerGroup;
+	const headerGroupInitFns = table._headerGroupInstanceInitFns;
+	const bottomHeaders = new Array(columnsToGroup.length);
+	for (let i = 0; i < columnsToGroup.length; i++) {
+		if (!(i in columnsToGroup)) continue;
+		bottomHeaders[i] = constructHeader(table, columnsToGroup[i], {
+			depth: maxDepth,
+			index: i
 		});
-		headerGroups.push(headerGroup);
-		if (depth > 0) constructHeaderGroup(pendingParentHeaders, depth - 1);
-	};
-	constructHeaderGroup(columnsToGroup.map((column, index) => constructHeader(table, column, {
-		depth: maxDepth,
-		index
-	})), maxDepth - 1);
+	}
+	constructHeaderGroup(bottomHeaders, maxDepth - 1, table, headerFamily, headerGroups, headerGroupInitFns);
 	headerGroups.reverse();
-	const recurseHeadersForSpans = (headers) => {
-		const results = [];
-		for (let i = 0; i < headers.length; i++) {
-			const header = headers[i];
-			if (!callMemoOrStaticFn(header.column, "getIsVisible", column_getIsVisible)) continue;
-			let colSpan = 0;
-			let minChildRowSpan = Infinity;
-			if (header.subHeaders.length) {
-				const childSpans = recurseHeadersForSpans(header.subHeaders);
-				for (let j = 0; j < childSpans.length; j++) {
-					const child = childSpans[j];
-					colSpan += child.colSpan;
-					if (child.rowSpan < minChildRowSpan) minChildRowSpan = child.rowSpan;
-				}
-			} else {
-				colSpan = 1;
-				minChildRowSpan = 0;
-			}
-			header.colSpan = colSpan;
-			header.rowSpan = minChildRowSpan;
-			results.push({
-				colSpan,
-				rowSpan: header.rowSpan
-			});
-		}
-		return results;
-	};
-	recurseHeadersForSpans(((_headerGroups$ = headerGroups[0]) === null || _headerGroups$ === void 0 ? void 0 : _headerGroups$.headers) ?? []);
+	updateHeaderSpans(headerGroups[0]?.headers ?? []);
 	return headerGroups;
 }
 
 //#endregion
-export { buildHeaderGroups };
-//# sourceMappingURL=buildHeaderGroups.js.map
+export { buildHeaderGroups };

package/dist/core/headers/constructHeader.d.ts

@@ -1,16 +1,15 @@
 import { CellData, RowData } from "../../types/type-utils.js";
 import { Header } from "../../types/Header.js";
 import { Column } from "../../types/Column.js";
+import { Table } from "../../types/Table.js";
 import { TableFeatures } from "../../types/TableFeatures.js";
-import { Table_Internal } from "../../types/Table.js";
-
 //#region src/core/headers/constructHeader.d.ts
 /**
  * Constructs a header instance from normalized table internals.
  *
  * This wires core properties, feature prototype APIs, and instance data used by table rendering and row-model operations.
  */
-declare function constructHeader<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(table: Table_Internal<TFeatures, TData>, column: Column<TFeatures, TData, TValue>, options: {
+declare function constructHeader<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(table: Table<TFeatures, TData>, column: Column<TFeatures, TData, TValue>, options: {
   id?: string;
   isPlaceholder?: boolean;
   placeholderId?: string;
@@ -18,5 +17,4 @@ declare function constructHeader<TFeatures extends TableFeatures, TData extends
   depth: number;
 }): Header<TFeatures, TData, TValue>;
 //#endregion
-export { constructHeader };
-//# sourceMappingURL=constructHeader.d.ts.map
+export { constructHeader };

package/dist/core/headers/constructHeader.js

@@ -7,10 +7,7 @@ function getHeaderPrototype(table) {
 	if (!table._headerPrototype) {
 		table._headerPrototype = { table };
 		const features = Object.values(table._features);
-		for (let i = 0; i < features.length; i++) {
-			var _assignHeaderPrototyp, _ref;
-			(_assignHeaderPrototyp = (_ref = features[i]).assignHeaderPrototype) === null || _assignHeaderPrototyp === void 0 || _assignHeaderPrototyp.call(_ref, table._headerPrototype, table);
-		}
+		for (let i = 0; i < features.length; i++) features[i].assignHeaderPrototype?.(table._headerPrototype, table);
 	}
 	return table._headerPrototype;
 }
@@ -32,9 +29,10 @@ function constructHeader(table, column, options) {
 	header.placeholderId = options.placeholderId;
 	header.rowSpan = 0;
 	header.subHeaders = [];
+	const initFns = table._headerInstanceInitFns;
+	for (let i = 0; i < initFns.length; i++) initFns[i](header);
 	return header;
 }
 
 //#endregion
-export { constructHeader };
-//# sourceMappingURL=constructHeader.js.map
+export { constructHeader };

package/dist/core/headers/coreHeadersFeature.d.ts

@@ -1,10 +1,8 @@
 import { TableFeature } from "../../types/TableFeatures.js";
-
 //#region src/core/headers/coreHeadersFeature.d.ts
 /**
  * Core feature that builds header groups and exposes header context APIs.
  */
 declare const coreHeadersFeature: TableFeature;
 //#endregion
-export { coreHeadersFeature };
-//# sourceMappingURL=coreHeadersFeature.d.ts.map
+export { coreHeadersFeature };

package/dist/core/headers/coreHeadersFeature.js

@@ -22,17 +22,14 @@ const coreHeadersFeature = {
 		assignTableAPIs("coreHeadersFeature", table, {
 			table_getHeaderGroups: {
 				fn: () => table_getHeaderGroups(table),
-				memoDeps: () => {
-					var _table$atoms$columnOr, _table$atoms$grouping, _table$atoms$columnPi, _table$atoms$columnVi;
-					return [
-						table.options.columns,
-						(_table$atoms$columnOr = table.atoms.columnOrder) === null || _table$atoms$columnOr === void 0 ? void 0 : _table$atoms$columnOr.get(),
-						(_table$atoms$grouping = table.atoms.grouping) === null || _table$atoms$grouping === void 0 ? void 0 : _table$atoms$grouping.get(),
-						(_table$atoms$columnPi = table.atoms.columnPinning) === null || _table$atoms$columnPi === void 0 ? void 0 : _table$atoms$columnPi.get(),
-						(_table$atoms$columnVi = table.atoms.columnVisibility) === null || _table$atoms$columnVi === void 0 ? void 0 : _table$atoms$columnVi.get(),
-						table.options.groupedColumnMode
-					];
-				}
+				memoDeps: () => [
+					table.options.columns,
+					table.atoms.columnOrder?.get(),
+					table.atoms.grouping?.get(),
+					table.atoms.columnPinning?.get(),
+					table.atoms.columnVisibility?.get(),
+					table.options.groupedColumnMode
+				]
 			},
 			table_getFooterGroups: {
 				fn: () => table_getFooterGroups(table),
@@ -51,5 +48,4 @@ const coreHeadersFeature = {
 };
 
 //#endregion
-export { coreHeadersFeature };
-//# sourceMappingURL=coreHeadersFeature.js.map
+export { coreHeadersFeature };

package/dist/core/headers/coreHeadersFeature.types.d.ts

@@ -2,11 +2,10 @@ import { CellData, RowData } from "../../types/type-utils.js";
 import { HeaderGroup } from "../../types/HeaderGroup.js";
 import { Header } from "../../types/Header.js";
 import { Column } from "../../types/Column.js";
-import { TableFeatures } from "../../types/TableFeatures.js";
 import { Table } from "../../types/Table.js";
-
+import { TableFeatures } from "../../types/TableFeatures.js";
 //#region src/core/headers/coreHeadersFeature.types.d.ts
-interface Table_Headers<TFeatures extends TableFeatures, TData extends RowData> {
+interface Table_Headers<in out TFeatures extends TableFeatures, in out TData extends RowData> {
   /**
    * Builds the visible header groups for the current column tree, visibility,
    * and pinning state.
@@ -26,7 +25,7 @@ interface Table_Headers<TFeatures extends TableFeatures, TData extends RowData>
    */
   getLeafHeaders: () => Array<Header<TFeatures, TData, unknown>>;
 }
-interface HeaderContext<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData> {
+interface HeaderContext<in out TFeatures extends TableFeatures, in out TData extends RowData, TValue extends CellData = CellData> {
   /**
    * An instance of a column.
    */
@@ -40,7 +39,7 @@ interface HeaderContext<TFeatures extends TableFeatures, TData extends RowData,
    */
   table: Table<TFeatures, TData>;
 }
-interface Header_CoreProperties<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData> {
+interface Header_CoreProperties<in out TFeatures extends TableFeatures, in out TData extends RowData, TValue extends CellData = CellData> {
   /**
    * The col-span for the header.
    */
@@ -50,7 +49,7 @@ interface Header_CoreProperties<TFeatures extends TableFeatures, TData extends R
    */
   column: Column<TFeatures, TData, TValue>;
   /**
-   * The depth of the header, zero-indexed based.
+   * The depth of the header, zero-indexed.
    */
   depth: number;
   /**
@@ -66,7 +65,11 @@ interface Header_CoreProperties<TFeatures extends TableFeatures, TData extends R
    */
   index: number;
   /**
-   * A boolean denoting if the header is a placeholder header.
+   * A boolean denoting if the header is a placeholder header. Placeholder
+   * headers fill the rows above a shallow leaf column's real header so that
+   * every header group row accounts for every visible column. Render them as
+   * empty cells, or use `header.rowSpan` to merge each chain of placeholders
+   * into one vertically spanning header cell.
    */
   isPlaceholder: boolean;
   /**
@@ -74,7 +77,15 @@ interface Header_CoreProperties<TFeatures extends TableFeatures, TData extends R
    */
   placeholderId?: string;
   /**
-   * The row-span for the header.
+   * The number of header group rows the header should span when merging header
+   * cells vertically. A leaf column that is shallower than the deepest leaf
+   * column produces a chain of placeholder headers above its real header; the
+   * placeholder at the top of the chain reports the chain's full span, and
+   * every header it covers (including the real leaf header in the bottom row)
+   * reports 0. To merge vertically, skip headers with a rowSpan of 0 and
+   * render every other header with the `rowSpan` attribute and its column's
+   * header content, even when it is a placeholder. Headers in even column
+   * trees always report 1.
    */
   rowSpan: number;
   /**
@@ -86,7 +97,7 @@ interface Header_CoreProperties<TFeatures extends TableFeatures, TData extends R
    */
   table: Table<TFeatures, TData>;
 }
-interface Header_Header<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData> extends Header_CoreProperties<TFeatures, TData, TValue> {
+interface Header_Header<in out TFeatures extends TableFeatures, in out TData extends RowData, TValue extends CellData = CellData> extends Header_CoreProperties<TFeatures, TData, TValue> {
   /**
    * Returns the rendering context (or props) for column-based components like headers, footers and filters.
    */
@@ -96,11 +107,10 @@ interface Header_Header<TFeatures extends TableFeatures, TData extends RowData,
    */
   getLeafHeaders: () => Array<Header<TFeatures, TData, TValue>>;
 }
-interface HeaderGroup_Header<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData> {
+interface HeaderGroup_Header<in out TFeatures extends TableFeatures, in out TData extends RowData, TValue extends CellData = CellData> {
   depth: number;
   headers: Array<Header<TFeatures, TData, TValue>>;
   id: string;
 }
 //#endregion
-export { HeaderContext, HeaderGroup_Header, Header_CoreProperties, Header_Header, Table_Headers };
-//# sourceMappingURL=coreHeadersFeature.types.d.ts.map
+export { HeaderContext, HeaderGroup_Header, Header_CoreProperties, Header_Header, Table_Headers };

package/dist/core/headers/coreHeadersFeature.utils.d.ts

@@ -2,8 +2,9 @@ import { RowData } from "../../types/type-utils.js";
 import { HeaderGroup } from "../../types/HeaderGroup.js";
 import { Header } from "../../types/Header.js";
 import { Column } from "../../types/Column.js";
+import { Table } from "../../types/Table.js";
 import { TableFeatures } from "../../types/TableFeatures.js";
-import { Table_Internal } from "../../types/Table.js";
+import "../../index.js";
 //#region src/core/headers/coreHeadersFeature.utils.d.ts
 /**
  * Walks a header tree and collects all descendant leaf headers.
@@ -30,7 +31,7 @@ declare function header_getLeafHeaders<TFeatures extends TableFeatures, TData ex
 declare function header_getContext<TFeatures extends TableFeatures, TData extends RowData, TValue>(header: Header<TFeatures, TData, TValue>): {
   column: Column<TFeatures, TData, TValue>;
   header: Header<TFeatures, TData, TValue>;
-  table: Table_Internal<TFeatures, TData>;
+  table: Table<TFeatures, TData>;
 };
 /**
  * Builds visible header groups for the current column tree.
@@ -43,7 +44,7 @@ declare function header_getContext<TFeatures extends TableFeatures, TData extend
  * const headerGroups = table_getHeaderGroups(table)
  * ```
  */
-declare function table_getHeaderGroups<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): HeaderGroup<TFeatures, TData>[];
+declare function table_getHeaderGroups<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>): HeaderGroup<TFeatures, TData>[];
 /**
  * Builds footer groups by reversing the current header groups.
  *
@@ -55,7 +56,7 @@ declare function table_getHeaderGroups<TFeatures extends TableFeatures, TData ex
  * const footerGroups = table_getFooterGroups(table)
  * ```
  */
-declare function table_getFooterGroups<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): HeaderGroup<TFeatures, TData>[];
+declare function table_getFooterGroups<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>): HeaderGroup<TFeatures, TData>[];
 /**
  * Flattens every header from every header group into one array.
  *
@@ -67,7 +68,7 @@ declare function table_getFooterGroups<TFeatures extends TableFeatures, TData ex
  * const flatHeaders = table_getFlatHeaders(table)
  * ```
  */
-declare function table_getFlatHeaders<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): Header<TFeatures, TData, unknown>[];
+declare function table_getFlatHeaders<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>): Header<TFeatures, TData, unknown>[];
 /**
  * Collects only the leaf headers from the current header tree.
  *
@@ -79,7 +80,6 @@ declare function table_getFlatHeaders<TFeatures extends TableFeatures, TData ext
  * const leafHeaders = table_getLeafHeaders(table)
  * ```
  */
-declare function table_getLeafHeaders<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): Header<TFeatures, TData, unknown>[];
+declare function table_getLeafHeaders<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>): Header<TFeatures, TData, unknown>[];
 //#endregion
-export { header_getContext, header_getLeafHeaders, table_getFlatHeaders, table_getFooterGroups, table_getHeaderGroups, table_getLeafHeaders };
-//# sourceMappingURL=coreHeadersFeature.utils.d.ts.map
+export { header_getContext, header_getLeafHeaders, table_getFlatHeaders, table_getFooterGroups, table_getHeaderGroups, table_getLeafHeaders };

package/dist/core/headers/coreHeadersFeature.utils.js

@@ -4,6 +4,10 @@ import { buildHeaderGroups } from "./buildHeaderGroups.js";
 import { getDefaultColumnPinningState } from "../../features/column-pinning/columnPinningFeature.utils.js";
 
 //#region src/core/headers/coreHeadersFeature.utils.ts
+function collectLeafHeaders(header, leafHeaders) {
+	for (let i = 0; i < header.subHeaders.length; i++) collectLeafHeaders(header.subHeaders[i], leafHeaders);
+	leafHeaders.push(header);
+}
 /**
 * Walks a header tree and collects all descendant leaf headers.
 *
@@ -17,11 +21,7 @@ import { getDefaultColumnPinningState } from "../../features/column-pinning/colu
 */
 function header_getLeafHeaders(header) {
 	const leafHeaders = [];
-	const recurseHeader = (h) => {
-		if (h.subHeaders.length) h.subHeaders.map(recurseHeader);
-		leafHeaders.push(h);
-	};
-	recurseHeader(header);
+	collectLeafHeaders(header, leafHeaders);
 	return leafHeaders;
 }
 /**
@@ -53,23 +53,22 @@ function header_getContext(header) {
 * ```
 */
 function table_getHeaderGroups(table) {
-	var _table$atoms$columnPi;
-	const { left, right } = ((_table$atoms$columnPi = table.atoms.columnPinning) === null || _table$atoms$columnPi === void 0 ? void 0 : _table$atoms$columnPi.get()) ?? getDefaultColumnPinningState();
+	const { start, end } = table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState();
 	const allColumns = table.getAllColumns();
 	const leafColumns = callMemoOrStaticFn(table, "getVisibleLeafColumns", table_getVisibleLeafColumns);
-	if (!left.length && !right.length) return buildHeaderGroups(allColumns, leafColumns, table);
+	if (!start.length && !end.length) return buildHeaderGroups(allColumns, leafColumns, table);
 	const leafColumnsById = table.getAllLeafColumnsById();
 	const leftColumns = [];
-	for (let i = 0; i < left.length; i++) {
-		const column = leafColumnsById[left[i]];
+	for (let i = 0; i < start.length; i++) {
+		const column = leafColumnsById[start[i]];
 		if (column && callMemoOrStaticFn(column, "getIsVisible", column_getIsVisible)) leftColumns.push(column);
 	}
 	const rightColumns = [];
-	for (let i = 0; i < right.length; i++) {
-		const column = leafColumnsById[right[i]];
+	for (let i = 0; i < end.length; i++) {
+		const column = leafColumnsById[end[i]];
 		if (column && callMemoOrStaticFn(column, "getIsVisible", column_getIsVisible)) rightColumns.push(column);
 	}
-	const centerColumns = leafColumns.filter((column) => !left.includes(column.id) && !right.includes(column.id));
+	const centerColumns = leafColumns.filter((column) => !start.includes(column.id) && !end.includes(column.id));
 	return buildHeaderGroups(allColumns, [
 		...leftColumns,
 		...centerColumns,
@@ -122,8 +121,7 @@ function table_getFlatHeaders(table) {
 * ```
 */
 function table_getLeafHeaders(table) {
-	var _table$getHeaderGroup;
-	const topHeaders = ((_table$getHeaderGroup = table.getHeaderGroups()[0]) === null || _table$getHeaderGroup === void 0 ? void 0 : _table$getHeaderGroup.headers) ?? [];
+	const topHeaders = table.getHeaderGroups()[0]?.headers ?? [];
 	const result = [];
 	for (let i = 0; i < topHeaders.length; i++) {
 		const leafHeaders = topHeaders[i].getLeafHeaders();
@@ -133,5 +131,4 @@ function table_getLeafHeaders(table) {
 }
 
 //#endregion
-export { header_getContext, header_getLeafHeaders, table_getFlatHeaders, table_getFooterGroups, table_getHeaderGroups, table_getLeafHeaders };
-//# sourceMappingURL=coreHeadersFeature.utils.js.map
+export { header_getContext, header_getLeafHeaders, table_getFlatHeaders, table_getFooterGroups, table_getHeaderGroups, table_getLeafHeaders };

package/dist/core/reactivity/coreReactivityFeature.types.d.ts

@@ -1,5 +1,4 @@
 import { Atom, AtomOptions, ReadonlyAtom, Subscription } from "@tanstack/store";
-
 //#region src/core/reactivity/coreReactivityFeature.types.d.ts
 interface TableAtomOptions<T> extends AtomOptions<T> {
   /**
@@ -17,6 +16,13 @@ interface TableAtomOptions<T> extends AtomOptions<T> {
 interface TableReactivityBindings {
   createOptionsStore: boolean;
   wrapExternalAtoms: boolean;
+  /**
+   * Invalidates readonly atoms whose compute reads non-reactive inputs (plain
+   * options). Render-phase adapters call this after publishing captured
+   * controlled state from a host commit, including when no base atom changed,
+   * so controlled ownership changes still reach subscribers.
+   */
+  commit?: () => void;
   addSubscription: (subscription: Subscription) => void;
   /**
    * Creates a writable atom with an initial value.
@@ -44,5 +50,4 @@ interface TableReactivityBindings {
   unmount?: () => void;
 }
 //#endregion
-export { TableAtomOptions, TableReactivityBindings };
-//# sourceMappingURL=coreReactivityFeature.types.d.ts.map
+export { TableAtomOptions, TableReactivityBindings };

package/dist/core/reactivity/coreReactivityFeature.utils.d.ts

@@ -1,5 +1,4 @@
 import { Atom, ReadonlyAtom, ReadonlyStore, Store } from "@tanstack/store";
-
 //#region src/core/reactivity/coreReactivityFeature.utils.d.ts
 /**
  * Converts a writable atom to the store-compatible shape expected by core.
@@ -20,5 +19,4 @@ declare function atomToStore<T>(atom: Atom<T>): Store<T>;
  */
 declare function atomToStore<T>(atom: ReadonlyAtom<T>): ReadonlyStore<T>;
 //#endregion
-export { atomToStore };
-//# sourceMappingURL=coreReactivityFeature.utils.d.ts.map
+export { atomToStore };

package/dist/core/reactivity/coreReactivityFeature.utils.js

@@ -19,5 +19,4 @@ function atomToStore(atom) {
 }
 
 //#endregion
-export { atomToStore };
-//# sourceMappingURL=coreReactivityFeature.utils.js.map
+export { atomToStore };

package/dist/core/reactivity/renderPhaseReactivity.d.ts

@@ -0,0 +1,80 @@
+import { TableReactivityBindings } from "./coreReactivityFeature.types.js";
+import { Atom, AtomOptions, ReadonlyAtom } from "@tanstack/store";
+//#region src/core/reactivity/renderPhaseReactivity.d.ts
+/**
+ * Reactivity bindings for adapters whose options are plain values synchronized
+ * during the host framework's render phase, with a guaranteed `commit` hook.
+ */
+interface RenderPhaseReactivityBindings extends TableReactivityBindings {
+  commit: () => void;
+}
+/**
+ * Store primitives supplied by the adapter.
+ *
+ * They MUST come from the adapter's own store package (e.g.
+ * `@tanstack/react-store`) rather than table-core's copy: dependency tracking
+ * and batching share module-global state, so atoms created here must live in
+ * the same store instance as user-provided external atoms and adapter
+ * subscriptions.
+ */
+interface RenderPhaseReactivityPrimitives {
+  createAtom: {
+    <T>(getValue: (prev?: T) => T, options?: AtomOptions<T>): ReadonlyAtom<T>;
+    <T>(initialValue: T, options?: AtomOptions<T>): Atom<T>;
+  };
+  batch: (fn: () => void) => void;
+  /**
+   * Overrides the deferred-scheduling primitive (defaults to
+   * `queueMicrotask`).
+   */
+  schedule?: (fn: () => void) => void;
+}
+/**
+ * Creates reactivity bindings for render-phase adapters (React, Preact, Lit):
+ * frameworks with plain, non-reactive options that are re-synchronized during
+ * component render, where store notifications must not fire until the host
+ * commits.
+ *
+ * Readonly atoms are exposed as live facades. `get()` re-evaluates the
+ * resolver against the options of the render in progress — a normal computed
+ * cannot know that plain `options.state` changed — and caches the result
+ * through the configured comparator so external-store consumers (e.g. React's
+ * `useSyncExternalStore`) see referentially stable snapshots. `subscribe()`
+ * goes through a hidden computed that tracks the resolver's real atom
+ * dependencies plus a commit version, so subscribers are invalidated by
+ * actual reactive writes and by the adapter's post-commit publication.
+ *
+ * @example
+ * ```ts
+ * import { batch, createAtom } from '@tanstack/react-store'
+ *
+ * export const reactReactivity = () =>
+ *   renderPhaseReactivity({ createAtom, batch })
+ * ```
+ */
+declare function renderPhaseReactivity(primitives: RenderPhaseReactivityPrimitives): RenderPhaseReactivityBindings;
+type SelectionSource<T> = {
+  get: () => T;
+  subscribe: (listener: (value: T) => void) => {
+    unsubscribe: () => void;
+  };
+};
+interface RenderPhaseSource<T> extends SelectionSource<T> {
+  /**
+   * Records the snapshot observed by a render that actually committed.
+   */
+  markCommitted: (snapshot: T) => void;
+}
+/**
+ * Creates a render-phase source with an explicit commit baseline.
+ *
+ * Render-phase adapters publish controlled state after the host framework
+ * commits so isolated subscribers update, but the component that owns the
+ * table already rendered that exact snapshot — forwarding the notification to
+ * its root subscription would produce a redundant render. Unlike a last-read
+ * filter, speculative reads do not change notification behavior: only
+ * `markCommitted()` advances the baseline.
+ */
+declare function createRenderPhaseSource<T>(source: SelectionSource<T>, compare?: (committed: T, published: T) => boolean): RenderPhaseSource<T>;
+//#endregion
+export { RenderPhaseReactivityBindings, RenderPhaseReactivityPrimitives, RenderPhaseSource, createRenderPhaseSource, renderPhaseReactivity };