react-shadcn-table 1.0.0

package/dist/lib/utils.d.ts

@@ -0,0 +1,2 @@
+import { ClassValue } from 'clsx';
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/package/contexts/grid/GridContext.d.ts

@@ -0,0 +1,4 @@
+import { RowData } from '@tanstack/react-table';
+import { GridContextProps, GridContextProviderProps } from './types';
+export declare const GridContext: import('react').Context<GridContextProps<any> | undefined>;
+export declare const GridContextProvider: <TableData extends RowData>({ children, columns, payload, name, state, onColumnFiltersChange, onPaginationChange, onSortingChange, setGlobalFilter, isError, isLoading, isFetching, refetch, manualFiltering, manualSorting, manualPagination, height, getRowCanExpand, renderSubComponent, onRowSelectionChange, enableCellSelection, enableCellSpanning, enableRowSelection, topRightSlot, }: GridContextProviderProps<TableData>) => import("react").JSX.Element;

package/dist/package/contexts/grid/types/index.d.ts

@@ -0,0 +1,58 @@
+import { GridFeatures } from '../../../features';
+import { ColumnDef, ColumnFiltersState, OnChangeFn, PaginationState, ReactTable, Row, RowData, RowSelectionState, SortingState, TableState } from '@tanstack/react-table';
+import { default as React } from 'react';
+export interface GridContextProps<TableData extends RowData = RowData> {
+    table: ReactTable<GridFeatures, TableData, TableState<GridFeatures>>;
+    paneRef1: React.RefObject<HTMLDivElement | null>;
+    paneRef2: React.RefObject<HTMLDivElement | null>;
+    paneRef3: React.RefObject<HTMLDivElement | null>;
+    paneRef4: React.RefObject<HTMLDivElement | null>;
+    paneRef5: React.RefObject<HTMLDivElement | null>;
+    paneRef6: React.RefObject<HTMLDivElement | null>;
+    gridWrapperRef: React.RefObject<HTMLDivElement | null>;
+    isSplit: boolean;
+    setIsSplit: React.Dispatch<React.SetStateAction<boolean>>;
+    isFetching?: boolean;
+    isLoading?: boolean;
+    isError?: boolean;
+    refetch?: () => void;
+    height?: string;
+    globalFilter: string;
+    setGlobalFilter?: React.Dispatch<React.SetStateAction<string>>;
+    renderSubComponent?: (props: {
+        row: Row<GridFeatures, TableData>;
+    }) => React.ReactElement;
+    name?: string;
+    topRightSlot?: React.ReactNode;
+}
+export interface GridContextProviderProps<TData extends RowData> {
+    children: React.ReactNode;
+    payload?: {
+        data: TData[];
+        total: number;
+    };
+    columns: ColumnDef<GridFeatures, TData>[];
+    name?: string;
+    height?: string;
+    state?: Partial<TableState<GridFeatures>>;
+    onColumnFiltersChange?: OnChangeFn<ColumnFiltersState>;
+    onPaginationChange?: OnChangeFn<PaginationState>;
+    onSortingChange?: OnChangeFn<SortingState>;
+    onRowSelectionChange?: OnChangeFn<RowSelectionState>;
+    setGlobalFilter?: React.Dispatch<React.SetStateAction<string>>;
+    manualPagination?: boolean;
+    manualFiltering?: boolean;
+    manualSorting?: boolean;
+    isLoading?: boolean;
+    isError?: boolean;
+    isFetching?: boolean;
+    refetch?: () => void;
+    renderSubComponent?: (props: {
+        row: Row<GridFeatures, TData>;
+    }) => React.ReactElement;
+    getRowCanExpand?: (row: Row<GridFeatures, TData>) => boolean;
+    enableCellSelection?: boolean;
+    enableCellSpanning?: boolean;
+    enableRowSelection?: boolean;
+    topRightSlot?: React.ReactNode;
+}

package/dist/package/core/index.d.ts

@@ -0,0 +1,4 @@
+import { RowData } from '@tanstack/react-table';
+import { GridProps } from './types';
+declare const Grid: <T extends RowData>({ payload, columns, name, state, onColumnFiltersChange, onPaginationChange, onSortingChange, onRowSelectionChange, setGlobalFilter, manualPagination, manualFiltering, manualSorting, isLoading, isError, isFetching, refetch, height, getRowCanExpand, renderSubComponent, enableCellSelection, enableCellSpanning, enableRowSelection, topRightSlot, }: GridProps<T>) => import("react").JSX.Element;
+export { Grid };

