@tanstack/table-core 9.0.0-beta.51 → 9.0.0-beta.53

package/dist/features/stockFeatures.cjs

@@ -1,43 +0,0 @@
-const require_columnFacetingFeature = require('./column-faceting/columnFacetingFeature.cjs');
-const require_rowAggregationFeature = require('./row-aggregation/rowAggregationFeature.cjs');
-const require_columnFilteringFeature = require('./column-filtering/columnFilteringFeature.cjs');
-const require_columnGroupingFeature = require('./column-grouping/columnGroupingFeature.cjs');
-const require_columnOrderingFeature = require('./column-ordering/columnOrderingFeature.cjs');
-const require_columnPinningFeature = require('./column-pinning/columnPinningFeature.cjs');
-const require_columnResizingFeature = require('./column-resizing/columnResizingFeature.cjs');
-const require_columnSizingFeature = require('./column-sizing/columnSizingFeature.cjs');
-const require_columnVisibilityFeature = require('./column-visibility/columnVisibilityFeature.cjs');
-const require_globalFilteringFeature = require('./global-filtering/globalFilteringFeature.cjs');
-const require_rowExpandingFeature = require('./row-expanding/rowExpandingFeature.cjs');
-const require_rowPaginationFeature = require('./row-pagination/rowPaginationFeature.cjs');
-const require_rowPinningFeature = require('./row-pinning/rowPinningFeature.cjs');
-const require_rowSelectionFeature = require('./row-selection/rowSelectionFeature.cjs');
-const require_rowSortingFeature = require('./row-sorting/rowSortingFeature.cjs');
-
-//#region src/features/stockFeatures.ts
-/**
-* The complete set of stock optional table features.
-*
-* Use individual feature exports for tree-shaking, or this aggregate when a table should include every built-in feature.
-*/
-const stockFeatures = {
-	rowAggregationFeature: require_rowAggregationFeature.rowAggregationFeature,
-	columnFacetingFeature: require_columnFacetingFeature.columnFacetingFeature,
-	columnFilteringFeature: require_columnFilteringFeature.columnFilteringFeature,
-	columnGroupingFeature: require_columnGroupingFeature.columnGroupingFeature,
-	columnOrderingFeature: require_columnOrderingFeature.columnOrderingFeature,
-	columnPinningFeature: require_columnPinningFeature.columnPinningFeature,
-	columnResizingFeature: require_columnResizingFeature.columnResizingFeature,
-	columnSizingFeature: require_columnSizingFeature.columnSizingFeature,
-	columnVisibilityFeature: require_columnVisibilityFeature.columnVisibilityFeature,
-	globalFilteringFeature: require_globalFilteringFeature.globalFilteringFeature,
-	rowExpandingFeature: require_rowExpandingFeature.rowExpandingFeature,
-	rowPaginationFeature: require_rowPaginationFeature.rowPaginationFeature,
-	rowPinningFeature: require_rowPinningFeature.rowPinningFeature,
-	rowSelectionFeature: require_rowSelectionFeature.rowSelectionFeature,
-	rowSortingFeature: require_rowSortingFeature.rowSortingFeature
-};
-
-//#endregion
-exports.stockFeatures = stockFeatures;
-//# sourceMappingURL=stockFeatures.cjs.map

package/dist/features/stockFeatures.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"stockFeatures.cjs","names":[],"sources":["../../src/features/stockFeatures.ts"],"sourcesContent":["import { columnFacetingFeature } from './column-faceting/columnFacetingFeature'\nimport { rowAggregationFeature } from './row-aggregation/rowAggregationFeature'\nimport { columnFilteringFeature } from './column-filtering/columnFilteringFeature'\nimport { columnGroupingFeature } from './column-grouping/columnGroupingFeature'\nimport { columnOrderingFeature } from './column-ordering/columnOrderingFeature'\nimport { columnPinningFeature } from './column-pinning/columnPinningFeature'\nimport { columnResizingFeature } from './column-resizing/columnResizingFeature'\nimport { columnSizingFeature } from './column-sizing/columnSizingFeature'\nimport { columnVisibilityFeature } from './column-visibility/columnVisibilityFeature'\nimport { globalFilteringFeature } from './global-filtering/globalFilteringFeature'\nimport { rowExpandingFeature } from './row-expanding/rowExpandingFeature'\nimport { rowPaginationFeature } from './row-pagination/rowPaginationFeature'\nimport { rowPinningFeature } from './row-pinning/rowPinningFeature'\nimport { rowSelectionFeature } from './row-selection/rowSelectionFeature'\nimport { rowSortingFeature } from './row-sorting/rowSortingFeature'\n\nexport interface StockFeatures {\n  rowAggregationFeature: typeof rowAggregationFeature\n  columnFacetingFeature: typeof columnFacetingFeature\n  columnFilteringFeature: typeof columnFilteringFeature\n  columnGroupingFeature: typeof columnGroupingFeature\n  columnOrderingFeature: typeof columnOrderingFeature\n  columnPinningFeature: typeof columnPinningFeature\n  columnResizingFeature: typeof columnResizingFeature\n  columnSizingFeature: typeof columnSizingFeature\n  columnVisibilityFeature: typeof columnVisibilityFeature\n  globalFilteringFeature: typeof globalFilteringFeature\n  rowExpandingFeature: typeof rowExpandingFeature\n  rowPaginationFeature: typeof rowPaginationFeature\n  rowPinningFeature: typeof rowPinningFeature\n  rowSelectionFeature: typeof rowSelectionFeature\n  rowSortingFeature: typeof rowSortingFeature\n}\n\n/**\n * The complete set of stock optional table features.\n *\n * Use individual feature exports for tree-shaking, or this aggregate when a table should include every built-in feature.\n */\nexport const stockFeatures: StockFeatures = {\n  rowAggregationFeature,\n  columnFacetingFeature,\n  columnFilteringFeature,\n  columnGroupingFeature,\n  columnOrderingFeature,\n  columnPinningFeature,\n  columnResizingFeature,\n  columnSizingFeature,\n  columnVisibilityFeature,\n  globalFilteringFeature,\n  rowExpandingFeature,\n  rowPaginationFeature,\n  rowPinningFeature,\n  rowSelectionFeature,\n  rowSortingFeature,\n} as const\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAuCA,MAAa,gBAA+B;CAC1C;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF"}

