@tanstack/react-table 9.0.0-alpha.0 → 9.0.0-alpha.11

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from '@tanstack/table-core'
+
+export * from './FlexRender'
+export * from './Subscribe'
+export * from './createTableHook'
+export * from './useLegacyTable'
+export * from './useTable'

package/src/useLegacyTable.ts

@@ -0,0 +1,370 @@
+'use client'
+
+import {
+  aggregationFns,
+  createExpandedRowModel,
+  createFacetedMinMaxValues,
+  createFacetedRowModel,
+  createFacetedUniqueValues,
+  createFilteredRowModel,
+  createGroupedRowModel,
+  createPaginatedRowModel,
+  createSortedRowModel,
+  filterFns,
+  sortFns,
+  stockFeatures,
+} from '@tanstack/table-core'
+import { useMemo } from 'react'
+import { useStore } from '@tanstack/react-store'
+import { useTable } from './useTable'
+import type {
+  CreateRowModels_All,
+  RowData,
+  RowModel,
+  StockFeatures,
+  Table,
+  TableOptions,
+  TableState,
+} from '@tanstack/table-core'
+import type { ReactTable } from './useTable'
+
+// =============================================================================
+// V8-style row model factory functions
+// These are stub functions that act as markers for useLegacyTable to know
+// which row models to enable. They don't actually do anything - the real
+// implementation is handled by useLegacyTable internally.
+// =============================================================================
+
+/**
+ * @deprecated Use `createFilteredRowModel(filterFns)` with the new `useTable` hook instead.
+ *
+ * This is a stub function for v8 API compatibility with `useLegacyTable`.
+ * It acts as a marker to enable the filtered row model.
+ */
+export function getFilteredRowModel<
+  TData extends RowData,
+>(): RowModelFactory<TData> {
+  return (() => () => {}) as unknown as RowModelFactory<TData>
+}
+
+/**
+ * @deprecated Use `createSortedRowModel(sortFns)` with the new `useTable` hook instead.
+ *
+ * This is a stub function for v8 API compatibility with `useLegacyTable`.
+ * It acts as a marker to enable the sorted row model.
+ */
+export function getSortedRowModel<
+  TData extends RowData,
+>(): RowModelFactory<TData> {
+  return (() => () => {}) as unknown as RowModelFactory<TData>
+}
+
+/**
+ * @deprecated Use `createPaginatedRowModel()` with the new `useTable` hook instead.
+ *
+ * This is a stub function for v8 API compatibility with `useLegacyTable`.
+ * It acts as a marker to enable the paginated row model.
+ */
+export function getPaginationRowModel<
+  TData extends RowData,
+>(): RowModelFactory<TData> {
+  return (() => () => {}) as unknown as RowModelFactory<TData>
+}
+
+/**
+ * @deprecated Use `createExpandedRowModel()` with the new `useTable` hook instead.
+ *
+ * This is a stub function for v8 API compatibility with `useLegacyTable`.
+ * It acts as a marker to enable the expanded row model.
+ */
+export function getExpandedRowModel<
+  TData extends RowData,
+>(): RowModelFactory<TData> {
+  return (() => () => {}) as unknown as RowModelFactory<TData>
+}
+
+/**
+ * @deprecated Use `createGroupedRowModel(aggregationFns)` with the new `useTable` hook instead.
+ *
+ * This is a stub function for v8 API compatibility with `useLegacyTable`.
+ * It acts as a marker to enable the grouped row model.
+ */
+export function getGroupedRowModel<
+  TData extends RowData,
+>(): RowModelFactory<TData> {
+  return (() => () => {}) as unknown as RowModelFactory<TData>
+}
+
+/**
+ * @deprecated Use `createFacetedRowModel()` with the new `useTable` hook instead.
+ *
+ * This is a stub function for v8 API compatibility with `useLegacyTable`.
+ * It acts as a marker to enable the faceted row model.
+ */
+export function getFacetedRowModel<
+  TData extends RowData,
+>(): FacetedRowModelFactory<TData> {
+  return (() => () => {}) as unknown as FacetedRowModelFactory<TData>
+}
+
+/**
+ * @deprecated Use `createFacetedMinMaxValues()` with the new `useTable` hook instead.
+ *
+ * This is a stub function for v8 API compatibility with `useLegacyTable`.
+ * It acts as a marker to enable the faceted min/max values.
+ */
+export function getFacetedMinMaxValues<
+  TData extends RowData,
+>(): FacetedMinMaxValuesFactory<TData> {
+  return (() => () => undefined) as unknown as FacetedMinMaxValuesFactory<TData>
+}
+
+/**
+ * @deprecated Use `createFacetedUniqueValues()` with the new `useTable` hook instead.
+ *
+ * This is a stub function for v8 API compatibility with `useLegacyTable`.
+ * It acts as a marker to enable the faceted unique values.
+ */
+export function getFacetedUniqueValues<
+  TData extends RowData,
+>(): FacetedUniqueValuesFactory<TData> {
+  return (() => () => new Map()) as unknown as FacetedUniqueValuesFactory<TData>
+}
+
+/**
+ * @deprecated The core row model is always created automatically in v9.
+ *
+ * This is a stub function for v8 API compatibility with `useLegacyTable`.
+ * It does nothing - the core row model is always available.
+ */
+export function getCoreRowModel<
+  TData extends RowData,
+>(): RowModelFactory<TData> {
+  return (() => () => {}) as unknown as RowModelFactory<TData>
+}
+
+// =============================================================================
+// Type definitions
+// =============================================================================
+
+/**
+ * Row model factory function type from v8 API
+ */
+type RowModelFactory<TData extends RowData> = (
+  table: Table<StockFeatures, TData>,
+) => () => RowModel<StockFeatures, TData>
+
+/**
+ * Faceted row model factory function type from v8 API
+ */
+type FacetedRowModelFactory<TData extends RowData> = (
+  table: Table<StockFeatures, TData>,
+  columnId: string,
+) => () => RowModel<StockFeatures, TData>
+
+/**
+ * Faceted min/max values factory function type from v8 API
+ */
+type FacetedMinMaxValuesFactory<TData extends RowData> = (
+  table: Table<StockFeatures, TData>,
+  columnId: string,
+) => () => undefined | [number, number]
+
+/**
+ * Faceted unique values factory function type from v8 API
+ */
+type FacetedUniqueValuesFactory<TData extends RowData> = (
+  table: Table<StockFeatures, TData>,
+  columnId: string,
+) => () => Map<any, number>
+
+/**
+ * Legacy v8-style row model options
+ */
+export interface LegacyRowModelOptions<TData extends RowData> {
+  /**
+   * Returns the core row model for the table.
+   * @deprecated This option is no longer needed in v9. The core row model is always created automatically.
+   */
+  getCoreRowModel?: RowModelFactory<TData>
+  /**
+   * Returns the filtered row model for the table.
+   * @deprecated Use `_rowModels.filteredRowModel` with `createFilteredRowModel(filterFns)` instead.
+   */
+  getFilteredRowModel?: RowModelFactory<TData>
+  /**
+   * Returns the sorted row model for the table.
+   * @deprecated Use `_rowModels.sortedRowModel` with `createSortedRowModel(sortFns)` instead.
+   */
+  getSortedRowModel?: RowModelFactory<TData>
+  /**
+   * Returns the paginated row model for the table.
+   * @deprecated Use `_rowModels.paginatedRowModel` with `createPaginatedRowModel()` instead.
+   */
+  getPaginationRowModel?: RowModelFactory<TData>
+  /**
+   * Returns the expanded row model for the table.
+   * @deprecated Use `_rowModels.expandedRowModel` with `createExpandedRowModel()` instead.
+   */
+  getExpandedRowModel?: RowModelFactory<TData>
+  /**
+   * Returns the grouped row model for the table.
+   * @deprecated Use `_rowModels.groupedRowModel` with `createGroupedRowModel(aggregationFns)` instead.
+   */
+  getGroupedRowModel?: RowModelFactory<TData>
+  /**
+   * Returns the faceted row model for a column.
+   * @deprecated Use `_rowModels.facetedRowModel` with `createFacetedRowModel()` instead.
+   */
+  getFacetedRowModel?: FacetedRowModelFactory<TData>
+  /**
+   * Returns the faceted min/max values for a column.
+   * @deprecated Use `_rowModels.facetedMinMaxValues` with `createFacetedMinMaxValues()` instead.
+   */
+  getFacetedMinMaxValues?: FacetedMinMaxValuesFactory<TData>
+  /**
+   * Returns the faceted unique values for a column.
+   * @deprecated Use `_rowModels.facetedUniqueValues` with `createFacetedUniqueValues()` instead.
+   */
+  getFacetedUniqueValues?: FacetedUniqueValuesFactory<TData>
+}
+
+/**
+ * Legacy v8-style table options that work with useLegacyTable.
+ *
+ * This type omits `_features` and `_rowModels` and instead accepts the v8-style
+ * `get*RowModel` function options.
+ *
+ * @deprecated This is a compatibility layer for migrating from v8. Use `useTable` with explicit `_features` and `_rowModels` instead.
+ */
+export type LegacyTableOptions<TData extends RowData> = Omit<
+  TableOptions<StockFeatures, TData>,
+  '_features' | '_rowModels'
+> &
+  LegacyRowModelOptions<TData>
+
+/**
+ * Legacy table instance type that includes the v8-style `getState()` method.
+ *
+ * @deprecated Use `useTable` with explicit state selection instead.
+ */
+export type LegacyReactTable<TData extends RowData> = ReactTable<
+  StockFeatures,
+  TData,
+  TableState<StockFeatures>
+> & {
+  /**
+   * Returns the current table state.
+   * @deprecated In v9, access state directly via `table.state` or use `table.store.state` for the full state.
+   */
+  getState: () => TableState<StockFeatures>
+}
+
+/**
+ * @deprecated This hook is provided as a compatibility layer for migrating from TanStack Table v8.
+ *
+ * Use the new `useTable` hook instead with explicit `_features` and `_rowModels`:
+ *
+ * ```tsx
+ * // New v9 API
+ * const _features = tableFeatures({
+ *   columnFilteringFeature,
+ *   rowSortingFeature,
+ *   rowPaginationFeature,
+ * })
+ *
+ * const table = useTable({
+ *   _features,
+ *   _rowModels: {
+ *     filteredRowModel: createFilteredRowModel(filterFns),
+ *     sortedRowModel: createSortedRowModel(sortFns),
+ *     paginatedRowModel: createPaginatedRowModel(),
+ *   },
+ *   columns,
+ *   data,
+ * })
+ * ```
+ *
+ * Key differences from v8:
+ * - Features are tree-shakeable - only import what you use
+ * - Row models are explicitly passed via `_rowModels`
+ * - Use `table.Subscribe` for fine-grained re-renders
+ * - State is accessed via `table.state` after selecting with the 2nd argument
+ *
+ * @param options - Legacy v8-style table options
+ * @returns A table instance with the full state subscribed and a `getState()` method
+ */
+export function useLegacyTable<TData extends RowData>(
+  options: LegacyTableOptions<TData>,
+): LegacyReactTable<TData> {
+  const {
+    // Extract legacy row model options
+    getCoreRowModel: _getCoreRowModel,
+    getFilteredRowModel,
+    getSortedRowModel,
+    getPaginationRowModel,
+    getExpandedRowModel,
+    getGroupedRowModel,
+    getFacetedRowModel,
+    getFacetedMinMaxValues,
+    getFacetedUniqueValues,
+    // Rest of the options
+    ...restOptions
+  } = options
+
+  // Build the _rowModels object based on which legacy options were provided
+  const _rowModels: CreateRowModels_All<StockFeatures, TData> = {}
+
+  // Map v8 row model factories to v9 _rowModels
+  // Note: getCoreRowModel is handled automatically in v9, so we ignore it
+
+  if (getFilteredRowModel) {
+    _rowModels.filteredRowModel = createFilteredRowModel(filterFns)
+  }
+
+  if (getSortedRowModel) {
+    _rowModels.sortedRowModel = createSortedRowModel(sortFns)
+  }
+
+  if (getPaginationRowModel) {
+    _rowModels.paginatedRowModel = createPaginatedRowModel()
+  }
+
+  if (getExpandedRowModel) {
+    _rowModels.expandedRowModel = createExpandedRowModel()
+  }
+
+  if (getGroupedRowModel) {
+    _rowModels.groupedRowModel = createGroupedRowModel(aggregationFns)
+  }
+
+  if (getFacetedRowModel) {
+    _rowModels.facetedRowModel = createFacetedRowModel()
+  }
+
+  if (getFacetedMinMaxValues) {
+    _rowModels.facetedMinMaxValues = createFacetedMinMaxValues()
+  }
+
+  if (getFacetedUniqueValues) {
+    _rowModels.facetedUniqueValues = createFacetedUniqueValues()
+  }
+
+  // Call useTable with the v9 API, subscribing to all state changes
+  const table = useTable<StockFeatures, TData, TableState<StockFeatures>>({
+    ...restOptions,
+    _features: stockFeatures,
+    _rowModels,
+  } as TableOptions<StockFeatures, TData>)
+
+  const state = useStore(table.store, (state) => state)
+
+  return useMemo(
+    () =>
+      ({
+        ...table,
+        getState: () => state,
+      }) as LegacyReactTable<TData>,
+    [table, state],
+  )
+}

