@tanstack/table-core 9.0.0-alpha.6 → 9.0.0-beta.1

package/dist/fns/sortFns.js

@@ -0,0 +1,110 @@
+//#region src/fns/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;
+/**
+* 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 = (rowA, rowB, columnId) => {
+	return compareAlphanumeric(toString(rowA.getValue(columnId)).toLowerCase(), toString(rowB.getValue(columnId)).toLowerCase());
+};
+/**
+* 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 = (rowA, rowB, columnId) => {
+	return compareAlphanumeric(toString(rowA.getValue(columnId)), toString(rowB.getValue(columnId)));
+};
+/**
+* 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 = (rowA, rowB, columnId) => {
+	return compareBasic(toString(rowA.getValue(columnId)).toLowerCase(), toString(rowB.getValue(columnId)).toLowerCase());
+};
+/**
+* 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 = (rowA, rowB, columnId) => {
+	return compareBasic(toString(rowA.getValue(columnId)), toString(rowB.getValue(columnId)));
+};
+/**
+* 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 = (rowA, rowB, columnId) => {
+	const a = rowA.getValue(columnId);
+	const b = rowB.getValue(columnId);
+	return a > b ? 1 : a < b ? -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 = (rowA, rowB, columnId) => {
+	return compareBasic(rowA.getValue(columnId), rowB.getValue(columnId));
+};
+function compareBasic(a, b) {
+	return a === b ? 0 : a > b ? 1 : -1;
+}
+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) {
+	const a = aStr.split(reSplitAlphaNumeric).filter(Boolean);
+	const b = bStr.split(reSplitAlphaNumeric).filter(Boolean);
+	let ai = 0;
+	let bi = 0;
+	const aLen = a.length;
+	const bLen = b.length;
+	while (ai < aLen && bi < bLen) {
+		const aa = a[ai++];
+		const bb = b[bi++];
+		const an = parseInt(aa, 10);
+		const bn = parseInt(bb, 10);
+		const combo = [an, bn].sort();
+		if (isNaN(combo[0])) {
+			if (aa > bb) return 1;
+			if (bb > aa) return -1;
+			continue;
+		}
+		if (isNaN(combo[1])) return isNaN(an) ? -1 : 1;
+		if (an > bn) return 1;
+		if (bn > an) return -1;
+	}
+	return aLen - ai - (bLen - bi);
+}
+/**
+* The built-in sorting function registry.
+*
+* Pass this object to sorted row model creation or extend it with custom sorting functions.
+*/
+const sortFns = {
+	alphanumeric: sortFn_alphanumeric,
+	alphanumericCaseSensitive: sortFn_alphanumericCaseSensitive,
+	basic: sortFn_basic,
+	datetime: sortFn_datetime,
+	text: sortFn_text,
+	textCaseSensitive: sortFn_textCaseSensitive
+};
+
+//#endregion
+export { reSplitAlphaNumeric, sortFn_alphanumeric, sortFn_alphanumericCaseSensitive, sortFn_basic, sortFn_datetime, sortFn_text, sortFn_textCaseSensitive, sortFns };
+//# sourceMappingURL=sortFns.js.map