package/dist/features/stockFeatures.d.cts

@@ -1,43 +0,0 @@
-import { columnFacetingFeature } from "./column-faceting/columnFacetingFeature.cjs";
-import { rowAggregationFeature } from "./row-aggregation/rowAggregationFeature.cjs";
-import { columnFilteringFeature } from "./column-filtering/columnFilteringFeature.cjs";
-import { columnGroupingFeature } from "./column-grouping/columnGroupingFeature.cjs";
-import { columnOrderingFeature } from "./column-ordering/columnOrderingFeature.cjs";
-import { columnPinningFeature } from "./column-pinning/columnPinningFeature.cjs";
-import { columnResizingFeature } from "./column-resizing/columnResizingFeature.cjs";
-import { columnSizingFeature } from "./column-sizing/columnSizingFeature.cjs";
-import { columnVisibilityFeature } from "./column-visibility/columnVisibilityFeature.cjs";
-import { globalFilteringFeature } from "./global-filtering/globalFilteringFeature.cjs";
-import { rowExpandingFeature } from "./row-expanding/rowExpandingFeature.cjs";
-import { rowPaginationFeature } from "./row-pagination/rowPaginationFeature.cjs";
-import { rowPinningFeature } from "./row-pinning/rowPinningFeature.cjs";
-import { rowSelectionFeature } from "./row-selection/rowSelectionFeature.cjs";
-import { rowSortingFeature } from "./row-sorting/rowSortingFeature.cjs";
-
-//#region src/features/stockFeatures.d.ts
-interface StockFeatures {
-  rowAggregationFeature: typeof rowAggregationFeature;
-  columnFacetingFeature: typeof columnFacetingFeature;
-  columnFilteringFeature: typeof columnFilteringFeature;
-  columnGroupingFeature: typeof columnGroupingFeature;
-  columnOrderingFeature: typeof columnOrderingFeature;
-  columnPinningFeature: typeof columnPinningFeature;
-  columnResizingFeature: typeof columnResizingFeature;
-  columnSizingFeature: typeof columnSizingFeature;
-  columnVisibilityFeature: typeof columnVisibilityFeature;
-  globalFilteringFeature: typeof globalFilteringFeature;
-  rowExpandingFeature: typeof rowExpandingFeature;
-  rowPaginationFeature: typeof rowPaginationFeature;
-  rowPinningFeature: typeof rowPinningFeature;
-  rowSelectionFeature: typeof rowSelectionFeature;
-  rowSortingFeature: typeof rowSortingFeature;
-}
-/**
- * The complete set of stock optional table features.
- *
- * Use individual feature exports for tree-shaking, or this aggregate when a table should include every built-in feature.
- */
-declare const stockFeatures: StockFeatures;
-//#endregion
-export { StockFeatures, stockFeatures };
-//# sourceMappingURL=stockFeatures.d.cts.map

package/dist/features/stockFeatures.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"stockFeatures.js","names":[],"sources":["../../src/features/stockFeatures.ts"],"sourcesContent":["import { columnFacetingFeature } from './column-faceting/columnFacetingFeature'\nimport { rowAggregationFeature } from './row-aggregation/rowAggregationFeature'\nimport { columnFilteringFeature } from './column-filtering/columnFilteringFeature'\nimport { columnGroupingFeature } from './column-grouping/columnGroupingFeature'\nimport { columnOrderingFeature } from './column-ordering/columnOrderingFeature'\nimport { columnPinningFeature } from './column-pinning/columnPinningFeature'\nimport { columnResizingFeature } from './column-resizing/columnResizingFeature'\nimport { columnSizingFeature } from './column-sizing/columnSizingFeature'\nimport { columnVisibilityFeature } from './column-visibility/columnVisibilityFeature'\nimport { globalFilteringFeature } from './global-filtering/globalFilteringFeature'\nimport { rowExpandingFeature } from './row-expanding/rowExpandingFeature'\nimport { rowPaginationFeature } from './row-pagination/rowPaginationFeature'\nimport { rowPinningFeature } from './row-pinning/rowPinningFeature'\nimport { rowSelectionFeature } from './row-selection/rowSelectionFeature'\nimport { rowSortingFeature } from './row-sorting/rowSortingFeature'\n\nexport interface StockFeatures {\n  rowAggregationFeature: typeof rowAggregationFeature\n  columnFacetingFeature: typeof columnFacetingFeature\n  columnFilteringFeature: typeof columnFilteringFeature\n  columnGroupingFeature: typeof columnGroupingFeature\n  columnOrderingFeature: typeof columnOrderingFeature\n  columnPinningFeature: typeof columnPinningFeature\n  columnResizingFeature: typeof columnResizingFeature\n  columnSizingFeature: typeof columnSizingFeature\n  columnVisibilityFeature: typeof columnVisibilityFeature\n  globalFilteringFeature: typeof globalFilteringFeature\n  rowExpandingFeature: typeof rowExpandingFeature\n  rowPaginationFeature: typeof rowPaginationFeature\n  rowPinningFeature: typeof rowPinningFeature\n  rowSelectionFeature: typeof rowSelectionFeature\n  rowSortingFeature: typeof rowSortingFeature\n}\n\n/**\n * The complete set of stock optional table features.\n *\n * Use individual feature exports for tree-shaking, or this aggregate when a table should include every built-in feature.\n */\nexport const stockFeatures: StockFeatures = {\n  rowAggregationFeature,\n  columnFacetingFeature,\n  columnFilteringFeature,\n  columnGroupingFeature,\n  columnOrderingFeature,\n  columnPinningFeature,\n  columnResizingFeature,\n  columnSizingFeature,\n  columnVisibilityFeature,\n  globalFilteringFeature,\n  rowExpandingFeature,\n  rowPaginationFeature,\n  rowPinningFeature,\n  rowSelectionFeature,\n  rowSortingFeature,\n} as const\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAuCA,MAAa,gBAA+B;CAC1C;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF"}

package/dist/flex-render.cjs