package/dist/package/core/types/index.d.ts

@@ -0,0 +1,342 @@
+import { GridFeatures } from '../../features';
+import { ColumnDef, ColumnFiltersState, OnChangeFn, PaginationState, Row, RowData, RowSelectionState, SortingState, TableState } from '@tanstack/react-table';
+/**
+ * Props for the `Grid` component.
+ *
+ * `Grid` is a reusable, feature-rich data-table component built on top of
+ * `@tanstack/react-table`. It supports sorting, filtering, pagination,
+ * column/row pinning, column resizing, row selection, cell selection,
+ * cell spanning, and row expansion out of the box.
+ *
+ * @typeParam TData - The shape of a single row of data. Must satisfy
+ * TanStack Table's `RowData` constraint.
+ *
+ * @example
+ * Basic usage with local state via `useGridState`:
+ * ```tsx
+ * import { Grid, useGridState, type ColumnDef, type GridFeatures } from 'react-shadcn-table';
+ *
+ * interface User {
+ *   id: string;
+ *   name: string;
+ * }
+ *
+ * const columns: ColumnDef<GridFeatures, User, unknown>[] = [
+ *   { id: 'id', accessorKey: 'id', header: () => 'ID' },
+ *   { id: 'name', accessorKey: 'name', header: () => 'Name' },
+ * ];
+ *
+ * const App = () => {
+ *   const { state, handlers } = useGridState();
+ *
+ *   return (
+ *     <Grid
+ *       payload={{ data: users, total: users.length }}
+ *       columns={columns}
+ *       state={state}
+ *       {...handlers}
+ *     />
+ *   );
+ * };
+ * ```
+ *
+ * @example
+ * Server-side (manual) pagination, sorting, and filtering:
+ * ```tsx
+ * const { state, handlers } = useGridState();
+ * const { data, isLoading, isError, refetch, isFetching } = useUsersQuery({
+ *   queryString: URLSearch(state),
+ * });
+ *
+ * <Grid
+ *   payload={{ data: data?.rows ?? [], total: data?.total ?? 0 }}
+ *   columns={columns}
+ *   manualPagination
+ *   manualFiltering
+ *   manualSorting
+ *   isLoading={isLoading}
+ *   isError={isError}
+ *   isFetching={isFetching}
+ *   refetch={refetch}
+ *   state={state}
+ *   {...handlers}
+ * />
+ * ```
+ */
+export interface GridProps<TData extends RowData> {
+    /**
+     * The row data to render, plus the total row count (used for
+     * server-side/manual pagination to compute total pages).
+     *
+     * @example
+     * ```tsx
+     * payload={{ data: users, total: 128 }}
+     * ```
+     */
+    payload?: {
+        data: TData[];
+        total: number;
+    };
+    /**
+     * Column definitions for the table. Required. Typed against the grid's
+     * internal `GridFeatures` so column APIs (pinning, spanning, etc.) are
+     * available inside `header`/`cell` renderers.
+     *
+     * @example
+     * ```tsx
+     * const columns: ColumnDef<GridFeatures, User, unknown>[] = [
+     *   {
+     *     id: 'email',
+     *     accessorKey: 'email',
+     *     header: () => <div>Email</div>,
+     *     meta: { filterVariant: 'text' },
+     *   },
+     * ];
+     * ```
+     */
+    columns: ColumnDef<GridFeatures, TData>[];
+    /**
+     * A unique name for this grid instance, used as a storage key to persist
+     * per-grid layout (column visibility, pinning, order, sizing, split view)
+     * across sessions. Use a distinct name per grid instance in your app.
+     *
+     * @defaultValue `'munza'`
+     *
+     * @example
+     * ```tsx
+     * <Grid name="users-grid" ... />
+     * ```
+     */
+    name?: string;
+    /**
+     * Fixed height for the table's scrollable body, as a CSS value.
+     *
+     * @defaultValue `'65vh'`
+     *
+     * @example
+     * ```tsx
+     * <Grid height="480px" ... />
+     * ```
+     */
+    height?: string;
+    /**
+     * The current table state (filters, pagination, sorting, selection,
+     * global filter, etc.), typically supplied by `useGridState`. Partial,
+     * since any field you omit falls back to the grid's own internal state.
+     *
+     * @example
+     * ```tsx
+     * const { state } = useGridState();
+     * <Grid state={state} ... />
+     * ```
+     */
+    state?: Partial<TableState<GridFeatures>>;
+    /**
+     * Callback fired when column filters change.
+     *
+     * @example
+     * ```tsx
+     * onColumnFiltersChange={(updater) => setColumnFilters(updater)}
+     * ```
+     */
+    onColumnFiltersChange?: OnChangeFn<ColumnFiltersState>;
+    /**
+     * Callback fired when pagination (page index or page size) changes.
+     *
+     * @example
+     * ```tsx
+     * onPaginationChange={(updater) => setPagination(updater)}
+     * ```
+     */
+    onPaginationChange?: OnChangeFn<PaginationState>;
+    /**
+     * Callback fired when column sorting changes.
+     *
+     * @example
+     * ```tsx
+     * onSortingChange={(updater) => setSorting(updater)}
+     * ```
+     */
+    onSortingChange?: OnChangeFn<SortingState>;
+    /**
+     * Callback fired when row selection changes.
+     *
+     * @example
+     * ```tsx
+     * onRowSelectionChange={(updater) => setRowSelection(updater)}
+     * ```
+     */
+    onRowSelectionChange?: OnChangeFn<RowSelectionState>;
+    /**
+     * Setter for the global (cross-column) search/filter text.
+     *
+     * @example
+     * ```tsx
+     * const [globalFilter, setGlobalFilter] = useState('');
+     * <Grid setGlobalFilter={setGlobalFilter} ... />
+     * ```
+     */
+    setGlobalFilter?: React.Dispatch<React.SetStateAction<string>>;
+    /**
+     * Enables server-side (manual) pagination. When `true`, the table will
+     * not paginate `payload.data` itself and instead relies on `payload.total`
+     * and your `onPaginationChange` handler to fetch the correct page.
+     *
+     * @defaultValue `false`
+     *
+     * @example
+     * ```tsx
+     * <Grid manualPagination payload={{ data: pageOfUsers, total: 500 }} ... />
+     * ```
+     */
+    manualPagination?: boolean;
+    /**
+     * Enables server-side (manual) column filtering. When `true`, the table
+     * assumes `payload.data` is already filtered and skips its own
+     * client-side filtering row model for column filters.
+     *
+     * @defaultValue `false`
+     *
+     * @example
+     * ```tsx
+     * <Grid manualFiltering onColumnFiltersChange={setColumnFilters} ... />
+     * ```
+     */
+    manualFiltering?: boolean;
+    /**
+     * Enables server-side (manual) sorting. When `true`, the table assumes
+     * `payload.data` already arrives sorted and skips its own client-side
+     * sorting row model.
+     *
+     * @defaultValue `false`
+     *
+     * @example
+     * ```tsx
+     * <Grid manualSorting onSortingChange={setSorting} ... />
+     * ```
+     */
+    manualSorting?: boolean;
+    /**
+     * Shows a loading state (e.g. skeleton rows) while data is being fetched.
+     *
+     * @example
+     * ```tsx
+     * <Grid isLoading={isPending} ... />
+     * ```
+     */
+    isLoading?: boolean;
+    /**
+     * Shows an error state, typically when a data-fetch request has failed.
+     *
+     * @example
+     * ```tsx
+     * <Grid isError={isError} ... />
+     * ```
+     */
+    isError?: boolean;
+    /**
+     * Indicates a background refetch is in progress (distinct from the
+     * initial `isLoading` state), useful for showing a subtle refresh
+     * indicator without blocking the existing rows.
+     *
+     * @example
+     * ```tsx
+     * <Grid isFetching={isFetching} ... />
+     * ```
+     */
+    isFetching?: boolean;
+    /**
+     * Function to manually re-trigger a data fetch, e.g. from a "Retry"
+     * button on the error state or a refresh action in the toolbar.
+     *
+     * @example
+     * ```tsx
+     * <Grid refetch={() => queryClient.refetchQueries(['users'])} ... />
+     * ```
+     */
+    refetch?: () => void;
+    /**
+     * Renders custom content inside an expanded row (used together with
+     * `getRowCanExpand`).
+     *
+     * @example
+     * ```tsx
+     * renderSubComponent={({ row }) => (
+     *   <pre>{JSON.stringify(row.original, null, 2)}</pre>
+     * )}
+     * ```
+     */
+    renderSubComponent?: (props: {
+        row: Row<GridFeatures, TData>;
+    }) => React.ReactElement;
+    /**
+     * Determines whether a given row can be expanded to show
+     * `renderSubComponent`. If omitted, no rows are expandable and the
+     * expand column is not rendered.
+     *
+     * @example
+     * ```tsx
+     * getRowCanExpand={(row) => row.original.subRows?.length > 0}
+     * ```
+     */
+    getRowCanExpand?: (row: Row<GridFeatures, TData>) => boolean;
+    /**
+     * Enables Excel-like click-and-drag cell range selection, independent
+     * of row selection.
+     *
+     * @defaultValue `false`
+     *
+     * @example
+     * ```tsx
+     * <Grid enableCellSelection ... />
+     * ```
+     */
+    enableCellSelection?: boolean;
+    /**
+     * Enables merged/spanning cells for columns whose `ColumnDef` opts into
+     * spanning.
+     *
+     * @defaultValue `false`
+     *
+     * @example
+     * ```tsx
+     * <Grid enableCellSpanning ... />
+     * ```
+     */
+    enableCellSpanning?: boolean;
+    /**
+     * Enables or disables row selection (checkbox column and related
+     * selection APIs). When `false`, the selection column is not rendered.
+     *
+     * @defaultValue `true`
+     *
+     * @example
+     * ```tsx
+     * <Grid enableRowSelection={false} ... />
+     * ```
+     */
+    enableRowSelection?: boolean;
+    /**
+     * Additional content rendered on the right side of the built-in toolbar,
+     * next to the global search field (e.g. custom action buttons like
+     * Add, Filter, Refresh, or Export).
+     *
+     * @example
+     * ```tsx
+     * <Grid
+     *   topRightSlot={
+     *     <div className="flex items-center gap-2">
+     *       <Button variant="ghost" size="icon" onClick={refetch}>
+     *         <RefreshCw className="size-4" />
+     *       </Button>
+     *       <Button size="icon" onClick={handleAdd}>
+     *         <Plus className="size-4" />
+     *       </Button>
+     *     </div>
+     *   }
+     *   ...
+     * />
+     * ```
+     */
+    topRightSlot?: React.ReactNode;
+}

