npm - @sesamehr/react-design-system - Versions diffs - 0.1.0 - Mend

@sesamehr/react-design-system 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (154) hide show

package/LICENSE ADDED Viewed

@@ -0,0 +1,21 @@
+MIT License
+Copyright (c) 2026 Sesame HR
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md ADDED Viewed

@@ -0,0 +1,89 @@
+# @sesamehr/react-design-system
+React component library and design tokens for the Sesame HR design system.
+Accessible, composable components built on [Radix UI](https://www.radix-ui.com/) and styled with [Tailwind CSS v4](https://tailwindcss.com/), shipped as an ESM + UMD bundle with full TypeScript types.
+## Installation
+```bash
+npm install @sesamehr/react-design-system
+```
+This package has peer dependencies you must install alongside it:
+```bash
+npm install react react-dom tailwindcss
+```
+| Peer          | Supported range      |
+| ------------- | -------------------- |
+| `react`       | `^18.3.0 \|\| ^19.0.0` |
+| `react-dom`   | `^18.3.0 \|\| ^19.0.0` |
+| `tailwindcss` | `^4.1.7`             |
+## Usage
+Import the stylesheet once at your app root, then use the components:
+```tsx
+// main.tsx / App entry — import the compiled styles once
+import '@sesamehr/react-design-system/style.css';
+```
+```tsx
+import { Button, Avatar, Alert } from '@sesamehr/react-design-system';
+export function Example() {
+  return (
+    <div>
+      <Avatar initials="SH" size="lg" />
+      <Button variant="default">Save</Button>
+      <Alert>Saved successfully.</Alert>
+    </div>
+  );
+}
+```
+### Design tokens
+The compiled stylesheet already includes the tokens. If you want the raw token
+layers (e.g. to `@reference` them from your own Tailwind setup), they are
+exported separately:
+```css
+@import '@sesamehr/react-design-system/assets/styles/mainTheme.css';
+```
+### `cn` utility
+The class-merging helper used internally is also exported:
+```ts
+import { cn } from '@sesamehr/react-design-system/lib/utils';
+```
+## Components
+- **Buttons** — Button
+- **Forms** — Input, InputNumber, InputGroup, Combobox, Checkbox, Switch, RadioButton, Toggle, Field
+- **Data** — Table (sorting, selection, pinning, row drag & drop, pagination), TablePagination, Avatar cells
+- **Display** — Avatar, AvatarGroup, Badge, PaymentCard
+- **Feedback** — Alert, Dialog, Popover, Tooltip, StatusBadge, Bullet
+- **Navigation** — Tabs, Accordion, Breadcrumb
+- **Layout** — Resizable
+- **Transitions** — Fade, Expand, Flip, Bounce, SlideX, SlideY
+All components ship with TypeScript definitions and support `ref` forwarding.
+## Dark mode
+Components react to the `dark` class on a parent element (typically `<html>`):
+```ts
+document.documentElement.classList.toggle('dark', isDark);
+```
+## License
+[MIT](./LICENSE) © Sesame HR

package/dist/Button/Button.d.ts ADDED Viewed

@@ -0,0 +1,12 @@
+import { ButtonVariants } from '.';
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: ButtonVariants['variant'];
+    size?: ButtonVariants['size'];
+    /** Render as the child element instead of a `<button>` (Radix Slot). */
+    asChild?: boolean;
+}
+/**
+ * Button — mirrors `@orxata/core` Button.
+ * `asChild` replaces reka-ui's `<Primitive as-child>` via `@radix-ui/react-slot`.
+ */
+export declare const Button: import('react').ForwardRefExoticComponent<ButtonProps & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/Button/index.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+import { VariantProps } from 'class-variance-authority';
+export { Button, type ButtonProps } from './Button';
+export declare const buttonVariants: (props?: ({
+    variant?: "link" | "default" | "success" | "secondary" | "outline" | "destructive" | "ghost" | null | undefined;
+    size?: "default" | "icon" | "sm" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type ButtonVariants = VariantProps<typeof buttonVariants>;

package/dist/Data/Table/Table.d.ts ADDED Viewed

@@ -0,0 +1,43 @@
+import { ReactNode } from 'react';
+import { UseTableReturn } from './hooks/useTable/useTable';
+import { CellContext, ColumnDef } from './types';
+export interface TableComponentProps<TData = unknown> {
+    loading?: boolean;
+    enableDragToScroll?: boolean;
+    table?: UseTableReturn<TData>;
+    /**
+     * Cell render prop (replaces the `cell-${field}` scoped slots). Return
+     * `undefined` to fall back to the column's `cellSlot`.
+     */
+    renderCell?: (field: string, ctx: CellContext<TData> & {
+        rowIndex: number;
+    }) => ReactNode;
+    /**
+     * Header render prop (replaces the `header-${field}` scoped slots). Return
+     * `undefined` to fall back to `column.header ?? column.field`.
+     */
+    renderHeader?: (field: string, column: ColumnDef<TData>) => ReactNode;
+    /** Detail-row render prop (`detail-row` scoped slot). */
+    detailRow?: (ctx: {
+        row: TData;
+        rowIndex: number;
+    }) => ReactNode;
+    /** Custom bulk header (`bulk-header` slot). Overrides the auto bulk header. */
+    bulkHeader?: ReactNode;
+    /** Bulk action controls (`bulk-actions` slot). */
+    bulkActions?: ReactNode;
+    /** Pagination content (`pagination` slot). */
+    pagination?: ReactNode;
+    /** Empty state content (`empty` slot). */
+    empty?: ReactNode;
+    /** Left fixed section content (`fixed-left` slot) — custom mode only. */
+    fixedLeft?: ReactNode;
+    /** Right fixed section content (`fixed-right` slot) — custom mode only. */
+    fixedRight?: ReactNode;
+    /** Center table content (default slot) — custom mode only. */
+    children?: ReactNode;
+}
+export declare function Table<TData = unknown>({ enableDragToScroll, table, renderCell, renderHeader, detailRow: detailRowSlot, bulkHeader, bulkActions, pagination, empty, fixedLeft, fixedRight, children, }: TableComponentProps<TData>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Table {
+    var displayName: string;
+}

package/dist/Data/Table/TableAvatar/TableAvatar.d.ts ADDED Viewed

@@ -0,0 +1,13 @@
+export interface TableAvatarProps extends React.ComponentPropsWithoutRef<'div'> {
+    /** Image source URL */
+    src?: string;
+    /** Fallback initials (max 2 characters) */
+    initials?: string;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Full name to display */
+    name: string;
+    /** Subtitle (department, role, etc.) */
+    subtitle?: string;
+}
+export declare const TableAvatar: import('react').ForwardRefExoticComponent<TableAvatarProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Data/Table/TableBody/TableBody.d.ts ADDED Viewed

@@ -0,0 +1,21 @@
+export interface TableBodyProps extends React.ComponentPropsWithoutRef<'tbody'> {
+    /** Enable row drag & drop reordering */
+    draggable?: boolean;
+    /** Items array for drag reordering (required when draggable=true) */
+    items?: unknown[];
+    /** Called when items are reordered */
+    onReorder?: (items: unknown[]) => void;
+    /**
+     * Derives the sortable id for each item. MUST match the `dragId` passed to
+     * each child `TableRow`. Defaults to the array index — pass a stable key
+     * (e.g. `(row) => row.id`) whenever rows are keyed by something other than
+     * their position, or reordering across renders will misbehave.
+     */
+    getItemId?: (item: unknown, index: number) => string | number;
+}
+/**
+ * Styled `<tbody>`. When `draggable`, wraps rows in a dnd-kit sortable
+ * context — replacing the Vue `vue-draggable-plus` (Sortable.js) integration.
+ * Sortable item ids are derived from the index of each `items` entry.
+ */
+export declare const TableBody: import('react').ForwardRefExoticComponent<TableBodyProps & import('react').RefAttributes<HTMLTableSectionElement>>;

package/dist/Data/Table/TableBulkHeader/TableBulkHeader.d.ts ADDED Viewed

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+export interface TableBulkHeaderProps extends React.ComponentPropsWithoutRef<'div'> {
+    selectedCount?: number;
+    total?: number;
+    /** Custom feedback content (replaces the default text). */
+    feedback?: (props: {
+        selectedCount: number;
+        total: number;
+    }) => ReactNode;
+    /** Action controls rendered on the right. */
+    actions?: ReactNode;
+}
+export declare const TableBulkHeader: import('react').ForwardRefExoticComponent<TableBulkHeaderProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Data/Table/TableCell/TableCell.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+import { ColumnAlign } from '../types';
+export interface TableCellProps extends React.ComponentPropsWithoutRef<'td'> {
+    align?: ColumnAlign;
+    fixed?: 'left' | 'right';
+    /** CSS value for multiple fixed columns, e.g. '48px' */
+    fixedOffset?: string;
+}
+export declare const TableCell: import('react').ForwardRefExoticComponent<TableCellProps & import('react').RefAttributes<HTMLTableCellElement>>;

package/dist/Data/Table/TableColumnVisibility/TableColumnVisibility.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+import { ColumnDef } from '../types';
+export interface TableColumnVisibilityProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'onToggle'> {
+    columns: ColumnDef[];
+    visibility?: Record<string, boolean>;
+    /** Custom header content (replaces the default "Columns" label). */
+    header?: ReactNode;
+    onToggle?: (field: string) => void;
+}
+export declare const TableColumnVisibility: import('react').ForwardRefExoticComponent<TableColumnVisibilityProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Data/Table/TableDragCell/TableDragCell.d.ts ADDED Viewed

@@ -0,0 +1,6 @@
+export interface TableDragCellProps extends React.ComponentPropsWithoutRef<'td'> {
+    header?: boolean;
+    fixed?: boolean;
+    fixedOffset?: string;
+}
+export declare const TableDragCell: import('react').ForwardRefExoticComponent<TableDragCellProps & import('react').RefAttributes<HTMLTableCellElement>>;

package/dist/Data/Table/TableEmpty/TableEmpty.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+export type TableEmptyProps = React.ComponentPropsWithoutRef<'div'>;
+/** Empty state display. Renders `children`, or a default message. */
+export declare const TableEmpty: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Data/Table/TableExpandCell/TableExpandCell.d.ts ADDED Viewed

@@ -0,0 +1,6 @@
+export interface TableExpandCellProps extends React.ComponentPropsWithoutRef<'td'> {
+    expanded?: boolean;
+    header?: boolean;
+    onToggle?: () => void;
+}
+export declare const TableExpandCell: import('react').ForwardRefExoticComponent<TableExpandCellProps & import('react').RefAttributes<HTMLTableCellElement>>;

package/dist/Data/Table/TableFixed/TableFixed.d.ts ADDED Viewed

@@ -0,0 +1,27 @@
+import { ReactNode } from 'react';
+export interface TableFixedContextValue {
+    hasLeftFixed: boolean;
+    hasRightFixed: boolean;
+}
+export declare const TableFixedContext: import('react').Context<TableFixedContextValue>;
+export interface TableFixedProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'children'> {
+    loading?: boolean;
+    enableDragToScroll?: boolean;
+    /** e.g., '48px' for checkbox column */
+    leftWidth?: string;
+    /** e.g., '48px' for actions column */
+    rightWidth?: string;
+    /** Content of the left fixed section (`fixed-left` slot). */
+    fixedLeft?: ReactNode;
+    /** Content of the right fixed section (`fixed-right` slot). */
+    fixedRight?: ReactNode;
+    /** Bulk header content (`bulk-header` slot). */
+    bulkHeader?: ReactNode;
+    /** Pagination content (`pagination` slot). */
+    pagination?: ReactNode;
+    /** Empty state content (`empty` slot). */
+    empty?: ReactNode;
+    /** Center scrollable table content (default slot). */
+    children?: ReactNode;
+}
+export declare const TableFixed: import('react').ForwardRefExoticComponent<TableFixedProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Data/Table/TableFixed/index.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export { TableFixed, TableFixedContext, type TableFixedProps, type TableFixedContextValue, } from './TableFixed';

package/dist/Data/Table/TableHead/TableHead.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+export type TableHeadProps = React.ComponentPropsWithoutRef<'thead'>;
+/** Styled `<thead>` wrapping its children in a header row. */
+export declare const TableHead: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, "ref"> & import('react').RefAttributes<HTMLTableSectionElement>>;

package/dist/Data/Table/TableHeaderCell/TableHeaderCell.d.ts ADDED Viewed

@@ -0,0 +1,18 @@
+import { ColumnAlign } from '../types';
+export interface TableHeaderCellProps extends Omit<React.ComponentPropsWithoutRef<'th'>, 'onDrop'> {
+    sortable?: boolean;
+    sorted?: boolean;
+    sortDirection?: 'asc' | 'desc' | null;
+    resizable?: boolean;
+    resizing?: boolean;
+    draggable?: boolean;
+    align?: ColumnAlign;
+    width?: string;
+    fixed?: 'left' | 'right';
+    /** CSS value for multiple fixed columns */
+    fixedOffset?: string;
+    onSort?: () => void;
+    onResizeStart?: (event: React.MouseEvent | React.TouchEvent) => void;
+    onColumnDrop?: (sourceField: string) => void;
+}
+export declare const TableHeaderCell: import('react').ForwardRefExoticComponent<TableHeaderCellProps & import('react').RefAttributes<HTMLTableCellElement>>;

package/dist/Data/Table/TablePagination/TablePagination.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+export interface TablePaginationProps extends React.ComponentPropsWithoutRef<'div'> {
+    page?: number;
+    pageSize?: number;
+    pageCount?: number;
+    total?: number;
+    pageSizes?: number[];
+    onPageChange?: (page: number) => void;
+    onPageSizeChange?: (pageSize: number) => void;
+}
+export declare const TablePagination: import('react').ForwardRefExoticComponent<TablePaginationProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Data/Table/TableRow/TableRow.d.ts ADDED Viewed

@@ -0,0 +1,11 @@
+export interface TableRowProps extends React.ComponentPropsWithoutRef<'tr'> {
+    selected?: boolean;
+    expanded?: boolean;
+    /**
+     * Sortable id for row drag & drop. When set, the row becomes draggable and
+     * MUST live inside a `<TableBody draggable>` (which provides the dnd-kit
+     * context). The value has to match the id produced by TableBody's `getItemId`.
+     */
+    dragId?: string | number;
+}
+export declare const TableRow: import('react').ForwardRefExoticComponent<TableRowProps & import('react').RefAttributes<HTMLTableRowElement>>;

package/dist/Data/Table/TableRow/rowDrag.d.ts ADDED Viewed

@@ -0,0 +1,17 @@
+/**
+ * Bridges a sortable `TableRow` to its drag handle (`TableDragCell`).
+ *
+ * `useSortable` puts the node ref + transform on the `<tr>`, but the drag
+ * *activator* (the grip icon) lives in a child cell. This context passes the
+ * activator ref + attributes/listeners down so the grip — and only the grip —
+ * starts a drag, instead of the whole row.
+ *
+ * Typed loosely on purpose: dnd-kit's attribute/listener maps don't line up
+ * cleanly with intrinsic element props, and they are only ever spread.
+ */
+export interface RowDragHandle {
+    attributes: Record<string, unknown>;
+    listeners: Record<string, unknown> | undefined;
+    setActivatorNodeRef: (element: HTMLElement | null) => void;
+}
+export declare const RowDragContext: import('react').Context<RowDragHandle | null>;

package/dist/Data/Table/TableRowExpanded/TableRowExpanded.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+export interface TableRowExpandedProps extends React.ComponentPropsWithoutRef<'tr'> {
+    expanded?: boolean;
+    colspan?: number;
+}
+export declare const TableRowExpanded: import('react').ForwardRefExoticComponent<TableRowExpandedProps & import('react').RefAttributes<HTMLTableRowElement>>;

package/dist/Data/Table/TableSelectCell/TableSelectCell.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+export interface TableSelectCellProps extends Omit<React.ComponentPropsWithoutRef<'td'>, 'onChange'> {
+    checked?: boolean | 'indeterminate';
+    header?: boolean;
+    /** Usually fixed to left */
+    fixed?: boolean;
+    fixedOffset?: string;
+    onChange?: (checked: boolean) => void;
+}
+export declare const TableSelectCell: import('react').ForwardRefExoticComponent<TableSelectCellProps & import('react').RefAttributes<HTMLTableCellElement>>;

package/dist/Data/Table/hooks/index.d.ts ADDED Viewed

@@ -0,0 +1,20 @@
+export { useTable } from './useTable/useTable';
+export type { UseTableOptions, UseTableReturn, } from './useTable/useTable.types';
+export { useTableSelection } from './useTableSelection/useTableSelection';
+export type { SelectionOptions, SelectionInstance, SelectionPluginDef, } from './useTableSelection/useTableSelection.types';
+export { useTableSorting } from './useTableSorting/useTableSorting';
+export type { SortingOptions, SortingInstance, SortingPluginDef, } from './useTableSorting/useTableSorting.types';
+export { useTablePagination } from './useTablePagination/useTablePagination';
+export type { UseTablePaginationOptions, UseTablePaginationReturn, } from './useTablePagination/useTablePagination';
+export { useTableDetailRow } from './useTableDetailRow/useTableDetailRow';
+export type { DetailRowOptions, DetailRowInstance, DetailRowPluginDef, } from './useTableDetailRow/useTableDetailRow.types';
+export { useTablePinning } from './useTablePinning/useTablePinning';
+export type { PinningOptions, PinningInstance, PinningPluginDef, CellInfo, HeaderInfo, } from './useTablePinning/useTablePinning.types';
+export { useTableColumns } from './useTableColumns/useTableColumns';
+export type { ColumnsOptions, ColumnsInstance, ColumnsPluginDef, } from './useTableColumns/useTableColumns.types';
+export { useScrollShadow } from './useScrollShadow/useScrollShadow';
+export type { UseScrollShadowOptions, UseScrollShadowReturn, } from './useScrollShadow/useScrollShadow';
+export { useDragToScroll } from './useDragToScroll/useDragToScroll';
+export type { UseDragToScrollOptions, UseDragToScrollReturn, } from './useDragToScroll/useDragToScroll';
+export { useFixedColumns } from './useFixedColumns';
+export type { UseFixedColumnsOptions } from './useFixedColumns';

package/dist/Data/Table/hooks/useDragToScroll/useDragToScroll.d.ts ADDED Viewed

@@ -0,0 +1,19 @@
+import { RefObject } from 'react';
+export interface UseDragToScrollOptions {
+    /** Whether drag-to-scroll is enabled */
+    enabled?: boolean | (() => boolean);
+    /** Cursor to show while dragging */
+    cursor?: string;
+}
+export interface UseDragToScrollReturn {
+    /** Whether the user is currently dragging to scroll */
+    isDragging: boolean;
+}
+/**
+ * Hook for drag-to-scroll functionality.
+ * Allows horizontal scrolling by dragging with the mouse.
+ *
+ * Note: If using row drag & drop, set enabled=false to avoid conflicts.
+ * Use @dnd-kit for row reordering instead.
+ */
+export declare function useDragToScroll(elementRef: RefObject<HTMLElement | null>, options?: UseDragToScrollOptions): UseDragToScrollReturn;

package/dist/Data/Table/hooks/useFixedColumns.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+import { RefObject } from 'react';
+export interface UseFixedColumnsOptions {
+    leftWidth?: number;
+    rightWidth?: number;
+}
+export declare function useFixedColumns(scrollContainerRef: RefObject<HTMLElement | null>, leftContainerRef: RefObject<HTMLElement | null>, rightContainerRef: RefObject<HTMLElement | null>): {
+    syncRowHeights: () => void;
+};

package/dist/Data/Table/hooks/useScrollShadow/useScrollShadow.d.ts ADDED Viewed

@@ -0,0 +1,14 @@
+import { RefObject } from 'react';
+export interface UseScrollShadowOptions {
+    /** Threshold in pixels to consider content as scrollable */
+    threshold?: number;
+}
+export interface UseScrollShadowReturn {
+    /** Whether to show left shadow (content hidden on left) */
+    showLeftShadow: boolean;
+    /** Whether to show right shadow (content hidden on right) */
+    showRightShadow: boolean;
+    /** Manually update shadow state */
+    updateShadows: () => void;
+}
+export declare function useScrollShadow(elementRef: RefObject<HTMLElement | null>, options?: UseScrollShadowOptions): UseScrollShadowReturn;

package/dist/Data/Table/hooks/useTable/useTable.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import { UseTableOptions, UseTableReturn } from './useTable.types';
+export declare function useTable<TData>(options: UseTableOptions<TData>): UseTableReturn<TData>;
+export type { UseTableOptions, UseTableReturn } from './useTable.types';

package/dist/Data/Table/hooks/useTable/useTable.types.d.ts ADDED Viewed

@@ -0,0 +1,55 @@
+import { Table as TanstackTable } from '@tanstack/react-table';
+import { ColumnDef, TableMode } from '../../types';
+import { ColumnsInstance, ColumnsPluginDef } from '../useTableColumns/useTableColumns.types';
+import { DetailRowInstance, DetailRowPluginDef } from '../useTableDetailRow/useTableDetailRow.types';
+import { PinningInstance, PinningPluginDef } from '../useTablePinning/useTablePinning.types';
+import { SelectionInstance, SelectionPluginDef } from '../useTableSelection/useTableSelection.types';
+import { SortingInstance, SortingPluginDef } from '../useTableSorting/useTableSorting.types';
+/** A value that may be provided directly or via a getter function. */
+export type MaybeGetter<T> = T | (() => T);
+export interface UseTableOptions<TData> {
+    /** Table data */
+    data: MaybeGetter<TData[]>;
+    /** Column definitions */
+    columns?: MaybeGetter<ColumnDef<TData>[]>;
+    /** Table mode: 'client' for local data, 'server' for remote data */
+    mode?: TableMode;
+    /** Whether the table data is currently loading */
+    loading?: MaybeGetter<boolean>;
+    /** Row key field or getter function */
+    rowKey?: string | ((row: TData) => string | number);
+    /** Selection plugin (created with useTableSelection) */
+    selection?: SelectionPluginDef<TData>;
+    /** Detail row plugin (created with useTableDetailRow) */
+    detailRow?: DetailRowPluginDef<TData>;
+    /** Sorting plugin (created with useTableSorting) */
+    sorting?: SortingPluginDef;
+    /** Columns plugin (created with useTableColumns) */
+    columnManager?: ColumnsPluginDef;
+    /** Pinning plugin (created with useTablePinning) */
+    pinning?: PinningPluginDef<TData>;
+}
+export interface UseTableReturn<TData> {
+    /** TanStack table instance */
+    instance: TanstackTable<TData>;
+    /** Rows from the row model */
+    rows: TData[];
+    /** Column definitions */
+    columns: ColumnDef<TData>[];
+    /** Get unique key for a row */
+    getRowKey: (row: TData, index: number) => string | number;
+    /** Table mode (client/server) */
+    mode: TableMode;
+    /** Whether the table data is currently loading */
+    loading: boolean;
+    /** Selection plugin instance (if provided) */
+    selection?: SelectionInstance;
+    /** Detail row plugin instance (if provided) */
+    detailRow?: DetailRowInstance;
+    /** Sorting plugin instance (if provided) */
+    sorting?: SortingInstance;
+    /** Columns plugin instance (if provided) */
+    columnManager?: ColumnsInstance;
+    /** Pinning plugin instance (if provided) */
+    pinning?: PinningInstance<TData>;
+}

package/dist/Data/Table/hooks/useTableColumns/useTableColumns.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import { ColumnsOptions, ColumnsPluginDef } from './useTableColumns.types';
2	+ export declare function useTableColumns(options?: ColumnsOptions): ColumnsPluginDef;

package/dist/Data/Table/hooks/useTableColumns/useTableColumns.types.d.ts ADDED Viewed

@@ -0,0 +1,31 @@
+import { ColumnOrderState, ColumnResizeMode, ColumnVisibilityState } from '../../types';
+export interface ColumnsOptions {
+    /** Enable column resizing */
+    enableResizing?: boolean;
+    /** Resize mode: 'onChange' or 'onEnd' */
+    resizeMode?: ColumnResizeMode;
+    /** Initial visibility state */
+    initialVisibility?: ColumnVisibilityState;
+    /** Initial column order */
+    initialOrder?: ColumnOrderState;
+}
+export interface ColumnsInstance {
+    visibility: ColumnVisibilityState;
+    isVisible: (field: string) => boolean;
+    toggleVisibility: (field: string) => void;
+    setVisibility: (visibility: ColumnVisibilityState) => void;
+    showColumn: (field: string) => void;
+    hideColumn: (field: string) => void;
+    order: ColumnOrderState;
+    setOrder: (order: ColumnOrderState) => void;
+    resetOrder: () => void;
+    moveColumn: (field: string, toIndex: number) => void;
+    sizing: Record<string, number>;
+    getSize: (field: string) => number;
+    setSize: (field: string, size: number) => void;
+}
+export interface ColumnsPluginDef {
+    type: 'columns';
+    options: ColumnsOptions;
+    create: (tableInstance: unknown, defaultOrder: () => string[]) => ColumnsInstance;
+}

package/dist/Data/Table/hooks/useTableDetailRow/useTableDetailRow.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import { DetailRowOptions, DetailRowPluginDef } from './useTableDetailRow.types';
2	+ export declare function useTableDetailRow<TData = unknown>(options?: DetailRowOptions): DetailRowPluginDef<TData>;

package/dist/Data/Table/hooks/useTableDetailRow/useTableDetailRow.types.d.ts ADDED Viewed

@@ -0,0 +1,29 @@
+export interface DetailRowOptions {
+    /** Initially expanded row keys */
+    initial?: (string | number)[];
+    /** Allow multiple rows to be expanded at once (default: true) */
+    allowMultiple?: boolean;
+}
+export interface DetailRowInstance {
+    /** Expansion state: Record<rowKey, boolean> or true for all */
+    expanded: Record<string, boolean> | boolean;
+    /** Check if a specific row is expanded */
+    isExpanded: (key: string | number) => boolean;
+    /** Whether all rows are expanded */
+    isAllExpanded: boolean;
+    /** Toggle expansion for a specific row */
+    toggle: (key: string | number) => void;
+    /** Toggle expansion for all rows */
+    toggleAll: () => void;
+    /** Expand specific rows */
+    expand: (keys: (string | number)[]) => void;
+    /** Collapse specific rows */
+    collapse: (keys: (string | number)[]) => void;
+    /** Collapse all rows */
+    collapseAll: () => void;
+}
+export interface DetailRowPluginDef<TData = unknown> {
+    type: 'detailRow';
+    options: DetailRowOptions;
+    create: (rows: TData[], getRowKey: (row: TData, index: number) => string | number) => DetailRowInstance;
+}

package/dist/Data/Table/hooks/useTablePagination/useTablePagination.d.ts ADDED Viewed

@@ -0,0 +1,44 @@
+import { UseTableReturn } from '../useTable/useTable';
+import { MaybeGetter } from '../useTable/useTable.types';
+export interface UseTablePaginationOptions {
+    initialPageSize?: number;
+    /** Total item count for server-side pagination (overrides rows.length) */
+    totalCount?: MaybeGetter<number>;
+}
+export interface UseTablePaginationReturn {
+    /** Current page number (1-based) */
+    page: number;
+    /** Items per page */
+    pageSize: number;
+    /** Total number of pages */
+    pageCount: number;
+    /** Total number of items */
+    total: number;
+    /** Go to specific page (1-based) */
+    setPage: (page: number) => void;
+    /** Set page size */
+    setPageSize: (size: number) => void;
+    /** Go to next page */
+    nextPage: () => void;
+    /** Go to previous page */
+    prevPage: () => void;
+    /** Go to first page */
+    firstPage: () => void;
+    /** Go to last page */
+    lastPage: () => void;
+    /** Can go to next page */
+    canNextPage: boolean;
+    /** Can go to previous page */
+    canPrevPage: boolean;
+}
+/**
+ * Pagination is left *uncontrolled* — owned by the TanStack instance — on
+ * purpose. The previous version held page state in a local `useState` and pushed
+ * it onto the instance via an `onPaginationChange` + `setOptions` effect, which
+ * applied the change one render too late, so the visible rows never moved (the
+ * "pagination doesn't work" bug). Driving the instance directly
+ * (`nextPage()`, `setPageIndex()`, ...) updates its internal state synchronously
+ * and re-renders the consumer, and `useTable` now reads the row model fresh each
+ * render, so the page actually changes.
+ */
+export declare function useTablePagination<TData>(table: UseTableReturn<TData>, options?: UseTablePaginationOptions): UseTablePaginationReturn;

package/dist/Data/Table/hooks/useTablePinning/index.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export { useTablePinning } from './useTablePinning';
2	+ export type { PinningOptions, PinningInstance, PinningPluginDef, CellInfo, HeaderInfo, } from './useTablePinning.types';

package/dist/Data/Table/hooks/useTablePinning/useTablePinning.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import { PinningOptions, PinningPluginDef } from './useTablePinning.types';
2	+ export declare function useTablePinning<TData = unknown>(options: PinningOptions<TData>): PinningPluginDef<TData>;