@@ -1,29 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-//#region src/flex-render.ts
-/**
-* Renders a static value or render function with the provided props.
-*
-* Framework adapters use this helper to support column definitions that contain either plain values or template functions.
-*/
-function flexRender(comp, props) {
-	if (comp == null) return null;
-	if (typeof comp === "function") return comp(props);
-	return comp;
-}
-/**
-* Renders a static value or render function with the provided 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 ("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
-exports.FlexRender = FlexRender;
-exports.flexRender = flexRender;
-//# sourceMappingURL=flex-render.cjs.map

package/dist/flex-render.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"flex-render.cjs","names":[],"sources":["../src/flex-render.ts"],"sourcesContent":["import type { Cell } from './types/Cell'\nimport type { Header } from './types/Header'\nimport type { TableFeatures } from './types/TableFeatures'\nimport type { CellData, RowData } from './types/type-utils'\n\n/**\n * Renders a static value or render function with the provided props.\n *\n * Framework adapters use this helper to support column definitions that contain either plain values or template functions.\n */\nexport function flexRender<TProps extends object>(\n  comp: unknown,\n  props: TProps,\n): unknown | null {\n  if (comp == null) return null\n\n  if (typeof comp === 'function') {\n    return comp(props)\n  }\n\n  return comp\n}\n\nexport type FlexRenderProps<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n> =\n  | { cell: Cell<TFeatures, TData, TValue>; header?: never; footer?: never }\n  | {\n      header: Header<TFeatures, TData, TValue>\n      cell?: never\n      footer?: never\n    }\n  | {\n      footer: Header<TFeatures, TData, TValue>\n      cell?: never\n      header?: never\n    }\n\n/**\n * Renders a static value or render function with the provided props.\n *\n * Framework adapters use this helper to support column definitions that contain either plain values or template functions.\n */\nexport function FlexRender<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(props: FlexRenderProps<TFeatures, TData, TValue>): unknown | null {\n  if ('cell' in props && props.cell) {\n    return flexRender(props.cell.column.columnDef.cell, props.cell.getContext())\n  }\n\n  if ('header' in props && props.header) {\n    return flexRender(\n      props.header.column.columnDef.header,\n      props.header.getContext(),\n    )\n  }\n\n  if ('footer' in props && props.footer) {\n    return flexRender(\n      props.footer.column.columnDef.footer,\n      props.footer.getContext(),\n    )\n  }\n\n  return null\n}\n"],"mappings":";;;;;;;;AAUA,SAAgB,WACd,MACA,OACgB;CAChB,IAAI,QAAQ,MAAM,OAAO;CAEzB,IAAI,OAAO,SAAS,YAClB,OAAO,KAAK,KAAK;CAGnB,OAAO;AACT;;;;;;AAwBA,SAAgB,WAId,OAAkE;CAClE,IAAI,UAAU,SAAS,MAAM,MAC3B,OAAO,WAAW,MAAM,KAAK,OAAO,UAAU,MAAM,MAAM,KAAK,WAAW,CAAC;CAG7E,IAAI,YAAY,SAAS,MAAM,QAC7B,OAAO,WACL,MAAM,OAAO,OAAO,UAAU,QAC9B,MAAM,OAAO,WAAW,CAC1B;CAGF,IAAI,YAAY,SAAS,MAAM,QAC7B,OAAO,WACL,MAAM,OAAO,OAAO,UAAU,QAC9B,MAAM,OAAO,WAAW,CAC1B;CAGF,OAAO;AACT"}

package/dist/flex-render.d.cts

@@ -1,34 +0,0 @@
-import { CellData, RowData } from "./types/type-utils.cjs";
-import { Header } from "./types/Header.cjs";
-import { Cell } from "./types/Cell.cjs";
-import { TableFeatures } from "./types/TableFeatures.cjs";
-
-//#region src/flex-render.d.ts
-/**
- * Renders a static value or render function with the provided props.
- *
- * Framework adapters use this helper to support column definitions that contain either plain values or template functions.
- */
-declare function flexRender<TProps extends object>(comp: unknown, props: TProps): unknown | null;
-type FlexRenderProps<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData> = {
-  cell: Cell<TFeatures, TData, TValue>;
-  header?: never;
-  footer?: never;
-} | {
-  header: Header<TFeatures, TData, TValue>;
-  cell?: never;
-  footer?: never;
-} | {
-  footer: Header<TFeatures, TData, TValue>;
-  cell?: never;
-  header?: never;
-};
-/**
- * Renders a static value or render function with the provided props.
- *
- * Framework adapters use this helper to support column definitions that contain either plain values or template functions.
- */
-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.cts.map

package/dist/flex-render.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"flex-render.js","names":[],"sources":["../src/flex-render.ts"],"sourcesContent":["import type { Cell } from './types/Cell'\nimport type { Header } from './types/Header'\nimport type { TableFeatures } from './types/TableFeatures'\nimport type { CellData, RowData } from './types/type-utils'\n\n/**\n * Renders a static value or render function with the provided props.\n *\n * Framework adapters use this helper to support column definitions that contain either plain values or template functions.\n */\nexport function flexRender<TProps extends object>(\n  comp: unknown,\n  props: TProps,\n): unknown | null {\n  if (comp == null) return null\n\n  if (typeof comp === 'function') {\n    return comp(props)\n  }\n\n  return comp\n}\n\nexport type FlexRenderProps<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n> =\n  | { cell: Cell<TFeatures, TData, TValue>; header?: never; footer?: never }\n  | {\n      header: Header<TFeatures, TData, TValue>\n      cell?: never\n      footer?: never\n    }\n  | {\n      footer: Header<TFeatures, TData, TValue>\n      cell?: never\n      header?: never\n    }\n\n/**\n * Renders a static value or render function with the provided props.\n *\n * Framework adapters use this helper to support column definitions that contain either plain values or template functions.\n */\nexport function FlexRender<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData = CellData,\n>(props: FlexRenderProps<TFeatures, TData, TValue>): unknown | null {\n  if ('cell' in props && props.cell) {\n    return flexRender(props.cell.column.columnDef.cell, props.cell.getContext())\n  }\n\n  if ('header' in props && props.header) {\n    return flexRender(\n      props.header.column.columnDef.header,\n      props.header.getContext(),\n    )\n  }\n\n  if ('footer' in props && props.footer) {\n    return flexRender(\n      props.footer.column.columnDef.footer,\n      props.footer.getContext(),\n    )\n  }\n\n  return null\n}\n"],"mappings":";;;;;;AAUA,SAAgB,WACd,MACA,OACgB;CAChB,IAAI,QAAQ,MAAM,OAAO;CAEzB,IAAI,OAAO,SAAS,YAClB,OAAO,KAAK,KAAK;CAGnB,OAAO;AACT;;;;;;AAwBA,SAAgB,WAId,OAAkE;CAClE,IAAI,UAAU,SAAS,MAAM,MAC3B,OAAO,WAAW,MAAM,KAAK,OAAO,UAAU,MAAM,MAAM,KAAK,WAAW,CAAC;CAG7E,IAAI,YAAY,SAAS,MAAM,QAC7B,OAAO,WACL,MAAM,OAAO,OAAO,UAAU,QAC9B,MAAM,OAAO,WAAW,CAC1B;CAGF,IAAI,YAAY,SAAS,MAAM,QAC7B,OAAO,WACL,MAAM,OAAO,OAAO,UAAU,QAC9B,MAAM,OAAO,WAAW,CAC1B;CAGF,OAAO;AACT"}