package/dist/package/features/index.d.ts

@@ -0,0 +1,41 @@
+interface MyColumnMeta {
+    filterVariant?: 'text' | 'number' | 'tel' | 'url' | 'color' | 'range' | 'select' | 'dateRange' | 'date' | 'datetime-local' | 'month' | 'time' | 'week' | 'search';
+}
+export declare const features: {
+    rowExpandingFeature: import('@tanstack/react-table').TableFeature;
+    cellSpanningFeature: import('@tanstack/react-table').TableFeature;
+    cellSelectionFeature: import('@tanstack/react-table').TableFeature;
+    rowPinningFeature: import('@tanstack/react-table').TableFeature;
+    columnOrderingFeature: import('@tanstack/react-table').TableFeature;
+    columnPinningFeature: import('@tanstack/react-table').TableFeature;
+    columnResizingFeature: import('@tanstack/react-table').TableFeature;
+    columnSizingFeature: import('@tanstack/react-table').TableFeature;
+    columnVisibilityFeature: import('@tanstack/react-table').TableFeature;
+    columnFacetingFeature: import('@tanstack/react-table').TableFeature;
+    columnFilteringFeature: import('@tanstack/react-table').TableFeature;
+    rowPaginationFeature: import('@tanstack/react-table').TableFeature;
+    rowSelectionFeature: import('@tanstack/react-table').TableFeature;
+    rowSortingFeature: import('@tanstack/react-table').TableFeature;
+    filteredRowModel: (table: import('@tanstack/react-table').Table<any, any>) => () => import('@tanstack/react-table').RowModel<any, any>;
+    paginatedRowModel: (table: import('@tanstack/react-table').Table<any, any>) => () => import('@tanstack/react-table').RowModel<any, any>;
+    sortedRowModel: (table: import('@tanstack/react-table').Table<any, any>) => () => import('@tanstack/react-table').RowModel<any, any>;
+    facetedRowModel: (table: import('@tanstack/react-table').Table<any, any>, columnId: string) => () => import('@tanstack/react-table').RowModel<any, any>;
+    facetedUniqueValues: (table: import('@tanstack/react-table').Table<import('@tanstack/react-table').TableFeatures, any>, columnId: string) => () => Map<any, number>;
+    facetedMinMaxValues: (table: import('@tanstack/react-table').Table<import('@tanstack/react-table').TableFeatures, any>, columnId: string) => () => undefined | [number, number];
+    expandedRowModel: (table: import('@tanstack/react-table').Table<any, any>) => () => import('@tanstack/react-table').RowModel<any, any>;
+    filterFns: {
+        includesString: import('@tanstack/react-table').CreatedFilterFn<any, any>;
+        inNumberRange: import('@tanstack/react-table').CreatedFilterFn<any, any>;
+        inDateRange: import('@tanstack/react-table').CreatedFilterFn<any, any>;
+        equalsString: import('@tanstack/react-table').CreatedFilterFn<any, any>;
+    };
+    sortFns: {
+        alphanumeric: import('@tanstack/react-table').CreatedSortFn<any, any>;
+        text: import('@tanstack/react-table').CreatedSortFn<any, any>;
+    };
+    globalFilteringFeature: import('@tanstack/react-table').TableFeature;
+    columnMeta: MyColumnMeta;
+    densityPlugin: import('@tanstack/react-table').TableFeature;
+};
+export type GridFeatures = typeof features;
+export {};