package/src/useTable.ts

@@ -0,0 +1,139 @@
+'use client'
+import { useEffect, useLayoutEffect, useMemo, useState } from 'react'
+import { constructTable } from '@tanstack/table-core'
+import { useStore } from '@tanstack/react-store'
+import { FlexRender } from './FlexRender'
+import { Subscribe } from './Subscribe'
+import type {
+  CellData,
+  NoInfer,
+  RowData,
+  Table,
+  TableFeatures,
+  TableOptions,
+  TableState,
+} from '@tanstack/table-core'
+import type { FunctionComponent, ReactNode } from 'react'
+import type { FlexRenderProps } from './FlexRender'
+import type { SubscribeProps } from './Subscribe'
+
+const useIsomorphicLayoutEffect =
+  typeof window !== 'undefined' ? useLayoutEffect : useEffect
+
+export type ReactTable<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+  TSelected = {},
+> = Table<TFeatures, TData> & {
+  /**
+   * A React HOC (Higher Order Component) that allows you to subscribe to the table state.
+   *
+   * This is useful for opting into state re-renders for specific parts of the table state.
+   *
+   * @example
+   * <table.Subscribe selector={(state) => ({ rowSelection: state.rowSelection })}>
+   *   {({ rowSelection }) => ( // important to include `{() => {()}}` syntax
+   *     <tr key={row.id}>
+            // render the row
+   *     </tr>
+   *   ))}
+   * </table.Subscribe>
+   */
+  Subscribe: <TSelected>(props: {
+    selector: (state: NoInfer<TableState<TFeatures>>) => TSelected
+    children: ((state: TSelected) => ReactNode) | ReactNode
+  }) => ReturnType<FunctionComponent>
+  /**
+   * A React component that renders headers, cells, or footers with custom markup.
+   * Use this utility component instead of manually calling flexRender.
+   *
+   * @example
+   * ```tsx
+   * <table.FlexRender cell={cell} />
+   * <table.FlexRender header={header} />
+   * <table.FlexRender footer={footer} />
+   * ```
+   *
+   * This replaces calling `flexRender` directly like this:
+   * ```tsx
+   * flexRender(cell.column.columnDef.cell, cell.getContext())
+   * flexRender(header.column.columnDef.header, header.getContext())
+   * flexRender(footer.column.columnDef.footer, footer.getContext())
+   * ```
+   */
+  FlexRender: <TValue extends CellData = CellData>(
+    props: FlexRenderProps<TFeatures, TData, TValue>,
+  ) => ReactNode
+  /**
+   * The selected state of the table. This state may not match the structure of `table.store.state` because it is selected by the `selector` function that you pass as the 2nd argument to `useTable`.
+   *
+   * @example
+   * const table = useTable(options, (state) => ({ globalFilter: state.globalFilter })) // only globalFilter is part of the selected state
+   *
+   * console.log(table.state.globalFilter)
+   */
+  readonly state: Readonly<TSelected>
+}
+
+export function useTable<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+  TSelected = {},
+>(
+  tableOptions: TableOptions<TFeatures, TData>,
+  selector: (state: TableState<TFeatures>) => TSelected = () =>
+    ({}) as TSelected,
+): ReactTable<TFeatures, TData, TSelected> {
+  const [table] = useState(() => {
+    const tableInstance = constructTable(tableOptions) as ReactTable<
+      TFeatures,
+      TData,
+      TSelected
+    >
+
+    tableInstance.Subscribe = function SubscribeBound<TSelected>(
+      props: Omit<SubscribeProps<TFeatures, TData, TSelected>, 'table'>,
+    ) {
+      return Subscribe({ ...props, table: tableInstance })
+    }
+
+    tableInstance.FlexRender = FlexRender
+
+    return tableInstance
+  })
+
+  // sync table options on every render
+  table.setOptions((prev) => ({
+    ...prev,
+    ...tableOptions,
+  }))
+
+  // Mount the derived store to register it on the dependency graph
+  useIsomorphicLayoutEffect(() => {
+    const cleanup = table.store.mount()
+    return cleanup
+  }, [table])
+
+  useIsomorphicLayoutEffect(() => {
+    // prevent race condition between table.setOptions and table.baseStore.setState
+    queueMicrotask(() => {
+      table.baseStore.setState((prev) => ({
+        ...prev,
+      }))
+    })
+  }, [
+    table.options.columns, // re-render when columns change
+    table.options.data, // re-render when data changes
+    table.options.state, // sync react state to the table store
+  ])
+
+  const state = useStore(table.store, selector)
+
+  return useMemo(
+    () => ({
+      ...table,
+      state,
+    }),
+    [state, table],
+  )
+}