package/dist/helpers/columnHelper.cjs

@@ -1,41 +0,0 @@
-
-//#region src/helpers/columnHelper.ts
-/**
-* Creates helper functions for authoring column definitions with stronger value
-* inference.
-*
-* `accessor` infers `TValue` from an accessor key or accessor function,
-* `display` creates non-data columns, `group` creates parent columns, and
-* `columns` preserves tuple-level value types for arrays. At runtime these
-* helpers only return column definition objects.
-*
-* @example
-* ```tsx
-* const helper = createColumnHelper<typeof features, Person>() // features is the result of `tableFeatures({})` helper
-* const columns = [
-*  helper.display({ id: 'actions', header: 'Actions' }),
-*  helper.accessor('firstName', {}),
-*  helper.accessor((row) => row.lastName, { id: 'lastName' }),
-* ]
-* ```
-*/
-function createColumnHelper() {
-	return {
-		accessor: (accessor, column) => {
-			return typeof accessor === "function" ? {
-				...column,
-				accessorFn: accessor
-			} : {
-				...column,
-				accessorKey: accessor
-			};
-		},
-		columns: (columns) => columns,
-		display: (column) => column,
-		group: (column) => column
-	};
-}
-
-//#endregion
-exports.createColumnHelper = createColumnHelper;
-//# sourceMappingURL=columnHelper.cjs.map

package/dist/helpers/columnHelper.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"columnHelper.cjs","names":[],"sources":["../../src/helpers/columnHelper.ts"],"sourcesContent":["import type { DeepKeys, DeepValue, RowData } from '../types/type-utils'\nimport type { TableFeatures } from '../types/TableFeatures'\nimport type {\n  AccessorFn,\n  AccessorFnColumnDef,\n  AccessorKeyColumnDef,\n  ColumnDef,\n  DisplayColumnDef,\n  GroupColumnDef,\n  IdentifiedColumnDef,\n} from '../types/ColumnDef'\n\nexport interface ColumnHelper<\n  in out TFeatures extends TableFeatures,\n  in out TData extends RowData,\n> {\n  /**\n   * Creates a data column definition with an accessor key or function to extract the cell value.\n   * @example\n   * ```ts\n   * helper.accessor('firstName', { cell: (info) => info.getValue() })\n   * helper.accessor((row) => row.lastName, { id: 'lastName' })\n   * ```\n   */\n  accessor: <\n    TAccessor extends AccessorFn<TData> | DeepKeys<TData>,\n    TValue extends TAccessor extends AccessorFn<TData, infer TReturn>\n      ? TReturn\n      : TAccessor extends DeepKeys<TData>\n        ? DeepValue<TData, TAccessor>\n        : never,\n  >(\n    accessor: TAccessor,\n    column: TAccessor extends AccessorFn<TData>\n      ? DisplayColumnDef<TFeatures, TData, TValue>\n      : IdentifiedColumnDef<TFeatures, TData, TValue>,\n  ) => TAccessor extends AccessorFn<TData>\n    ? AccessorFnColumnDef<TFeatures, TData, TValue>\n    : AccessorKeyColumnDef<TFeatures, TData, TValue>\n  /**\n   * Wraps an array of column definitions to preserve each column's individual TValue type.\n   * Uses variadic tuple types to infer element types before checking constraints, preventing type widening.\n   * @example\n   * ```ts\n   * helper.columns([helper.accessor('firstName', {}), helper.accessor('age', {})])\n   * ```\n   */\n  columns: <TColumns extends ReadonlyArray<ColumnDef<TFeatures, TData, any>>>(\n    columns: [...TColumns],\n  ) => Array<ColumnDef<TFeatures, TData, any>> & [...TColumns]\n  /**\n   * Creates a display column definition for non-data columns like actions or row selection.\n   * @example\n   * ```ts\n   * helper.display({ id: 'actions', header: 'Actions', cell: () => <button>Edit</button> })\n   * ```\n   */\n  display: (\n    column: DisplayColumnDef<TFeatures, TData>,\n  ) => DisplayColumnDef<TFeatures, TData, unknown>\n  /**\n   * Creates a group column definition that contains nested child columns.\n   * @example\n   * ```ts\n   * helper.group({\n   *   id: 'name',\n   *   header: 'Name',\n   *   columns: helper.columns([\n   *     helper.accessor('firstName', {}),\n   *     helper.accessor('lastName', { id: 'lastName' }),\n   *   ]),\n   * })\n   * ```\n   */\n  group: (\n    column: GroupColumnDef<TFeatures, TData, unknown>,\n  ) => GroupColumnDef<TFeatures, TData, unknown>\n}\n\n/**\n * Creates helper functions for authoring column definitions with stronger value\n * inference.\n *\n * `accessor` infers `TValue` from an accessor key or accessor function,\n * `display` creates non-data columns, `group` creates parent columns, and\n * `columns` preserves tuple-level value types for arrays. At runtime these\n * helpers only return column definition objects.\n *\n * @example\n * ```tsx\n * const helper = createColumnHelper<typeof features, Person>() // features is the result of `tableFeatures({})` helper\n * const columns = [\n *  helper.display({ id: 'actions', header: 'Actions' }),\n *  helper.accessor('firstName', {}),\n *  helper.accessor((row) => row.lastName, { id: 'lastName' }),\n * ]\n * ```\n */\nexport function createColumnHelper<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): ColumnHelper<TFeatures, TData> {\n  return {\n    accessor: (accessor, column) => {\n      return typeof accessor === 'function'\n        ? ({\n            ...column,\n            accessorFn: accessor,\n          } as any)\n        : {\n            ...column,\n            accessorKey: accessor,\n          }\n    },\n    columns: <TColumns extends ReadonlyArray<ColumnDef<TFeatures, TData, any>>>(\n      columns: [...TColumns],\n    ): Array<ColumnDef<TFeatures, TData, any>> & [...TColumns] =>\n      columns as Array<ColumnDef<TFeatures, TData, any>> & [...TColumns],\n    display: (column) => column,\n    group: (column) => column,\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAkGA,SAAgB,qBAGoB;CAClC,OAAO;EACL,WAAW,UAAU,WAAW;GAC9B,OAAO,OAAO,aAAa,aACtB;IACC,GAAG;IACH,YAAY;GACd,IACA;IACE,GAAG;IACH,aAAa;GACf;EACN;EACA,UACE,YAEA;EACF,UAAU,WAAW;EACrB,QAAQ,WAAW;CACrB;AACF"}