package/dist/package/hooks/useGrid.d.ts

@@ -0,0 +1,3 @@
+import { RowData } from '@tanstack/react-table';
+import { GridContextProps } from '../contexts/grid/types';
+export declare function useGrid<TData extends RowData = RowData>(): GridContextProps<TData>;

package/dist/package/hooks/useGridState.d.ts

@@ -0,0 +1,57 @@
+import { ColumnFiltersState, PaginationState, RowSelectionState, SortingState } from '@tanstack/react-table';
+import { default as React } from 'react';
+/**
+ * A React hook that manages all controlled state required to drive a
+ * TanStack Table instance (column filters, pagination, sorting, row
+ * selection, and global filter), and returns them pre-packaged in the
+ * shape expected by both the table's `state`/`onXChange` props and by
+ * consumers who need direct access to the current `rowSelection`.
+ *
+ * Internally, each piece of state is backed by its own `useState`, so
+ * updating one (e.g. `sorting`) does not cause unrelated state (e.g.
+ * `rowSelection`) to reset.
+ *
+ * @returns An object containing:
+ * - `state` - The combined table state object
+ *   (`columnFilters`, `globalFilter`, `pagination`, `sorting`,
+ *   `rowSelection`), meant to be spread into the table's `state` prop.
+ * - `handlers` - The corresponding change handlers
+ *   (`onColumnFiltersChange`, `onPaginationChange`, `onSortingChange`,
+ *   `setGlobalFilter`, `onRowSelectionChange`), meant to be spread as
+ *   props onto the table component.
+ * - `rowSelection` - The current `RowSelectionState` on its own, exposed
+ *   separately for convenience (e.g. to pass into utilities like
+ *   `pluckSelected` without destructuring it out of `state` again).
+ *
+ * @example
+ * ```tsx
+ * const { state, handlers, rowSelection } = useGridState();
+ *
+ * <Grid
+ *   columns={columns}
+ *   data={data}
+ *   state={state}
+ *   {...handlers}
+ * />
+ *
+ * // Use rowSelection directly elsewhere, e.g.:
+ * const selectedIds = pluckSelected(data, rowSelection, 'id');
+ * ```
+ */
+export declare const useGridState: () => {
+    state: {
+        columnFilters: ColumnFiltersState;
+        globalFilter: string;
+        pagination: PaginationState;
+        sorting: SortingState;
+        rowSelection: RowSelectionState;
+    };
+    handlers: {
+        onColumnFiltersChange: React.Dispatch<React.SetStateAction<ColumnFiltersState>>;
+        onPaginationChange: React.Dispatch<React.SetStateAction<PaginationState>>;
+        onSortingChange: React.Dispatch<React.SetStateAction<SortingState>>;
+        setGlobalFilter: React.Dispatch<React.SetStateAction<string>>;
+        onRowSelectionChange: React.Dispatch<React.SetStateAction<RowSelectionState>>;
+    };
+    rowSelection: RowSelectionState;
+};