package/dist/fns/sortFns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortFns.js","names":[],"sources":["../../src/fns/sortFns.ts"],"sourcesContent":["import type { RowData } from '../types/type-utils'\nimport type { TableFeatures } from '../types/TableFeatures'\nimport type { Row } from '../types/Row'\nimport type { SortFn } from '../features/row-sorting/rowSortingFeature.types'\n\n/**\n * Regular expression used to split mixed text and numeric chunks.\n *\n * The alphanumeric sort functions use these chunks for natural sorting of\n * strings like `item2` before `item10`.\n */\nexport const reSplitAlphaNumeric = /([0-9]+)/gm\n\n/**\n * Sorts rows with the built-in alphanumeric strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_alphanumeric: SortFn<any, any> = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  rowA: Row<any, any>,\n  rowB: Row<any, any>,\n  columnId: string,\n) => {\n  return compareAlphanumeric(\n    toString(rowA.getValue(columnId)).toLowerCase(),\n    toString(rowB.getValue(columnId)).toLowerCase(),\n  )\n}\n\n/**\n * Sorts rows with the built-in alphanumeric case sensitive strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_alphanumericCaseSensitive: SortFn<any, any> = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  rowA: Row<any, any>,\n  rowB: Row<any, any>,\n  columnId: string,\n) => {\n  return compareAlphanumeric(\n    toString(rowA.getValue(columnId)),\n    toString(rowB.getValue(columnId)),\n  )\n}\n\n// The text filter is more basic (less numeric support)\n// but is much faster\n/**\n * Sorts rows with the built-in text strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_text: SortFn<any, any> = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  rowA: Row<any, any>,\n  rowB: Row<any, any>,\n  columnId: string,\n) => {\n  return compareBasic(\n    toString(rowA.getValue(columnId)).toLowerCase(),\n    toString(rowB.getValue(columnId)).toLowerCase(),\n  )\n}\n\n// The text filter is more basic (less numeric support)\n// but is much faster\n/**\n * Sorts rows with the built-in text case sensitive strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_textCaseSensitive: SortFn<any, any> = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  rowA: Row<any, any>,\n  rowB: Row<any, any>,\n  columnId: string,\n) => {\n  return compareBasic(\n    toString(rowA.getValue(columnId)),\n    toString(rowB.getValue(columnId)),\n  )\n}\n\n/**\n * Sorts rows with the built-in datetime strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_datetime: SortFn<any, any> = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  rowA: Row<any, any>,\n  rowB: Row<any, any>,\n  columnId: string,\n) => {\n  const a: number | string = rowA.getValue(columnId)\n  const b: number | string = rowB.getValue(columnId)\n\n  // Can handle nullish values\n  // Use > and < because == (and ===) doesn't work with\n  // Date objects (would require calling getTime()).\n  return a > b ? 1 : a < b ? -1 : 0\n}\n\n/**\n * Sorts rows with the built-in basic strategy.\n *\n * This comparator returns ascending-order results; descending order is applied by the sorting row model.\n */\nexport const sortFn_basic: SortFn<any, any> = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  rowA: Row<any, any>,\n  rowB: Row<any, any>,\n  columnId: string,\n) => {\n  return compareBasic(rowA.getValue(columnId), rowB.getValue(columnId))\n}\n\n// Utils\n\nfunction compareBasic(a: any, b: any) {\n  return a === b ? 0 : a > b ? 1 : -1\n}\n\nfunction toString(a: any) {\n  if (typeof a === 'number') {\n    if (isNaN(a) || a === Infinity || a === -Infinity) {\n      return ''\n    }\n    return String(a)\n  }\n  if (typeof a === 'string') {\n    return a\n  }\n  return ''\n}\n\n// Mixed sorting is slow, but very inclusive of many edge cases.\n// It handles numbers, mixed alphanumeric combinations, and even\n// null, undefined, and Infinity\nfunction compareAlphanumeric(aStr: string, bStr: string) {\n  // Split on number groups, but keep the delimiter\n  // Then remove falsey split values\n  const a = aStr.split(reSplitAlphaNumeric).filter(Boolean)\n  const b = bStr.split(reSplitAlphaNumeric).filter(Boolean)\n\n  let ai = 0\n  let bi = 0\n  const aLen = a.length\n  const bLen = b.length\n\n  while (ai < aLen && bi < bLen) {\n    const aa = a[ai++]!\n    const bb = b[bi++]!\n\n    const an = parseInt(aa, 10)\n    const bn = parseInt(bb, 10)\n\n    const combo = [an, bn].sort()\n\n    // Both are string\n    if (isNaN(combo[0]!)) {\n      if (aa > bb) {\n        return 1\n      }\n      if (bb > aa) {\n        return -1\n      }\n      continue\n    }\n\n    // One is a string, one is a number\n    if (isNaN(combo[1]!)) {\n      return isNaN(an) ? -1 : 1\n    }\n\n    // Both are numbers\n    if (an > bn) {\n      return 1\n    }\n    if (bn > an) {\n      return -1\n    }\n  }\n\n  return aLen - ai - (bLen - bi)\n}\n\n// Exports\n\n/**\n * The built-in sorting function registry.\n *\n * Pass this object to sorted row model creation or extend it with custom sorting functions.\n */\nexport const sortFns = {\n  alphanumeric: sortFn_alphanumeric,\n  alphanumericCaseSensitive: sortFn_alphanumericCaseSensitive,\n  basic: sortFn_basic,\n  datetime: sortFn_datetime,\n  text: sortFn_text,\n  textCaseSensitive: sortFn_textCaseSensitive,\n}\n\nexport type BuiltInSortFn = keyof typeof sortFns\n"],"mappings":";;;;;;;AAWA,MAAa,sBAAsB;;;;;;AAOnC,MAAa,uBAIX,MACA,MACA,aACG;CACH,OAAO,oBACL,SAAS,KAAK,SAAS,QAAQ,CAAC,CAAC,CAAC,YAAY,GAC9C,SAAS,KAAK,SAAS,QAAQ,CAAC,CAAC,CAAC,YAAY,CAChD;AACF;;;;;;AAOA,MAAa,oCAIX,MACA,MACA,aACG;CACH,OAAO,oBACL,SAAS,KAAK,SAAS,QAAQ,CAAC,GAChC,SAAS,KAAK,SAAS,QAAQ,CAAC,CAClC;AACF;;;;;;AASA,MAAa,eAIX,MACA,MACA,aACG;CACH,OAAO,aACL,SAAS,KAAK,SAAS,QAAQ,CAAC,CAAC,CAAC,YAAY,GAC9C,SAAS,KAAK,SAAS,QAAQ,CAAC,CAAC,CAAC,YAAY,CAChD;AACF;;;;;;AASA,MAAa,4BAIX,MACA,MACA,aACG;CACH,OAAO,aACL,SAAS,KAAK,SAAS,QAAQ,CAAC,GAChC,SAAS,KAAK,SAAS,QAAQ,CAAC,CAClC;AACF;;;;;;AAOA,MAAa,mBAIX,MACA,MACA,aACG;CACH,MAAM,IAAqB,KAAK,SAAS,QAAQ;CACjD,MAAM,IAAqB,KAAK,SAAS,QAAQ;CAKjD,OAAO,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK;AAClC;;;;;;AAOA,MAAa,gBAIX,MACA,MACA,aACG;CACH,OAAO,aAAa,KAAK,SAAS,QAAQ,GAAG,KAAK,SAAS,QAAQ,CAAC;AACtE;AAIA,SAAS,aAAa,GAAQ,GAAQ;CACpC,OAAO,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI;AACnC;AAEA,SAAS,SAAS,GAAQ;CACxB,IAAI,OAAO,MAAM,UAAU;EACzB,IAAI,MAAM,CAAC,KAAK,MAAM,YAAY,MAAM,WACtC,OAAO;EAET,OAAO,OAAO,CAAC;CACjB;CACA,IAAI,OAAO,MAAM,UACf,OAAO;CAET,OAAO;AACT;AAKA,SAAS,oBAAoB,MAAc,MAAc;CAGvD,MAAM,IAAI,KAAK,MAAM,mBAAmB,CAAC,CAAC,OAAO,OAAO;CACxD,MAAM,IAAI,KAAK,MAAM,mBAAmB,CAAC,CAAC,OAAO,OAAO;CAExD,IAAI,KAAK;CACT,IAAI,KAAK;CACT,MAAM,OAAO,EAAE;CACf,MAAM,OAAO,EAAE;CAEf,OAAO,KAAK,QAAQ,KAAK,MAAM;EAC7B,MAAM,KAAK,EAAE;EACb,MAAM,KAAK,EAAE;EAEb,MAAM,KAAK,SAAS,IAAI,EAAE;EAC1B,MAAM,KAAK,SAAS,IAAI,EAAE;EAE1B,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK;EAG5B,IAAI,MAAM,MAAM,EAAG,GAAG;GACpB,IAAI,KAAK,IACP,OAAO;GAET,IAAI,KAAK,IACP,OAAO;GAET;EACF;EAGA,IAAI,MAAM,MAAM,EAAG,GACjB,OAAO,MAAM,EAAE,IAAI,KAAK;EAI1B,IAAI,KAAK,IACP,OAAO;EAET,IAAI,KAAK,IACP,OAAO;CAEX;CAEA,OAAO,OAAO,MAAM,OAAO;AAC7B;;;;;;AASA,MAAa,UAAU;CACrB,cAAc;CACd,2BAA2B;CAC3B,OAAO;CACP,UAAU;CACV,MAAM;CACN,mBAAmB;AACrB"}