package/dist/helpers/columnHelper.d.cts

@@ -1,71 +0,0 @@
-import { DeepKeys, DeepValue, RowData } from "../types/type-utils.cjs";
-import { AccessorFn, AccessorFnColumnDef, AccessorKeyColumnDef, ColumnDef, DisplayColumnDef, GroupColumnDef, IdentifiedColumnDef } from "../types/ColumnDef.cjs";
-import { TableFeatures } from "../types/TableFeatures.cjs";
-
-//#region src/helpers/columnHelper.d.ts
-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
-   * ```ts
-   * helper.accessor('firstName', { cell: (info) => info.getValue() })
-   * helper.accessor((row) => row.lastName, { id: 'lastName' })
-   * ```
-   */
-  accessor: <TAccessor extends AccessorFn<TData> | DeepKeys<TData>, TValue extends (TAccessor extends AccessorFn<TData, infer TReturn> ? TReturn : TAccessor extends DeepKeys<TData> ? DeepValue<TData, TAccessor> : never)>(accessor: TAccessor, column: TAccessor extends AccessorFn<TData> ? DisplayColumnDef<TFeatures, TData, TValue> : IdentifiedColumnDef<TFeatures, TData, TValue>) => TAccessor extends AccessorFn<TData> ? AccessorFnColumnDef<TFeatures, TData, TValue> : AccessorKeyColumnDef<TFeatures, TData, TValue>;
-  /**
-   * Wraps an array of column definitions to preserve each column's individual TValue type.
-   * Uses variadic tuple types to infer element types before checking constraints, preventing type widening.
-   * @example
-   * ```ts
-   * helper.columns([helper.accessor('firstName', {}), helper.accessor('age', {})])
-   * ```
-   */
-  columns: <TColumns extends ReadonlyArray<ColumnDef<TFeatures, TData, any>>>(columns: [...TColumns]) => Array<ColumnDef<TFeatures, TData, any>> & [...TColumns];
-  /**
-   * Creates a display column definition for non-data columns like actions or row selection.
-   * @example
-   * ```ts
-   * helper.display({ id: 'actions', header: 'Actions', cell: () => <button>Edit</button> })
-   * ```
-   */
-  display: (column: DisplayColumnDef<TFeatures, TData>) => DisplayColumnDef<TFeatures, TData, unknown>;
-  /**
-   * Creates a group column definition that contains nested child columns.
-   * @example
-   * ```ts
-   * helper.group({
-   *   id: 'name',
-   *   header: 'Name',
-   *   columns: helper.columns([
-   *     helper.accessor('firstName', {}),
-   *     helper.accessor('lastName', { id: 'lastName' }),
-   *   ]),
-   * })
-   * ```
-   */
-  group: (column: GroupColumnDef<TFeatures, TData, unknown>) => GroupColumnDef<TFeatures, TData, unknown>;
-}
-/**
- * Creates helper functions for authoring column definitions with stronger value
- * inference.
- *
- * `accessor` infers `TValue` from an accessor key or accessor function,
- * `display` creates non-data columns, `group` creates parent columns, and
- * `columns` preserves tuple-level value types for arrays. At runtime these
- * helpers only return column definition objects.
- *
- * @example
- * ```tsx
- * const helper = createColumnHelper<typeof features, Person>() // features is the result of `tableFeatures({})` helper
- * const columns = [
- *  helper.display({ id: 'actions', header: 'Actions' }),
- *  helper.accessor('firstName', {}),
- *  helper.accessor((row) => row.lastName, { id: 'lastName' }),
- * ]
- * ```
- */
-declare function createColumnHelper<TFeatures extends TableFeatures, TData extends RowData>(): ColumnHelper<TFeatures, TData>;
-//#endregion
-export { ColumnHelper, createColumnHelper };
-//# sourceMappingURL=columnHelper.d.cts.map