package/dist/package/hooks/useQueryArgs.d.ts

@@ -0,0 +1,12 @@
+import { ColumnFiltersState, PaginationState, SortingState } from '@tanstack/react-table';
+export declare const useQueryArgs: (state: {
+    columnFilters: ColumnFiltersState;
+    globalFilter: string;
+    pagination: PaginationState;
+    sorting: SortingState;
+}) => {
+    pagination: PaginationState;
+    queryParams: string;
+    sort: string;
+    globalFilter: string;
+};

package/dist/package/hooks/useSyncScroll.d.ts

@@ -0,0 +1,7 @@
+type Axis = 'x' | 'y' | 'both';
+interface Props {
+    refs: React.RefObject<HTMLElement | null>[];
+    axis?: Axis;
+}
+declare const useSyncScroll: ({ refs, axis }: Props) => void;
+export default useSyncScroll;

package/dist/package/index.d.ts

@@ -0,0 +1,11 @@
+import { ColumnDef, ColumnFiltersState, PaginationState, Row, SortingState } from '@tanstack/react-table';
+export { type GridContextProps } from './contexts/grid/types';
+export { Grid } from './core/index';
+export type { GridProps } from './core/types';
+export type { GridFeatures } from './features';
+export { useGrid } from './hooks/useGrid';
+export { useGridState } from './hooks/useGridState';
+export { useQueryArgs } from './hooks/useQueryArgs';
+export { pluckSelected } from './utils/pluckSelected';
+export { URLSearch } from './utils/URLSearch';
+export type { ColumnDef, ColumnFiltersState, PaginationState, Row, SortingState, };