package/dist/helpers/columnHelper.cjs

@@ -0,0 +1,41 @@
+
+//#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

@@ -0,0 +1 @@
+{"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 type ColumnHelper<\n  TFeatures extends TableFeatures,\n  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

@@ -0,0 +1,71 @@
+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
+type ColumnHelper<TFeatures extends TableFeatures, 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.d.ts

@@ -0,0 +1,71 @@
+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> = {
+  /**
+   * 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.ts.map

package/dist/helpers/columnHelper.js

@@ -0,0 +1,40 @@
+//#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
+export { createColumnHelper };
+//# sourceMappingURL=columnHelper.js.map

package/dist/helpers/columnHelper.js.map

@@ -0,0 +1 @@
+{"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 type ColumnHelper<\n  TFeatures extends TableFeatures,\n  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/tableFeatures.cjs

@@ -0,0 +1,20 @@
+
+//#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.
+* @example
+* ```
+* import { tableFeatures, columnVisibilityFeature, rowPinningFeature } from '@tanstack/react-table'
+* const features = tableFeatures({ columnVisibilityFeature, rowPinningFeature });
+* const table = useTable({ features, rowModels: {}, columns, data });
+* ```
+*/
+function tableFeatures(features) {
+	return features;
+}
+
+//#endregion
+exports.tableFeatures = tableFeatures;
+//# sourceMappingURL=tableFeatures.cjs.map

package/dist/helpers/tableFeatures.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tableFeatures.cjs","names":[],"sources":["../../src/helpers/tableFeatures.ts"],"sourcesContent":["import type { TableFeatures } 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 * @example\n * ```\n * import { tableFeatures, columnVisibilityFeature, rowPinningFeature } from '@tanstack/react-table'\n * const features = tableFeatures({ columnVisibilityFeature, rowPinningFeature });\n * const table = useTable({ features, rowModels: {}, columns, data });\n * ```\n */\nexport function tableFeatures<TFeatures extends TableFeatures>(\n  features: TFeatures,\n): TFeatures {\n  return features\n}\n\n// test\n\n// const features = tableFeatures({\n//   rowPinningFeature: {},\n// });\n"],"mappings":";;;;;;;;;;;;;AAaA,SAAgB,cACd,UACW;CACX,OAAO;AACT"}

package/dist/helpers/tableFeatures.d.cts

@@ -0,0 +1,18 @@
+import { TableFeatures } 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.
+ * @example
+ * ```
+ * import { tableFeatures, columnVisibilityFeature, rowPinningFeature } from '@tanstack/react-table'
+ * const features = tableFeatures({ columnVisibilityFeature, rowPinningFeature });
+ * const table = useTable({ features, rowModels: {}, columns, data });
+ * ```
+ */
+declare function tableFeatures<TFeatures extends TableFeatures>(features: TFeatures): TFeatures;
+//#endregion
+export { tableFeatures };
+//# sourceMappingURL=tableFeatures.d.cts.map

package/dist/helpers/tableFeatures.d.ts

@@ -0,0 +1,18 @@
+import { TableFeatures } 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.
+ * @example
+ * ```
+ * import { tableFeatures, columnVisibilityFeature, rowPinningFeature } from '@tanstack/react-table'
+ * const features = tableFeatures({ columnVisibilityFeature, rowPinningFeature });
+ * const table = useTable({ features, rowModels: {}, columns, data });
+ * ```
+ */
+declare function tableFeatures<TFeatures extends TableFeatures>(features: TFeatures): TFeatures;
+//#endregion
+export { tableFeatures };
+//# sourceMappingURL=tableFeatures.d.ts.map

package/dist/helpers/tableFeatures.js

@@ -0,0 +1,19 @@
+//#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.
+* @example
+* ```
+* import { tableFeatures, columnVisibilityFeature, rowPinningFeature } from '@tanstack/react-table'
+* const features = tableFeatures({ columnVisibilityFeature, rowPinningFeature });
+* const table = useTable({ features, rowModels: {}, columns, data });
+* ```
+*/
+function tableFeatures(features) {
+	return features;
+}
+
+//#endregion
+export { tableFeatures };
+//# sourceMappingURL=tableFeatures.js.map

package/dist/helpers/tableFeatures.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tableFeatures.js","names":[],"sources":["../../src/helpers/tableFeatures.ts"],"sourcesContent":["import type { TableFeatures } 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 * @example\n * ```\n * import { tableFeatures, columnVisibilityFeature, rowPinningFeature } from '@tanstack/react-table'\n * const features = tableFeatures({ columnVisibilityFeature, rowPinningFeature });\n * const table = useTable({ features, rowModels: {}, columns, data });\n * ```\n */\nexport function tableFeatures<TFeatures extends TableFeatures>(\n  features: TFeatures,\n): TFeatures {\n  return features\n}\n\n// test\n\n// const features = tableFeatures({\n//   rowPinningFeature: {},\n// });\n"],"mappings":";;;;;;;;;;;;AAaA,SAAgB,cACd,UACW;CACX,OAAO;AACT"}

package/dist/helpers/tableOptions.cjs

@@ -0,0 +1,15 @@
+
+//#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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,57 @@
+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.d.ts

@@ -0,0 +1,57 @@
+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`.
+ *
+ * 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.ts.map

package/dist/helpers/tableOptions.js

@@ -0,0 +1,14 @@
+//#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
+export { tableOptions };
+//# sourceMappingURL=tableOptions.js.map

package/dist/helpers/tableOptions.js.map

@@ -0,0 +1 @@
+{"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"}