package/dist/helpers/columnHelper.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"columnHelper.js","names":[],"sources":["../../src/helpers/columnHelper.ts"],"sourcesContent":["import type { DeepKeys, DeepValue, RowData } from '../types/type-utils'\nimport type { TableFeatures } from '../types/TableFeatures'\nimport type {\n  AccessorFn,\n  AccessorFnColumnDef,\n  AccessorKeyColumnDef,\n  ColumnDef,\n  DisplayColumnDef,\n  GroupColumnDef,\n  IdentifiedColumnDef,\n} from '../types/ColumnDef'\n\nexport interface ColumnHelper<\n  in out TFeatures extends TableFeatures,\n  in out TData extends RowData,\n> {\n  /**\n   * Creates a data column definition with an accessor key or function to extract the cell value.\n   * @example\n   * ```ts\n   * helper.accessor('firstName', { cell: (info) => info.getValue() })\n   * helper.accessor((row) => row.lastName, { id: 'lastName' })\n   * ```\n   */\n  accessor: <\n    TAccessor extends AccessorFn<TData> | DeepKeys<TData>,\n    TValue extends TAccessor extends AccessorFn<TData, infer TReturn>\n      ? TReturn\n      : TAccessor extends DeepKeys<TData>\n        ? DeepValue<TData, TAccessor>\n        : never,\n  >(\n    accessor: TAccessor,\n    column: TAccessor extends AccessorFn<TData>\n      ? DisplayColumnDef<TFeatures, TData, TValue>\n      : IdentifiedColumnDef<TFeatures, TData, TValue>,\n  ) => TAccessor extends AccessorFn<TData>\n    ? AccessorFnColumnDef<TFeatures, TData, TValue>\n    : AccessorKeyColumnDef<TFeatures, TData, TValue>\n  /**\n   * Wraps an array of column definitions to preserve each column's individual TValue type.\n   * Uses variadic tuple types to infer element types before checking constraints, preventing type widening.\n   * @example\n   * ```ts\n   * helper.columns([helper.accessor('firstName', {}), helper.accessor('age', {})])\n   * ```\n   */\n  columns: <TColumns extends ReadonlyArray<ColumnDef<TFeatures, TData, any>>>(\n    columns: [...TColumns],\n  ) => Array<ColumnDef<TFeatures, TData, any>> & [...TColumns]\n  /**\n   * Creates a display column definition for non-data columns like actions or row selection.\n   * @example\n   * ```ts\n   * helper.display({ id: 'actions', header: 'Actions', cell: () => <button>Edit</button> })\n   * ```\n   */\n  display: (\n    column: DisplayColumnDef<TFeatures, TData>,\n  ) => DisplayColumnDef<TFeatures, TData, unknown>\n  /**\n   * Creates a group column definition that contains nested child columns.\n   * @example\n   * ```ts\n   * helper.group({\n   *   id: 'name',\n   *   header: 'Name',\n   *   columns: helper.columns([\n   *     helper.accessor('firstName', {}),\n   *     helper.accessor('lastName', { id: 'lastName' }),\n   *   ]),\n   * })\n   * ```\n   */\n  group: (\n    column: GroupColumnDef<TFeatures, TData, unknown>,\n  ) => GroupColumnDef<TFeatures, TData, unknown>\n}\n\n/**\n * Creates helper functions for authoring column definitions with stronger value\n * inference.\n *\n * `accessor` infers `TValue` from an accessor key or accessor function,\n * `display` creates non-data columns, `group` creates parent columns, and\n * `columns` preserves tuple-level value types for arrays. At runtime these\n * helpers only return column definition objects.\n *\n * @example\n * ```tsx\n * const helper = createColumnHelper<typeof features, Person>() // features is the result of `tableFeatures({})` helper\n * const columns = [\n *  helper.display({ id: 'actions', header: 'Actions' }),\n *  helper.accessor('firstName', {}),\n *  helper.accessor((row) => row.lastName, { id: 'lastName' }),\n * ]\n * ```\n */\nexport function createColumnHelper<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): ColumnHelper<TFeatures, TData> {\n  return {\n    accessor: (accessor, column) => {\n      return typeof accessor === 'function'\n        ? ({\n            ...column,\n            accessorFn: accessor,\n          } as any)\n        : {\n            ...column,\n            accessorKey: accessor,\n          }\n    },\n    columns: <TColumns extends ReadonlyArray<ColumnDef<TFeatures, TData, any>>>(\n      columns: [...TColumns],\n    ): Array<ColumnDef<TFeatures, TData, any>> & [...TColumns] =>\n      columns as Array<ColumnDef<TFeatures, TData, any>> & [...TColumns],\n    display: (column) => column,\n    group: (column) => column,\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAkGA,SAAgB,qBAGoB;CAClC,OAAO;EACL,WAAW,UAAU,WAAW;GAC9B,OAAO,OAAO,aAAa,aACtB;IACC,GAAG;IACH,YAAY;GACd,IACA;IACE,GAAG;IACH,aAAa;GACf;EACN;EACA,UACE,YAEA;EACF,UAAU,WAAW;EACrB,QAAQ,WAAW;CACrB;AACF"}

package/dist/helpers/metaHelper.cjs

@@ -1,30 +0,0 @@
-
-//#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
-exports.metaHelper = metaHelper;
-//# sourceMappingURL=metaHelper.cjs.map

package/dist/helpers/metaHelper.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"metaHelper.cjs","names":[],"sources":["../../src/helpers/metaHelper.ts"],"sourcesContent":["/**\n * A helper for declaring the `tableMeta`/`columnMeta` type-only slots in the\n * `features` option without a type assertion.\n *\n * Equivalent to `{} as TMeta`, but reads as type-only at the call site and\n * avoids `@typescript-eslint/no-unnecessary-type-assertion` false positives\n * when the meta type has only optional properties (where an auto-fix removing\n * the assertion would silently degrade the inferred meta type to `{}`).\n *\n * The returned value is a phantom — it is ignored and stripped from the\n * table's registered features at runtime; only its type is used.\n * @example\n * ```\n * import { metaHelper, tableFeatures, rowSortingFeature } from '@tanstack/react-table'\n * const features = tableFeatures({\n *   rowSortingFeature,\n *   tableMeta: metaHelper<MyTableMeta>(),\n *   columnMeta: metaHelper<MyColumnMeta>(),\n * });\n * ```\n */\nexport function metaHelper<TMeta extends object>(): TMeta {\n  return {} as TMeta\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,aAA0C;CACxD,OAAO,CAAC;AACV"}

package/dist/helpers/metaHelper.d.cts

@@ -1,26 +0,0 @@
-//#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 };
-//# sourceMappingURL=metaHelper.d.cts.map