package/dist/package/state/rowDensity.d.ts

@@ -0,0 +1,28 @@
+import { OnChangeFn, RowData, TableFeature, TableFeatures, Updater } from '@tanstack/react-table';
+export type DensityState = 'sm' | 'md' | 'lg';
+export interface TableState_Density {
+    density: DensityState;
+}
+export interface TableOptions_Density {
+    enableDensity?: boolean;
+    onDensityChange?: OnChangeFn<DensityState>;
+}
+export interface Table_Density {
+    setDensity: (updater: Updater<DensityState>) => void;
+    toggleDensity: (value?: DensityState) => void;
+}
+declare module '@tanstack/react-table' {
+    interface Plugins {
+        densityPlugin: TableFeature;
+    }
+    interface TableState_FeatureMap {
+        densityPlugin: TableState_Density;
+    }
+    interface TableOptions_FeatureMap<TFeatures extends TableFeatures, TData extends RowData> {
+        densityPlugin: TableOptions_Density;
+    }
+    interface Table_FeatureMap<TFeatures extends TableFeatures, TData extends RowData> {
+        densityPlugin: Table_Density;
+    }
+}
+export declare const densityPlugin: TableFeature;

package/dist/package/state/useColumnOrderState.d.ts

@@ -0,0 +1,4 @@
+import { Dispatch, SetStateAction } from 'react';
+export declare function getStoredColumnOrder(gridId: string, defaultOrder: string[]): string[];
+export declare function setStoredColumnOrder(gridId: string, order: string[]): void;
+export declare function useColumnOrderState(gridId: string, defaultOrder: string[]): readonly [string[], Dispatch<SetStateAction<string[]>>];

package/dist/package/state/useColumnPinningState.d.ts

@@ -0,0 +1,5 @@
+import { ColumnPinningState } from '@tanstack/react-table';
+import { Dispatch, SetStateAction } from 'react';
+export declare function getStoredColumnPinning(gridId: string, columnIds?: string[]): ColumnPinningState;
+export declare function setStoredColumnPinning(gridId: string, pinning: ColumnPinningState): void;
+export declare function useColumnPinningState(gridId: string, columnIds?: string[]): readonly [ColumnPinningState, Dispatch<SetStateAction<ColumnPinningState>>];

