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

package/dist/features/row-sorting/rowSortingFeature.utils.js

@@ -1,5 +1,5 @@
 import { cloneState, isFunction } from "../../utils.js";
-import { reSplitAlphaNumeric, sortFn_basic } from "../../fns/sortFns.js";
+import { reSplitAlphaNumeric, sortFn_basic } from "./sortFns.js";
 
 //#region src/features/row-sorting/rowSortingFeature.utils.ts
 /**
@@ -28,8 +28,7 @@ function getDefaultSortingState() {
 * ```
 */
 function table_setSorting(table, updater) {
-	var _table$options$onSort, _table$options;
-	(_table$options$onSort = (_table$options = table.options).onSortingChange) === null || _table$options$onSort === void 0 || _table$options$onSort.call(_table$options, updater);
+	table.options.onSortingChange?.(updater);
 }
 /**
 * Resets `sorting` to the configured initial state or feature default.
@@ -47,6 +46,21 @@ function table_resetSorting(table, defaultState) {
 	table_setSorting(table, defaultState ? [] : cloneState(table.initialState.sorting ?? []));
 }
 /**
+* Resets sorting after the table data changes when explicitly enabled.
+*
+* Unlike other auto-reset behaviors, sorting is preserved by default. An
+* explicit `autoResetAll` value takes precedence over `autoResetSorting`.
+*
+* @example
+* ```ts
+* table_autoResetSorting(table)
+* ```
+*/
+function table_autoResetSorting(table) {
+	if (!table.atoms.sorting) return;
+	if (table.options.autoResetAll ?? table.options.autoResetSorting ?? false) table_resetSorting(table);
+}
+/**
 * Chooses a built-in sorting function from sampled filtered row values.
 *
 * Date-like values use `datetime`, mixed text/numeric strings use
@@ -61,27 +75,41 @@ function table_resetSorting(table, defaultState) {
 function column_getAutoSortFn(column) {
 	const sortFns = column.table._rowModelFns.sortFns;
 	const firstRows = column.table.getFilteredRowModel().flatRows.slice(0, 10);
+	let sortFnName;
 	let isString = false;
 	for (let i = 0; i < firstRows.length; i++) {
 		const value = firstRows[i].getValue(column.id);
 		if (Object.prototype.toString.call(value) === "[object Date]") {
-			if (sortFns === null || sortFns === void 0 ? void 0 : sortFns.datetime) return sortFns.datetime;
+			sortFnName = "datetime";
+			break;
 		}
 		if (typeof value === "string") {
 			isString = true;
 			if (value.split(reSplitAlphaNumeric).length > 1) {
-				if (sortFns === null || sortFns === void 0 ? void 0 : sortFns.alphanumeric) return sortFns.alphanumeric;
+				sortFnName = "alphanumeric";
+				break;
 			}
 		}
 	}
-	if (isString) return (sortFns === null || sortFns === void 0 ? void 0 : sortFns.text) ?? sortFn_basic;
+	if (!sortFnName && isString) sortFnName = "text";
+	if (sortFnName) {
+		let sortFn = sortFns?.[sortFnName];
+		if (!sortFn) {
+			if (process.env.NODE_ENV === "development") console.warn(`sortFn '${sortFnName}' (auto) for column '${column.id}' is not registered`);
+			if (sortFnName === "alphanumeric") sortFn = sortFns?.text;
+		}
+		if (sortFn) return sortFn;
+	}
 	return sortFn_basic;
 }
 /**
-* Chooses the default first sort direction from the first filtered row value.
+* Chooses the default first sort direction from sampled filtered row values.
 *
-* String columns start ascending so alphabetical order is natural; other value
-* types start descending.
+* The first non-nullish value among the sampled rows decides: string columns
+* start ascending so alphabetical order is natural; other value types (or
+* columns with no non-nullish sample) start descending. Sampling past leading
+* nullish values keeps the toggle cycle stable when sorting or a data swap
+* moves an empty value into the first row.
 *
 * @example
 * ```ts
@@ -89,8 +117,12 @@ function column_getAutoSortFn(column) {
 * ```
 */
 function column_getAutoSortDir(column) {
-	const firstRow = column.table.getFilteredRowModel().flatRows[0];
-	if (typeof (firstRow ? firstRow.getValue(column.id) : void 0) === "string") return "asc";
+	const firstRows = column.table.getFilteredRowModel().flatRows.slice(0, 10);
+	for (let i = 0; i < firstRows.length; i++) {
+		const value = firstRows[i].getValue(column.id);
+		if (value == null) continue;
+		return typeof value === "string" ? "asc" : "desc";
+	}
 	return "desc";
 }
 /**
@@ -107,14 +139,18 @@ function column_getAutoSortDir(column) {
 */
 function column_getSortFn(column) {
 	const sortFns = column.table._rowModelFns.sortFns;
-	return isFunction(column.columnDef.sortFn) ? column.columnDef.sortFn : column.columnDef.sortFn === "auto" ? column_getAutoSortFn(column) : (sortFns === null || sortFns === void 0 ? void 0 : sortFns[column.columnDef.sortFn]) ?? sortFn_basic;
+	if (isFunction(column.columnDef.sortFn)) return column.columnDef.sortFn;
+	if (column.columnDef.sortFn === "auto") return column_getAutoSortFn(column);
+	const sortFn = sortFns?.[column.columnDef.sortFn];
+	if (process.env.NODE_ENV === "development" && !sortFn) console.warn(`sortFn '${String(column.columnDef.sortFn)}' for column '${column.id}' is not registered`);
+	return sortFn ?? sortFn_basic;
 }
 /**
 * Applies the next sorting state for this column.
 *
 * The toggle can add, replace, flip, or remove this column's sort entry. Multi
-* sorting respects `enableMultiSort`, `maxMultiSortColCount`, and the `multi`
-* argument.
+* sorting respects `enableMultiSort`, `enableMultiRemove`,
+* `maxMultiSortColCount`, and the `multi` argument.
 *
 * @example
 * ```ts
@@ -122,17 +158,17 @@ function column_getSortFn(column) {
 * ```
 */
 function column_toggleSorting(column, desc, multi) {
-	const nextSortingOrder = column_getNextSortingOrder(column);
+	const nextSortingOrder = column_getNextSortingOrder(column, multi && column_getCanMultiSort(column));
 	const hasManualValue = typeof desc !== "undefined";
 	table_setSorting(column.table, (old) => {
-		const existingSorting = old.find((d) => d.id === column.id);
 		const existingIndex = old.findIndex((d) => d.id === column.id);
+		const existingSorting = existingIndex === -1 ? void 0 : old[existingIndex];
 		let newSorting = [];
 		let sortAction;
 		const nextDesc = hasManualValue ? desc : nextSortingOrder === "desc";
-		if (old.length && column_getCanMultiSort(column) && multi) if (existingSorting) sortAction = "toggle";
+		const isMultiMode = !!(old.length && column_getCanMultiSort(column) && multi);
+		if (isMultiMode) if (existingSorting) sortAction = "toggle";
 		else sortAction = "add";
-		else if (old.length && existingIndex !== old.length - 1) sortAction = "replace";
 		else if (existingSorting) sortAction = "toggle";
 		else sortAction = "replace";
 		if (sortAction === "toggle") {
@@ -146,14 +182,17 @@ function column_toggleSorting(column, desc, multi) {
 				desc: nextDesc
 			}];
 			newSorting.splice(0, newSorting.length - (column.table.options.maxMultiSortColCount ?? Number.MAX_SAFE_INTEGER));
-		} else if (sortAction === "toggle") newSorting = old.map((d) => {
+		} else if (sortAction === "toggle") newSorting = isMultiMode ? old.map((d) => {
 			if (d.id === column.id) return {
 				...d,
 				desc: nextDesc
 			};
 			return d;
-		});
-		else if (sortAction === "remove") newSorting = old.filter((d) => d.id !== column.id);
+		}) : [{
+			id: column.id,
+			desc: nextDesc
+		}];
+		else if (sortAction === "remove") newSorting = isMultiMode ? old.filter((d) => d.id !== column.id) : [];
 		else newSorting = [{
 			id: column.id,
 			desc: nextDesc
@@ -233,8 +272,7 @@ function column_getCanMultiSort(column) {
 * ```
 */
 function column_getIsSorted(column) {
-	var _column$table$atoms$s;
-	const columnSort = (_column$table$atoms$s = column.table.atoms.sorting) === null || _column$table$atoms$s === void 0 || (_column$table$atoms$s = _column$table$atoms$s.get()) === null || _column$table$atoms$s === void 0 ? void 0 : _column$table$atoms$s.find((d) => d.id === column.id);
+	const columnSort = column.table.atoms.sorting?.get()?.find((d) => d.id === column.id);
 	return !columnSort ? false : columnSort.desc ? "desc" : "asc";
 }
 /**
@@ -248,8 +286,7 @@ function column_getIsSorted(column) {
 * ```
 */
 function column_getSortIndex(column) {
-	var _column$table$atoms$s2;
-	return ((_column$table$atoms$s2 = column.table.atoms.sorting) === null || _column$table$atoms$s2 === void 0 || (_column$table$atoms$s2 = _column$table$atoms$s2.get()) === null || _column$table$atoms$s2 === void 0 ? void 0 : _column$table$atoms$s2.findIndex((d) => d.id === column.id)) ?? -1;
+	return column.table.atoms.sorting?.get()?.findIndex((d) => d.id === column.id) ?? -1;
 }
 /**
 * Removes this column from the sorting state.
@@ -267,9 +304,8 @@ function column_clearSorting(column) {
 /**
 * Creates a header event handler that toggles this column's sorting.
 *
-* The handler ignores events when the column cannot sort, persists React-style
-* synthetic events when present, and asks `options.isMultiSortEvent` whether
-* the event should add to a multi-sort.
+* The handler ignores events when the column cannot sort, and asks
+* `options.isMultiSortEvent` whether the event should add to a multi-sort.
 *
 * @example
 * ```ts
@@ -279,13 +315,10 @@ function column_clearSorting(column) {
 function column_getToggleSortingHandler(column) {
 	const canSort = column_getCanSort(column);
 	return (e) => {
-		var _persist, _column$table$options, _column$table$options2;
 		if (!canSort) return;
-		(_persist = e.persist) === null || _persist === void 0 || _persist.call(e);
-		column_toggleSorting(column, void 0, column_getCanMultiSort(column) ? (_column$table$options = (_column$table$options2 = column.table.options).isMultiSortEvent) === null || _column$table$options === void 0 ? void 0 : _column$table$options.call(_column$table$options2, e) : false);
+		column_toggleSorting(column, void 0, column_getCanMultiSort(column) ? column.table.options.isMultiSortEvent?.(e) : false);
 	};
 }
 
 //#endregion
-export { column_clearSorting, column_getAutoSortDir, column_getAutoSortFn, column_getCanMultiSort, column_getCanSort, column_getFirstSortDir, column_getIsSorted, column_getNextSortingOrder, column_getSortFn, column_getSortIndex, column_getToggleSortingHandler, column_toggleSorting, getDefaultSortingState, table_resetSorting, table_setSorting };
-//# sourceMappingURL=rowSortingFeature.utils.js.map
+export { column_clearSorting, column_getAutoSortDir, column_getAutoSortFn, column_getCanMultiSort, column_getCanSort, column_getFirstSortDir, column_getIsSorted, column_getNextSortingOrder, column_getSortFn, column_getSortIndex, column_getToggleSortingHandler, column_toggleSorting, getDefaultSortingState, table_autoResetSorting, table_resetSorting, table_setSorting };

package/dist/features/row-sorting/sortFns.d.ts

@@ -0,0 +1,96 @@
+import { RowData } from "../../types/type-utils.js";
+import { CreatedSortFn, SortFnDef } from "./rowSortingFeature.types.js";
+import { TableFeatures } from "../../types/TableFeatures.js";
+//#region src/features/row-sorting/sortFns.d.ts
+/**
+ * Regular expression used to split mixed text and numeric chunks.
+ *
+ * The alphanumeric sort functions use these chunks for natural sorting of
+ * strings like `item2` before `item10`.
+ */
+declare const reSplitAlphaNumeric: RegExp;
+/**
+ * Builds a `SortFn` from a value-level comparator plus an optional
+ * `resolveDataValue` normalizer.
+ *
+ * The `sort` comparator receives both rows' data values, each already passed
+ * through `resolveDataValue` when one is defined. Keeping normalization in the
+ * resolver means a variant of an existing sorting function only has to swap
+ * the resolver, not re-implement the comparison.
+ *
+ * The definition is attached to the returned function, so a variant can be
+ * created by spreading a built-in sorting function and overriding what
+ * differs:
+ *
+ * ```ts
+ * const stripDiacritics = (value: string) =>
+ *   value.normalize('NFD').replace(/\p{Diacritic}/gu, '')
+ *
+ * const alphanumericIgnoreDiacritics = constructSortFn({
+ *   ...sortFn_alphanumeric,
+ *   resolveDataValue: (value) =>
+ *     stripDiacritics(sortFn_alphanumeric.resolveDataValue!(value)),
+ * })
+ * ```
+ */
+declare function constructSortFn<TFeatures extends TableFeatures = any, TData extends RowData = any>(def: SortFnDef<TFeatures, TData>): CreatedSortFn<TFeatures, TData>;
+/**
+ * Sorts rows with the built-in alphanumeric strategy.
+ *
+ * This comparator returns ascending-order results; descending order is applied by the sorting row model.
+ */
+declare const sortFn_alphanumeric: CreatedSortFn<any, any>;
+/**
+ * Sorts rows with the built-in alphanumeric case sensitive strategy.
+ *
+ * This comparator returns ascending-order results; descending order is applied by the sorting row model.
+ */
+declare const sortFn_alphanumericCaseSensitive: CreatedSortFn<any, any>;
+/**
+ * Sorts rows with the built-in text strategy.
+ *
+ * This comparator returns ascending-order results; descending order is applied by the sorting row model.
+ */
+declare const sortFn_text: CreatedSortFn<any, any>;
+/**
+ * Sorts rows with the built-in text case sensitive strategy.
+ *
+ * This comparator returns ascending-order results; descending order is applied by the sorting row model.
+ */
+declare const sortFn_textCaseSensitive: CreatedSortFn<any, any>;
+/**
+ * Sorts rows with the built-in datetime strategy.
+ *
+ * This comparator returns ascending-order results; descending order is applied by the sorting row model.
+ */
+declare const sortFn_datetime: CreatedSortFn<any, any>;
+/**
+ * Sorts rows with the built-in basic strategy.
+ *
+ * This comparator returns ascending-order results; descending order is applied by the sorting row model.
+ */
+declare const sortFn_basic: CreatedSortFn<any, any>;
+/**
+ * The built-in sorting function registry.
+ *
+ * Registering this full object opts out of tree-shaking: every built-in
+ * sorting function ends up in your bundle. Prefer importing the `sortFn_*`
+ * functions you actually use and registering just those in the `sortFns`
+ * slot, or passing them directly to the `sortFn` column option.
+ *
+ * @deprecated Import individual `sortFn_*` functions instead for a smaller
+ * bundle. This export still works and is not going away in v9, but built-in
+ * name resolution (including `sortFn: 'auto'`) only finds functions you
+ * register yourself.
+ */
+declare const sortFns: {
+  alphanumeric: CreatedSortFn<any, any>;
+  alphanumericCaseSensitive: CreatedSortFn<any, any>;
+  basic: CreatedSortFn<any, any>;
+  datetime: CreatedSortFn<any, any>;
+  text: CreatedSortFn<any, any>;
+  textCaseSensitive: CreatedSortFn<any, any>;
+};
+type BuiltInSortFn = keyof typeof sortFns;
+//#endregion
+export { BuiltInSortFn, constructSortFn, reSplitAlphaNumeric, sortFn_alphanumeric, sortFn_alphanumericCaseSensitive, sortFn_basic, sortFn_datetime, sortFn_text, sortFn_textCaseSensitive, sortFns };

package/dist/features/row-sorting/sortFns.js

@@ -0,0 +1,216 @@
+//#region src/features/row-sorting/sortFns.ts
+/**
+* Regular expression used to split mixed text and numeric chunks.
+*
+* The alphanumeric sort functions use these chunks for natural sorting of
+* strings like `item2` before `item10`.
+*/
+const reSplitAlphaNumeric = /([0-9]+)/gm;
+/**
+* Builds a `SortFn` from a value-level comparator plus an optional
+* `resolveDataValue` normalizer.
+*
+* The `sort` comparator receives both rows' data values, each already passed
+* through `resolveDataValue` when one is defined. Keeping normalization in the
+* resolver means a variant of an existing sorting function only has to swap
+* the resolver, not re-implement the comparison.
+*
+* The definition is attached to the returned function, so a variant can be
+* created by spreading a built-in sorting function and overriding what
+* differs:
+*
+* ```ts
+* const stripDiacritics = (value: string) =>
+*   value.normalize('NFD').replace(/\p{Diacritic}/gu, '')
+*
+* const alphanumericIgnoreDiacritics = constructSortFn({
+*   ...sortFn_alphanumeric,
+*   resolveDataValue: (value) =>
+*     stripDiacritics(sortFn_alphanumeric.resolveDataValue!(value)),
+* })
+* ```
+*/
+function constructSortFn(def) {
+	const sortFn = Object.assign((rowA, rowB, columnId) => {
+		let dataValueA = rowA.getValue(columnId);
+		let dataValueB = rowB.getValue(columnId);
+		const resolveDataValue = sortFn.resolveDataValue;
+		if (resolveDataValue) {
+			dataValueA = resolveDataValue(dataValueA);
+			dataValueB = resolveDataValue(dataValueB);
+		}
+		return sortFn.sort(dataValueA, dataValueB, rowA, rowB, columnId);
+	}, def);
+	return sortFn;
+}
+/**
+* Sorts rows with the built-in alphanumeric strategy.
+*
+* This comparator returns ascending-order results; descending order is applied by the sorting row model.
+*/
+const sortFn_alphanumeric = constructSortFn({
+	resolveDataValue: (dataValue) => toString(dataValue).toLowerCase(),
+	sort: (dataValueA, dataValueB) => compareAlphanumeric(dataValueA, dataValueB)
+});
+/**
+* Sorts rows with the built-in alphanumeric case sensitive strategy.
+*
+* This comparator returns ascending-order results; descending order is applied by the sorting row model.
+*/
+const sortFn_alphanumericCaseSensitive = constructSortFn({
+	resolveDataValue: (dataValue) => toString(dataValue),
+	sort: (dataValueA, dataValueB) => compareAlphanumeric(dataValueA, dataValueB)
+});
+/**
+* Sorts rows with the built-in text strategy.
+*
+* This comparator returns ascending-order results; descending order is applied by the sorting row model.
+*/
+const sortFn_text = constructSortFn({
+	resolveDataValue: (dataValue) => toString(dataValue).toLowerCase(),
+	sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB)
+});
+/**
+* Sorts rows with the built-in text case sensitive strategy.
+*
+* This comparator returns ascending-order results; descending order is applied by the sorting row model.
+*/
+const sortFn_textCaseSensitive = constructSortFn({
+	resolveDataValue: (dataValue) => toString(dataValue),
+	sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB)
+});
+/**
+* Sorts rows with the built-in datetime strategy.
+*
+* This comparator returns ascending-order results; descending order is applied by the sorting row model.
+*/
+const sortFn_datetime = constructSortFn({
+	resolveDataValue: (dataValue) => toDateSortValue(dataValue),
+	sort: (dataValueA, dataValueB) => dataValueA > dataValueB ? 1 : dataValueA < dataValueB ? -1 : 0
+});
+/**
+* Sorts rows with the built-in basic strategy.
+*
+* This comparator returns ascending-order results; descending order is applied by the sorting row model.
+*/
+const sortFn_basic = constructSortFn({ sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB) });
+function compareBasic(a, b) {
+	return a === b ? 0 : a > b ? 1 : -1;
+}
+function toDateSortValue(value) {
+	return value instanceof Date ? value.getTime() : value;
+}
+function toString(a) {
+	if (typeof a === "number") {
+		if (isNaN(a) || a === Infinity || a === -Infinity) return "";
+		return String(a);
+	}
+	if (typeof a === "string") return a;
+	return "";
+}
+function compareAlphanumeric(aStr, bStr) {
+	let ai = 0;
+	let bi = 0;
+	const aLen = aStr.length;
+	const bLen = bStr.length;
+	while (ai < aLen && bi < bLen) {
+		const aIsNumeric = isDigit(aStr.charCodeAt(ai));
+		const bIsNumeric = isDigit(bStr.charCodeAt(bi));
+		const aEnd = findChunkEnd(aStr, ai, aIsNumeric);
+		const bEnd = findChunkEnd(bStr, bi, bIsNumeric);
+		if (!aIsNumeric && !bIsNumeric) {
+			const stringComparison = compareStringChunks(aStr, ai, aEnd, bStr, bi, bEnd);
+			if (stringComparison) return stringComparison;
+			ai = aEnd;
+			bi = bEnd;
+			continue;
+		}
+		if (aIsNumeric !== bIsNumeric) return aIsNumeric ? 1 : -1;
+		const numericComparison = compareNumericChunks(aStr, ai, aEnd, bStr, bi, bEnd);
+		if (numericComparison) return numericComparison;
+		ai = aEnd;
+		bi = bEnd;
+	}
+	return countRemainingChunks(aStr, ai) - countRemainingChunks(bStr, bi);
+}
+function isDigit(charCode) {
+	return charCode >= 48 && charCode <= 57;
+}
+function findChunkEnd(str, start, isNumeric) {
+	let end = start + 1;
+	while (end < str.length && isDigit(str.charCodeAt(end)) === isNumeric) end++;
+	return end;
+}
+function compareStringChunks(aStr, aStart, aEnd, bStr, bStart, bEnd) {
+	const aLength = aEnd - aStart;
+	const bLength = bEnd - bStart;
+	const minLength = aLength < bLength ? aLength : bLength;
+	for (let i = 0; i < minLength; i++) {
+		const aCode = aStr.charCodeAt(aStart + i);
+		const bCode = bStr.charCodeAt(bStart + i);
+		if (aCode > bCode) return 1;
+		if (bCode > aCode) return -1;
+	}
+	if (aLength > bLength) return 1;
+	if (bLength > aLength) return -1;
+	return 0;
+}
+function compareNumericChunks(aStr, aStart, aEnd, bStr, bStart, bEnd) {
+	let aSignificantStart = aStart;
+	while (aSignificantStart < aEnd && aStr.charCodeAt(aSignificantStart) === 48) aSignificantStart++;
+	let bSignificantStart = bStart;
+	while (bSignificantStart < bEnd && bStr.charCodeAt(bSignificantStart) === 48) bSignificantStart++;
+	const aSignificantLength = aEnd - aSignificantStart;
+	const bSignificantLength = bEnd - bSignificantStart;
+	if (aSignificantLength === 0 && bSignificantLength === 0) return 0;
+	if (aSignificantLength <= 15 && bSignificantLength <= 15) {
+		const an = parseSmallInt(aStr, aSignificantStart, aEnd);
+		const bn = parseSmallInt(bStr, bSignificantStart, bEnd);
+		if (an > bn) return 1;
+		if (bn > an) return -1;
+		return 0;
+	}
+	const an = parseInt(aStr.slice(aStart, aEnd), 10);
+	const bn = parseInt(bStr.slice(bStart, bEnd), 10);
+	if (an > bn) return 1;
+	if (bn > an) return -1;
+	return 0;
+}
+function parseSmallInt(str, start, end) {
+	let result = 0;
+	for (let i = start; i < end; i++) result = result * 10 + str.charCodeAt(i) - 48;
+	return result;
+}
+function countRemainingChunks(str, start) {
+	let count = 0;
+	let index = start;
+	while (index < str.length) {
+		count++;
+		index = findChunkEnd(str, index, isDigit(str.charCodeAt(index)));
+	}
+	return count;
+}
+/**
+* The built-in sorting function registry.
+*
+* Registering this full object opts out of tree-shaking: every built-in
+* sorting function ends up in your bundle. Prefer importing the `sortFn_*`
+* functions you actually use and registering just those in the `sortFns`
+* slot, or passing them directly to the `sortFn` column option.
+*
+* @deprecated Import individual `sortFn_*` functions instead for a smaller
+* bundle. This export still works and is not going away in v9, but built-in
+* name resolution (including `sortFn: 'auto'`) only finds functions you
+* register yourself.
+*/
+const sortFns = {
+	alphanumeric: sortFn_alphanumeric,
+	alphanumericCaseSensitive: sortFn_alphanumericCaseSensitive,
+	basic: sortFn_basic,
+	datetime: sortFn_datetime,
+	text: sortFn_text,
+	textCaseSensitive: sortFn_textCaseSensitive
+};
+
+//#endregion
+export { constructSortFn, reSplitAlphaNumeric, sortFn_alphanumeric, sortFn_alphanumericCaseSensitive, sortFn_basic, sortFn_datetime, sortFn_text, sortFn_textCaseSensitive, sortFns };

package/dist/features/stockFeatures.d.ts

@@ -1,4 +1,7 @@
+import { cellSelectionFeature } from "./cell-selection/cellSelectionFeature.js";
+import { cellSpanningFeature } from "./cell-spanning/cellSpanningFeature.js";
 import { columnFacetingFeature } from "./column-faceting/columnFacetingFeature.js";
+import { rowAggregationFeature } from "./row-aggregation/rowAggregationFeature.js";
 import { columnFilteringFeature } from "./column-filtering/columnFilteringFeature.js";
 import { columnGroupingFeature } from "./column-grouping/columnGroupingFeature.js";
 import { columnOrderingFeature } from "./column-ordering/columnOrderingFeature.js";
@@ -12,9 +15,10 @@ import { rowPaginationFeature } from "./row-pagination/rowPaginationFeature.js";
 import { rowPinningFeature } from "./row-pinning/rowPinningFeature.js";
 import { rowSelectionFeature } from "./row-selection/rowSelectionFeature.js";
 import { rowSortingFeature } from "./row-sorting/rowSortingFeature.js";
-
 //#region src/features/stockFeatures.d.ts
 interface StockFeatures {
+  cellSelectionFeature: typeof cellSelectionFeature;
+  cellSpanningFeature: typeof cellSpanningFeature;
   columnFacetingFeature: typeof columnFacetingFeature;
   columnFilteringFeature: typeof columnFilteringFeature;
   columnGroupingFeature: typeof columnGroupingFeature;
@@ -24,6 +28,7 @@ interface StockFeatures {
   columnSizingFeature: typeof columnSizingFeature;
   columnVisibilityFeature: typeof columnVisibilityFeature;
   globalFilteringFeature: typeof globalFilteringFeature;
+  rowAggregationFeature: typeof rowAggregationFeature;
   rowExpandingFeature: typeof rowExpandingFeature;
   rowPaginationFeature: typeof rowPaginationFeature;
   rowPinningFeature: typeof rowPinningFeature;
@@ -37,5 +42,4 @@ interface StockFeatures {
  */
 declare const stockFeatures: StockFeatures;
 //#endregion
-export { StockFeatures, stockFeatures };
-//# sourceMappingURL=stockFeatures.d.ts.map
+export { StockFeatures, stockFeatures };

package/dist/features/stockFeatures.js

@@ -1,4 +1,7 @@
+import { cellSelectionFeature } from "./cell-selection/cellSelectionFeature.js";
+import { cellSpanningFeature } from "./cell-spanning/cellSpanningFeature.js";
 import { columnFacetingFeature } from "./column-faceting/columnFacetingFeature.js";
+import { rowAggregationFeature } from "./row-aggregation/rowAggregationFeature.js";
 import { columnFilteringFeature } from "./column-filtering/columnFilteringFeature.js";
 import { columnGroupingFeature } from "./column-grouping/columnGroupingFeature.js";
 import { columnOrderingFeature } from "./column-ordering/columnOrderingFeature.js";
@@ -20,6 +23,8 @@ import { rowSortingFeature } from "./row-sorting/rowSortingFeature.js";
 * Use individual feature exports for tree-shaking, or this aggregate when a table should include every built-in feature.
 */
 const stockFeatures = {
+	cellSelectionFeature,
+	cellSpanningFeature,
 	columnFacetingFeature,
 	columnFilteringFeature,
 	columnGroupingFeature,
@@ -29,6 +34,7 @@ const stockFeatures = {
 	columnSizingFeature,
 	columnVisibilityFeature,
 	globalFilteringFeature,
+	rowAggregationFeature,
 	rowExpandingFeature,
 	rowPaginationFeature,
 	rowPinningFeature,
@@ -37,5 +43,4 @@ const stockFeatures = {
 };
 
 //#endregion
-export { stockFeatures };
-//# sourceMappingURL=stockFeatures.js.map
+export { stockFeatures };

package/dist/flex-render.d.ts

@@ -1,8 +1,7 @@
 import { CellData, RowData } from "./types/type-utils.js";
 import { Header } from "./types/Header.js";
-import { TableFeatures } from "./types/TableFeatures.js";
 import { Cell } from "./types/Cell.js";
-
+import { TableFeatures } from "./types/TableFeatures.js";
 //#region src/flex-render.d.ts
 /**
  * Renders a static value or render function with the provided props.
@@ -30,5 +29,4 @@ type FlexRenderProps<TFeatures extends TableFeatures, TData extends RowData, TVa
  */
 declare function FlexRender<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(props: FlexRenderProps<TFeatures, TData, TValue>): unknown | null;
 //#endregion
-export { FlexRender, FlexRenderProps, flexRender };
-//# sourceMappingURL=flex-render.d.ts.map
+export { FlexRender, FlexRenderProps, flexRender };

package/dist/flex-render.js

@@ -15,12 +15,19 @@ function flexRender(comp, props) {
 * Framework adapters use this helper to support column definitions that contain either plain values or template functions.
 */
 function FlexRender(props) {
-	if ("cell" in props && props.cell) return flexRender(props.cell.column.columnDef.cell, props.cell.getContext());
+	if ("cell" in props && props.cell) {
+		const cell = props.cell;
+		const def = cell.column.columnDef;
+		const groupingCell = cell;
+		const groupingDef = def;
+		if (groupingCell.getIsAggregated?.()) return flexRender(groupingDef.aggregatedCell ?? def.cell, cell.getContext());
+		if (groupingCell.getIsPlaceholder?.()) return null;
+		return flexRender(def.cell, cell.getContext());
+	}
 	if ("header" in props && props.header) return flexRender(props.header.column.columnDef.header, props.header.getContext());
 	if ("footer" in props && props.footer) return flexRender(props.footer.column.columnDef.footer, props.footer.getContext());
 	return null;
 }
 
 //#endregion
-export { FlexRender, flexRender };
-//# sourceMappingURL=flex-render.js.map
+export { FlexRender, flexRender };

package/dist/helpers/columnHelper.d.ts

@@ -1,9 +1,8 @@
 import { DeepKeys, DeepValue, RowData } from "../types/type-utils.js";
 import { AccessorFn, AccessorFnColumnDef, AccessorKeyColumnDef, ColumnDef, DisplayColumnDef, GroupColumnDef, IdentifiedColumnDef } from "../types/ColumnDef.js";
 import { TableFeatures } from "../types/TableFeatures.js";
-
 //#region src/helpers/columnHelper.d.ts
-type ColumnHelper<TFeatures extends TableFeatures, TData extends RowData> = {
+interface ColumnHelper<in out TFeatures extends TableFeatures, in out TData extends RowData> {
   /**
    * Creates a data column definition with an accessor key or function to extract the cell value.
    * @example
@@ -45,7 +44,7 @@ type ColumnHelper<TFeatures extends TableFeatures, TData extends RowData> = {
    * ```
    */
   group: (column: GroupColumnDef<TFeatures, TData, unknown>) => GroupColumnDef<TFeatures, TData, unknown>;
-};
+}
 /**
  * Creates helper functions for authoring column definitions with stronger value
  * inference.
@@ -67,5 +66,4 @@ type ColumnHelper<TFeatures extends TableFeatures, TData extends RowData> = {
  */
 declare function createColumnHelper<TFeatures extends TableFeatures, TData extends RowData>(): ColumnHelper<TFeatures, TData>;
 //#endregion
-export { ColumnHelper, createColumnHelper };
-//# sourceMappingURL=columnHelper.d.ts.map
+export { ColumnHelper, createColumnHelper };

package/dist/helpers/columnHelper.js

@@ -36,5 +36,4 @@ function createColumnHelper() {
 }
 
 //#endregion
-export { createColumnHelper };
-//# sourceMappingURL=columnHelper.js.map
+export { createColumnHelper };

package/dist/helpers/metaHelper.d.ts

@@ -22,5 +22,4 @@
  */
 declare function metaHelper<TMeta extends object>(): TMeta;
 //#endregion
-export { metaHelper };
-//# sourceMappingURL=metaHelper.d.ts.map
+export { metaHelper };