package/dist/helpers/metaHelper.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"metaHelper.js","names":[],"sources":["../../src/helpers/metaHelper.ts"],"sourcesContent":["/**\n * A helper for declaring the `tableMeta`/`columnMeta` type-only slots in the\n * `features` option without a type assertion.\n *\n * Equivalent to `{} as TMeta`, but reads as type-only at the call site and\n * avoids `@typescript-eslint/no-unnecessary-type-assertion` false positives\n * when the meta type has only optional properties (where an auto-fix removing\n * the assertion would silently degrade the inferred meta type to `{}`).\n *\n * The returned value is a phantom — it is ignored and stripped from the\n * table's registered features at runtime; only its type is used.\n * @example\n * ```\n * import { metaHelper, tableFeatures, rowSortingFeature } from '@tanstack/react-table'\n * const features = tableFeatures({\n *   rowSortingFeature,\n *   tableMeta: metaHelper<MyTableMeta>(),\n *   columnMeta: metaHelper<MyColumnMeta>(),\n * });\n * ```\n */\nexport function metaHelper<TMeta extends object>(): TMeta {\n  return {} as TMeta\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,aAA0C;CACxD,OAAO,CAAC;AACV"}

package/dist/helpers/tableFeatures.cjs

@@ -1,49 +0,0 @@
-
-//#region src/helpers/tableFeatures.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 {
-*   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) {
-	return features;
-}
-
-//#endregion
-exports.tableFeatures = tableFeatures;
-//# sourceMappingURL=tableFeatures.cjs.map

package/dist/helpers/tableFeatures.cjs.map

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

package/dist/helpers/tableFeatures.d.cts

@@ -1,47 +0,0 @@
-import { TableFeatures, ValidateFeatureSlots } from "../types/TableFeatures.cjs";
-
-//#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 {
- *   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 & ValidateFeatureSlots<TFeatures>): TFeatures;
-//#endregion
-export { tableFeatures };
-//# sourceMappingURL=tableFeatures.d.cts.map

package/dist/helpers/tableFeatures.js.map

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

package/dist/helpers/tableOptions.cjs

@@ -1,15 +0,0 @@
-
-//#region src/helpers/tableOptions.ts
-/**
-* Runtime implementation for `tableOptions`.
-*
-* The helper returns the same object it receives; all value comes from the
-* overloads preserving table option inference at compile time.
-*/
-function tableOptions(options) {
-	return options;
-}
-
-//#endregion
-exports.tableOptions = tableOptions;
-//# sourceMappingURL=tableOptions.cjs.map

package/dist/helpers/tableOptions.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"tableOptions.cjs","names":[],"sources":["../../src/helpers/tableOptions.ts"],"sourcesContent":["import type { RowData } from '../types/type-utils'\nimport type { TableFeatures } from '../types/TableFeatures'\nimport type { TableOptions } from '../types/TableOptions'\n\n/**\n * Preserves table option inference when reusable options omit `columns`.\n *\n * This is useful for composing shared options that will receive columns later\n * from a framework adapter or table factory.\n */\nexport function tableOptions<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(\n  options: Omit<TableOptions<TFeatures, TData>, 'columns'> & {\n    features: TFeatures\n  },\n): Omit<TableOptions<TFeatures, TData>, 'columns' | 'features'> & {\n  features: TFeatures\n}\n\n/**\n * Preserves table option inference when reusable options omit `data`.\n */\nexport function tableOptions<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(\n  options: Omit<TableOptions<TFeatures, TData>, 'data'> & {\n    features: TFeatures\n  },\n): Omit<TableOptions<TFeatures, TData>, 'data' | 'features'> & {\n  features: TFeatures\n}\n\n/**\n * Preserves table option inference when reusable options omit both `data` and\n * `columns`.\n */\nexport function tableOptions<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(\n  options: Omit<TableOptions<TFeatures, TData>, 'data' | 'columns'> & {\n    features: TFeatures\n  },\n): Omit<TableOptions<TFeatures, TData>, 'data' | 'columns' | 'features'> & {\n  features: TFeatures\n}\n\n/**\n * Preserves inference for a fully specified table options object.\n */\nexport function tableOptions<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(options: TableOptions<TFeatures, TData>): TableOptions<TFeatures, TData>\n\n/**\n * Preserves inference when a wrapper supplies `features`.\n */\nexport function tableOptions<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(\n  options: Omit<TableOptions<TFeatures, TData>, 'features'>,\n): Omit<TableOptions<TFeatures, TData>, 'features'>\n\n/**\n * Preserves inference when a wrapper supplies both `data` and `features`.\n */\nexport function tableOptions<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(\n  options: Omit<TableOptions<TFeatures, TData>, 'data' | 'features'>,\n): Omit<TableOptions<TFeatures, TData>, 'data' | 'features'>\n\n/**\n * Preserves inference when a wrapper supplies both `columns` and `features`.\n */\nexport function tableOptions<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(\n  options: Omit<TableOptions<TFeatures, TData>, 'columns' | 'features'>,\n): Omit<TableOptions<TFeatures, TData>, 'columns' | 'features'>\n\n/**\n * Preserves inference when a wrapper supplies `data`, `columns`, and\n * `features`.\n */\nexport function tableOptions<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(\n  options: Omit<\n    TableOptions<TFeatures, TData>,\n    'data' | 'columns' | 'features'\n  >,\n): Omit<TableOptions<TFeatures, TData>, 'data' | 'columns' | 'features'>\n\n/**\n * Runtime implementation for `tableOptions`.\n *\n * The helper returns the same object it receives; all value comes from the\n * overloads preserving table option inference at compile time.\n */\nexport function tableOptions(options: unknown) {\n  return options\n}\n\n// test\n\n// const options = tableOptions({\n//   features: {},\n// })\n"],"mappings":";;;;;;;;AA4GA,SAAgB,aAAa,SAAkB;CAC7C,OAAO;AACT"}

package/dist/helpers/tableOptions.d.cts