package/dist/package/state/useColumnSizingState.d.ts

@@ -0,0 +1,5 @@
+import { ColumnSizingState } from '@tanstack/react-table';
+import { Dispatch, SetStateAction } from 'react';
+export declare function getStoredColumnSizing(gridId: string): ColumnSizingState;
+export declare function setStoredColumnSizing(gridId: string, sizing: ColumnSizingState): void;
+export declare function useColumnSizingState(gridId: string): readonly [ColumnSizingState, Dispatch<SetStateAction<ColumnSizingState>>];

package/dist/package/state/useColumnVisibilityState.d.ts

@@ -0,0 +1,5 @@
+import { ColumnVisibilityState } from '@tanstack/react-table';
+import { Dispatch, SetStateAction } from 'react';
+export declare function getStoredColumnVisibility(gridId: string): ColumnVisibilityState;
+export declare function setStoredColumnVisibility(gridId: string, visibility: ColumnVisibilityState): void;
+export declare function useColumnVisibilityState(gridId: string): readonly [ColumnVisibilityState, Dispatch<SetStateAction<ColumnVisibilityState>>];

package/dist/package/state/useDensityState.d.ts

@@ -0,0 +1,5 @@
+import { Dispatch, SetStateAction } from 'react';
+import { DensityState } from './rowDensity';
+export declare function getStoredDensity(gridId: string): DensityState;
+export declare function setStoredDensity(gridId: string, density: DensityState): void;
+export declare function useDensityState(gridId: string): readonly [DensityState, Dispatch<SetStateAction<DensityState>>];

package/dist/package/state/useRowPinningState.d.ts

@@ -0,0 +1,5 @@
+import { RowPinningState } from '@tanstack/react-table';
+import { Dispatch, SetStateAction } from 'react';
+export declare function getStoredRowPinning(gridId: string): RowPinningState;
+export declare function setStoredRowPinning(gridId: string, pinning: RowPinningState): void;
+export declare function useRowPinningState(gridId: string): readonly [RowPinningState, Dispatch<SetStateAction<RowPinningState>>];

package/dist/package/state/useSplitViewState.d.ts

@@ -0,0 +1,4 @@
+import { Dispatch, SetStateAction } from 'react';
+export declare function getStoredIsSplit(gridId: string): boolean;
+export declare function setStoredIsSplit(gridId: string, isSplit: boolean): void;
+export declare function useSplitViewState(gridId: string): readonly [boolean, Dispatch<SetStateAction<boolean>>];

package/dist/package/ui/grid/sections/center/GridCenter.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+declare const GridCenter: () => React.JSX.Element;
+export default GridCenter;

package/dist/package/ui/grid/sections/center/GridCenterBody.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+declare const GridCenterBody: () => React.JSX.Element;
+export default GridCenterBody;

package/dist/package/ui/grid/sections/center/GridCenterHeader.d.ts

@@ -0,0 +1,2 @@
+declare const GridCenterHeader: () => import("react").JSX.Element;
+export default GridCenterHeader;

package/dist/package/ui/grid/sections/center/GridCenterRowPin.d.ts

@@ -0,0 +1,3 @@
+export declare function GridCenterRowPin({ row }: {
+    row: any;
+}): import("react").JSX.Element;

package/dist/package/ui/grid/sections/center/feedback/GridCenterEmpty.d.ts

@@ -0,0 +1,2 @@
+declare const GridCenterEmpty: () => import("react").JSX.Element;
+export default GridCenterEmpty;

package/dist/package/ui/grid/sections/center/feedback/GridCenterEmptyMessage.d.ts

@@ -0,0 +1,2 @@
+declare const GridCenterEmptyMessage: () => import("react").JSX.Element;
+export default GridCenterEmptyMessage;

package/dist/package/ui/grid/sections/center/feedback/GridCenterError.d.ts

@@ -0,0 +1,2 @@
+declare const GridCenterError: () => import("react").JSX.Element;
+export default GridCenterError;

package/dist/package/ui/grid/sections/center/feedback/GridCenterErrorMessage.d.ts

@@ -0,0 +1,2 @@
+declare const GridCenterErrorMessage: () => import("react").JSX.Element;
+export default GridCenterErrorMessage;