package/dist/cjs/index.cjs

@@ -1,78 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const jsxRuntime = require("react/jsx-runtime");
-const React = require("react");
-const tableCore = require("@tanstack/table-core");
-function _interopNamespaceDefault(e) {
-  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
-  if (e) {
-    for (const k in e) {
-      if (k !== "default") {
-        const d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: () => e[k]
-        });
-      }
-    }
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-const React__namespace = /* @__PURE__ */ _interopNamespaceDefault(React);
-function flexRender(Comp, props) {
-  return !Comp ? null : isReactComponent(Comp) ? /* @__PURE__ */ jsxRuntime.jsx(Comp, { ...props }) : Comp;
-}
-function isReactComponent(component) {
-  return isClassComponent(component) || typeof component === "function" || isExoticComponent(component);
-}
-function isClassComponent(component) {
-  return typeof component === "function" && (() => {
-    const proto = Object.getPrototypeOf(component);
-    return proto.prototype && proto.prototype.isReactComponent;
-  })();
-}
-function isExoticComponent(component) {
-  return typeof component === "object" && typeof component.$$typeof === "symbol" && ["react.memo", "react.forward_ref"].includes(component.$$typeof.description);
-}
-function useReactTable(options) {
-  const resolvedOptions = {
-    state: {},
-    // Dummy state
-    onStateChange: () => {
-    },
-    // noop
-    renderFallbackValue: null,
-    ...options
-  };
-  const [tableRef] = React__namespace.useState(() => ({
-    current: tableCore.createTable(resolvedOptions)
-  }));
-  const [state, setState] = React__namespace.useState(() => tableRef.current.initialState);
-  tableRef.current.setOptions((prev) => ({
-    ...prev,
-    ...options,
-    state: {
-      ...state,
-      ...options.state
-    },
-    // Similarly, we'll maintain both our internal state and any user-provided
-    // state.
-    onStateChange: (updater) => {
-      var _a;
-      setState(updater);
-      (_a = options.onStateChange) == null ? void 0 : _a.call(options, updater);
-    }
-  }));
-  return tableRef.current;
-}
-exports.flexRender = flexRender;
-exports.useReactTable = useReactTable;
-Object.keys(tableCore).forEach((k) => {
-  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k))
-    Object.defineProperty(exports, k, {
-      enumerable: true,
-      get: () => tableCore[k]
-    });
-});
-//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","sources":["../../src/index.tsx"],"sourcesContent":["import * as React from 'react'\nexport * from '@tanstack/table-core'\n\nimport {\n  TableOptions,\n  TableOptionsResolved,\n  RowData,\n  createTable,\n} from '@tanstack/table-core'\n\nexport type Renderable<TProps> = React.ReactNode | React.ComponentType<TProps>\n\n//\n\n/**\n * If rendering headers, cells, or footers with custom markup, use flexRender instead of `cell.getValue()` or `cell.renderValue()`.\n */\nexport function flexRender<TProps extends object>(\n  Comp: Renderable<TProps>,\n  props: TProps\n): React.ReactNode | JSX.Element {\n  return !Comp ? null : isReactComponent<TProps>(Comp) ? (\n    <Comp {...props} />\n  ) : (\n    Comp\n  )\n}\n\nfunction isReactComponent<TProps>(\n  component: unknown\n): component is React.ComponentType<TProps> {\n  return (\n    isClassComponent(component) ||\n    typeof component === 'function' ||\n    isExoticComponent(component)\n  )\n}\n\nfunction isClassComponent(component: any) {\n  return (\n    typeof component === 'function' &&\n    (() => {\n      const proto = Object.getPrototypeOf(component)\n      return proto.prototype && proto.prototype.isReactComponent\n    })()\n  )\n}\n\nfunction isExoticComponent(component: any) {\n  return (\n    typeof component === 'object' &&\n    typeof component.$$typeof === 'symbol' &&\n    ['react.memo', 'react.forward_ref'].includes(component.$$typeof.description)\n  )\n}\n\nexport function useReactTable<TData extends RowData>(\n  options: TableOptions<TData>\n) {\n  // Compose in the generic options to the user options\n  const resolvedOptions: TableOptionsResolved<TData> = {\n    state: {}, // Dummy state\n    onStateChange: () => {}, // noop\n    renderFallbackValue: null,\n    ...options,\n  }\n\n  // Create a new table and store it in state\n  const [tableRef] = React.useState(() => ({\n    current: createTable<TData>(resolvedOptions),\n  }))\n\n  // By default, manage table state here using the table's initial state\n  const [state, setState] = React.useState(() => tableRef.current.initialState)\n\n  // Compose the default state above with any user state. This will allow the user\n  // to only control a subset of the state if desired.\n  tableRef.current.setOptions(prev => ({\n    ...prev,\n    ...options,\n    state: {\n      ...state,\n      ...options.state,\n    },\n    // Similarly, we'll maintain both our internal state and any user-provided\n    // state.\n    onStateChange: updater => {\n      setState(updater)\n      options.onStateChange?.(updater)\n    },\n  }))\n\n  return tableRef.current\n}\n"],"names":["jsx","React","createTable"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAiBgB,SAAA,WACd,MACA,OAC+B;AACxB,SAAA,CAAC,OAAO,OAAO,iBAAyB,IAAI,IAChDA,+BAAA,MAAA,EAAM,GAAG,MAAO,CAAA,IAEjB;AAEJ;AAEA,SAAS,iBACP,WAC0C;AAC1C,SACE,iBAAiB,SAAS,KAC1B,OAAO,cAAc,cACrB,kBAAkB,SAAS;AAE/B;AAEA,SAAS,iBAAiB,WAAgB;AAEtC,SAAA,OAAO,cAAc,eACpB,MAAM;AACC,UAAA,QAAQ,OAAO,eAAe,SAAS;AACtC,WAAA,MAAM,aAAa,MAAM,UAAU;AAAA,EAAA;AAGhD;AAEA,SAAS,kBAAkB,WAAgB;AACzC,SACE,OAAO,cAAc,YACrB,OAAO,UAAU,aAAa,YAC9B,CAAC,cAAc,mBAAmB,EAAE,SAAS,UAAU,SAAS,WAAW;AAE/E;AAEO,SAAS,cACd,SACA;AAEA,QAAM,kBAA+C;AAAA,IACnD,OAAO,CAAC;AAAA;AAAA,IACR,eAAe,MAAM;AAAA,IAAC;AAAA;AAAA,IACtB,qBAAqB;AAAA,IACrB,GAAG;AAAA,EAAA;AAIL,QAAM,CAAC,QAAQ,IAAIC,iBAAM,SAAS,OAAO;AAAA,IACvC,SAASC,sBAAmB,eAAe;AAAA,EAC3C,EAAA;AAGI,QAAA,CAAC,OAAO,QAAQ,IAAID,iBAAM,SAAS,MAAM,SAAS,QAAQ,YAAY;AAInE,WAAA,QAAQ,WAAW,CAAS,UAAA;AAAA,IACnC,GAAG;AAAA,IACH,GAAG;AAAA,IACH,OAAO;AAAA,MACL,GAAG;AAAA,MACH,GAAG,QAAQ;AAAA,IACb;AAAA;AAAA;AAAA,IAGA,eAAe,CAAW,YAAA;;AACxB,eAAS,OAAO;AAChB,oBAAQ,kBAAR,iCAAwB;AAAA,IAC1B;AAAA,EACA,EAAA;AAEF,SAAO,SAAS;AAClB;;;;;;;;;;"}

package/dist/cjs/index.d.cts

@@ -1,9 +0,0 @@
-import { TableOptions, RowData } from '@tanstack/table-core';
-import * as React from 'react';
-export * from '@tanstack/table-core';
-export type Renderable<TProps> = React.ReactNode | React.ComponentType<TProps>;
-/**
- * If rendering headers, cells, or footers with custom markup, use flexRender instead of `cell.getValue()` or `cell.renderValue()`.
- */
-export declare function flexRender<TProps extends object>(Comp: Renderable<TProps>, props: TProps): React.ReactNode | JSX.Element;
-export declare function useReactTable<TData extends RowData>(options: TableOptions<TData>): import('@tanstack/table-core').Table<TData>;