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

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

@@ -0,0 +1,25 @@
+//#region src/helpers/metaHelper.d.ts
+/**
+ * A helper for declaring the `tableMeta`/`columnMeta` type-only slots in the
+ * `features` option without a type assertion.
+ *
+ * Equivalent to `{} as TMeta`, but reads as type-only at the call site and
+ * avoids `@typescript-eslint/no-unnecessary-type-assertion` false positives
+ * when the meta type has only optional properties (where an auto-fix removing
+ * the assertion would silently degrade the inferred meta type to `{}`).
+ *
+ * The returned value is a phantom — it is ignored and stripped from the
+ * table's registered features at runtime; only its type is used.
+ * @example
+ * ```
+ * import { metaHelper, tableFeatures, rowSortingFeature } from '@tanstack/react-table'
+ * const features = tableFeatures({
+ *   rowSortingFeature,
+ *   tableMeta: metaHelper<MyTableMeta>(),
+ *   columnMeta: metaHelper<MyColumnMeta>(),
+ * });
+ * ```
+ */
+declare function metaHelper<TMeta extends object>(): TMeta;
+//#endregion
+export { metaHelper };

package/dist/helpers/metaHelper.js

@@ -0,0 +1,28 @@
+//#region src/helpers/metaHelper.ts
+/**
+* A helper for declaring the `tableMeta`/`columnMeta` type-only slots in the
+* `features` option without a type assertion.
+*
+* Equivalent to `{} as TMeta`, but reads as type-only at the call site and
+* avoids `@typescript-eslint/no-unnecessary-type-assertion` false positives
+* when the meta type has only optional properties (where an auto-fix removing
+* the assertion would silently degrade the inferred meta type to `{}`).
+*
+* The returned value is a phantom — it is ignored and stripped from the
+* table's registered features at runtime; only its type is used.
+* @example
+* ```
+* import { metaHelper, tableFeatures, rowSortingFeature } from '@tanstack/react-table'
+* const features = tableFeatures({
+*   rowSortingFeature,
+*   tableMeta: metaHelper<MyTableMeta>(),
+*   columnMeta: metaHelper<MyColumnMeta>(),
+* });
+* ```
+*/
+function metaHelper() {
+	return {};
+}
+
+//#endregion
+export { metaHelper };

package/dist/helpers/tableFeatures.d.ts

@@ -1,18 +1,45 @@
-import { TableFeatures } from "../types/TableFeatures.js";
-
+import { TableFeatures, ValidateFeatureSlots } from "../types/TableFeatures.js";
 //#region src/helpers/tableFeatures.d.ts
 /**
  * A helper function to help define the features that are to be imported and applied to a table instance.
  * Use this utility to make it easier to have the correct type inference for the features that are being imported.
  * **Note:** It is recommended to use this utility statically outside of a component.
+ *
+ * Alongside feature modules, this object carries everything else that is
+ * statically stitched into the table:
+ *
+ * - Row model factories (`sortedRowModel`, `filteredRowModel`, etc.)
+ * - Row model function registries (`sortFns`, `filterFns`, `aggregationFns`),
+ *   whose keys become the valid string values for `sortFn`, `filterFn`,
+ *   `globalFilterFn`, and `aggregationFn` with full inference
+ * - Type-only `tableMeta`/`columnMeta` slots for declaring per-table meta types
+ *   instead of using global declaration merging. The values are phantom
+ *   (ignored and stripped at runtime); only their types are used.
  * @example
  * ```
- * import { tableFeatures, columnVisibilityFeature, rowPinningFeature } from '@tanstack/react-table'
- * const features = tableFeatures({ columnVisibilityFeature, rowPinningFeature });
- * const table = useTable({ features, rowModels: {}, columns, data });
+ * import {
+ *   columnFilteringFeature,
+ *   createFilteredRowModel,
+ *   createSortedRowModel,
+ *   filterFn_includesString,
+ *   rowSortingFeature,
+ *   sortFn_alphanumeric,
+ *   sortFn_text,
+ *   tableFeatures,
+ * } from '@tanstack/react-table'
+ * const features = tableFeatures({
+ *   columnFilteringFeature,
+ *   rowSortingFeature,
+ *   filteredRowModel: createFilteredRowModel(),
+ *   sortedRowModel: createSortedRowModel(),
+ *   filterFns: { includesString: filterFn_includesString, myCustomFilterFn },
+ *   sortFns: { alphanumeric: sortFn_alphanumeric, text: sortFn_text },
+ *   tableMeta: {} as { updateData: (rowIndex: number, columnId: string, value: unknown) => void },
+ *   columnMeta: {} as { align?: 'left' | 'right' },
+ * });
+ * const table = useTable({ features, columns, data });
  * ```
  */