@@ -1,57 +0,0 @@
-import { RowData } from "../types/type-utils.cjs";
-import { TableOptions } from "../types/TableOptions.cjs";
-import { TableFeatures } from "../types/TableFeatures.cjs";
-
-//#region src/helpers/tableOptions.d.ts
-/**
- * Preserves table option inference when reusable options omit `columns`.
- *
- * This is useful for composing shared options that will receive columns later
- * from a framework adapter or table factory.
- */
-declare function tableOptions<TFeatures extends TableFeatures, TData extends RowData = any>(options: Omit<TableOptions<TFeatures, TData>, 'columns'> & {
-  features: TFeatures;
-}): Omit<TableOptions<TFeatures, TData>, 'columns' | 'features'> & {
-  features: TFeatures;
-};
-/**
- * Preserves table option inference when reusable options omit `data`.
- */
-declare function tableOptions<TFeatures extends TableFeatures, TData extends RowData = any>(options: Omit<TableOptions<TFeatures, TData>, 'data'> & {
-  features: TFeatures;
-}): Omit<TableOptions<TFeatures, TData>, 'data' | 'features'> & {
-  features: TFeatures;
-};
-/**
- * Preserves table option inference when reusable options omit both `data` and
- * `columns`.
- */
-declare function tableOptions<TFeatures extends TableFeatures, TData extends RowData = any>(options: Omit<TableOptions<TFeatures, TData>, 'data' | 'columns'> & {
-  features: TFeatures;
-}): Omit<TableOptions<TFeatures, TData>, 'data' | 'columns' | 'features'> & {
-  features: TFeatures;
-};
-/**
- * Preserves inference for a fully specified table options object.
- */
-declare function tableOptions<TFeatures extends TableFeatures, TData extends RowData = any>(options: TableOptions<TFeatures, TData>): TableOptions<TFeatures, TData>;
-/**
- * Preserves inference when a wrapper supplies `features`.
- */
-declare function tableOptions<TFeatures extends TableFeatures, TData extends RowData = any>(options: Omit<TableOptions<TFeatures, TData>, 'features'>): Omit<TableOptions<TFeatures, TData>, 'features'>;
-/**
- * Preserves inference when a wrapper supplies both `data` and `features`.
- */
-declare function tableOptions<TFeatures extends TableFeatures, TData extends RowData = any>(options: Omit<TableOptions<TFeatures, TData>, 'data' | 'features'>): Omit<TableOptions<TFeatures, TData>, 'data' | 'features'>;
-/**
- * Preserves inference when a wrapper supplies both `columns` and `features`.
- */
-declare function tableOptions<TFeatures extends TableFeatures, TData extends RowData = any>(options: Omit<TableOptions<TFeatures, TData>, 'columns' | 'features'>): Omit<TableOptions<TFeatures, TData>, 'columns' | 'features'>;
-/**
- * Preserves inference when a wrapper supplies `data`, `columns`, and
- * `features`.
- */
-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.cts.map

package/dist/helpers/tableOptions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tableOptions.js","names":[],"sources":["../../src/helpers/tableOptions.ts"],"sourcesContent":["import type { RowData } from '../types/type-utils'\nimport type { TableFeatures } from '../types/TableFeatures'\nimport type { TableOptions } from '../types/TableOptions'\n\n/**\n * Preserves table option inference when reusable options omit `columns`.\n *\n * This is useful for composing shared options that will receive columns later\n * from a framework adapter or table factory.\n */\nexport function tableOptions<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(\n  options: Omit<TableOptions<TFeatures, TData>, 'columns'> & {\n    features: TFeatures\n  },\n): Omit<TableOptions<TFeatures, TData>, 'columns' | 'features'> & {\n  features: TFeatures\n}\n\n/**\n * Preserves table option inference when reusable options omit `data`.\n */\nexport function tableOptions<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(\n  options: Omit<TableOptions<TFeatures, TData>, 'data'> & {\n    features: TFeatures\n  },\n): Omit<TableOptions<TFeatures, TData>, 'data' | 'features'> & {\n  features: TFeatures\n}\n\n/**\n * Preserves table option inference when reusable options omit both `data` and\n * `columns`.\n */\nexport function tableOptions<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(\n  options: Omit<TableOptions<TFeatures, TData>, 'data' | 'columns'> & {\n    features: TFeatures\n  },\n): Omit<TableOptions<TFeatures, TData>, 'data' | 'columns' | 'features'> & {\n  features: TFeatures\n}\n\n/**\n * Preserves inference for a fully specified table options object.\n */\nexport function tableOptions<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(options: TableOptions<TFeatures, TData>): TableOptions<TFeatures, TData>\n\n/**\n * Preserves inference when a wrapper supplies `features`.\n */\nexport function tableOptions<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(\n  options: Omit<TableOptions<TFeatures, TData>, 'features'>,\n): Omit<TableOptions<TFeatures, TData>, 'features'>\n\n/**\n * Preserves inference when a wrapper supplies both `data` and `features`.\n */\nexport function tableOptions<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(\n  options: Omit<TableOptions<TFeatures, TData>, 'data' | 'features'>,\n): Omit<TableOptions<TFeatures, TData>, 'data' | 'features'>\n\n/**\n * Preserves inference when a wrapper supplies both `columns` and `features`.\n */\nexport function tableOptions<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(\n  options: Omit<TableOptions<TFeatures, TData>, 'columns' | 'features'>,\n): Omit<TableOptions<TFeatures, TData>, 'columns' | 'features'>\n\n/**\n * Preserves inference when a wrapper supplies `data`, `columns`, and\n * `features`.\n */\nexport function tableOptions<\n  TFeatures extends TableFeatures,\n  TData extends RowData = any,\n>(\n  options: Omit<\n    TableOptions<TFeatures, TData>,\n    'data' | 'columns' | 'features'\n  >,\n): Omit<TableOptions<TFeatures, TData>, 'data' | 'columns' | 'features'>\n\n/**\n * Runtime implementation for `tableOptions`.\n *\n * The helper returns the same object it receives; all value comes from the\n * overloads preserving table option inference at compile time.\n */\nexport function tableOptions(options: unknown) {\n  return options\n}\n\n// test\n\n// const options = tableOptions({\n//   features: {},\n// })\n"],"mappings":";;;;;;;AA4GA,SAAgB,aAAa,SAAkB;CAC7C,OAAO;AACT"}