-declare function tableFeatures<TFeatures extends TableFeatures>(features: TFeatures): TFeatures;
+declare function tableFeatures<TFeatures extends TableFeatures>(features: TFeatures & ValidateFeatureSlots<TFeatures>): TFeatures;
 //#endregion
-export { tableFeatures };
-//# sourceMappingURL=tableFeatures.d.ts.map
+export { tableFeatures };

package/dist/helpers/tableFeatures.js

@@ -3,11 +3,40 @@
 * A helper function to help define the features that are to be imported and applied to a table instance.
 * Use this utility to make it easier to have the correct type inference for the features that are being imported.
 * **Note:** It is recommended to use this utility statically outside of a component.
+*
+* Alongside feature modules, this object carries everything else that is
+* statically stitched into the table:
+*
+* - Row model factories (`sortedRowModel`, `filteredRowModel`, etc.)
+* - Row model function registries (`sortFns`, `filterFns`, `aggregationFns`),
+*   whose keys become the valid string values for `sortFn`, `filterFn`,
+*   `globalFilterFn`, and `aggregationFn` with full inference
+* - Type-only `tableMeta`/`columnMeta` slots for declaring per-table meta types
+*   instead of using global declaration merging. The values are phantom
+*   (ignored and stripped at runtime); only their types are used.
 * @example
 * ```
-* import { tableFeatures, columnVisibilityFeature, rowPinningFeature } from '@tanstack/react-table'
-* const features = tableFeatures({ columnVisibilityFeature, rowPinningFeature });
-* const table = useTable({ features, rowModels: {}, columns, data });
+* import {
+*   columnFilteringFeature,
+*   createFilteredRowModel,
+*   createSortedRowModel,
+*   filterFn_includesString,
+*   rowSortingFeature,
+*   sortFn_alphanumeric,
+*   sortFn_text,
+*   tableFeatures,
+* } from '@tanstack/react-table'
+* const features = tableFeatures({
+*   columnFilteringFeature,
+*   rowSortingFeature,
+*   filteredRowModel: createFilteredRowModel(),
+*   sortedRowModel: createSortedRowModel(),
+*   filterFns: { includesString: filterFn_includesString, myCustomFilterFn },
+*   sortFns: { alphanumeric: sortFn_alphanumeric, text: sortFn_text },
+*   tableMeta: {} as { updateData: (rowIndex: number, columnId: string, value: unknown) => void },
+*   columnMeta: {} as { align?: 'left' | 'right' },
+* });
+* const table = useTable({ features, columns, data });
 * ```
 */
 function tableFeatures(features) {
@@ -15,5 +44,4 @@ function tableFeatures(features) {
 }
 
 //#endregion
-export { tableFeatures };
-//# sourceMappingURL=tableFeatures.js.map
+export { tableFeatures };

package/dist/helpers/tableOptions.d.ts

@@ -1,7 +1,6 @@
 import { RowData } from "../types/type-utils.js";
 import { TableOptions } from "../types/TableOptions.js";
 import { TableFeatures } from "../types/TableFeatures.js";
-
 //#region src/helpers/tableOptions.d.ts
 /**
  * Preserves table option inference when reusable options omit `columns`.
@@ -53,5 +52,4 @@ declare function tableOptions<TFeatures extends TableFeatures, TData extends Row
  */
 declare function tableOptions<TFeatures extends TableFeatures, TData extends RowData = any>(options: Omit<TableOptions<TFeatures, TData>, 'data' | 'columns' | 'features'>): Omit<TableOptions<TFeatures, TData>, 'data' | 'columns' | 'features'>;
 //#endregion
-export { tableOptions };
-//# sourceMappingURL=tableOptions.d.ts.map
+export { tableOptions };

package/dist/helpers/tableOptions.js

@@ -10,5 +10,4 @@ function tableOptions(options) {
 }
 
 //#endregion
-export { tableOptions };
-//# sourceMappingURL=tableOptions.js.map
+export { tableOptions };