@carto/ps-react-ui 4.3.0-widgets.0 → 5.0.0-widgets.1

package/dist/types/widgets/root/types.d.ts

@@ -1,15 +1,9 @@
 import { ReactNode } from 'react';
-import { WrapperUIProps } from '../wrapper';
-import { WidgetsStoreProps } from '../stores/types';
-export interface RootProps {
-    id: WidgetsStoreProps['id'];
-    type: WidgetsStoreProps['type'];
+import { WidgetsStoreProps, WidgetState } from '../stores/types';
+export interface RootProps<T> extends WidgetsStoreProps {
     children: ReactNode;
-    title: WrapperUIProps['title'];
-    data?: unknown;
-    isLoading?: WidgetsStoreProps['isLoading'];
-    isFetching?: WidgetsStoreProps['isFetching'];
-    collapsed?: WrapperUIProps['collapsed'];
-    collapsible?: WrapperUIProps['disabled'];
-    disabled?: WrapperUIProps['disabled'];
+    config?: T;
+}
+export interface ConfigProps {
+    refUI?: WidgetState['refUI'];
 }

package/dist/types/widgets/root/utils.d.ts

@@ -0,0 +1 @@
+export declare function mergeWidgetConfig<T>(...options: [T | undefined, T | undefined]): T;

package/dist/types/widgets/scatterplot/config.d.ts

@@ -1,4 +1,5 @@
-import { ScatterplotConfig, ScatterplotWidgetData } from './types';
-export declare const scatterplotConfig: (config: ScatterplotConfig & {
-    refUI?: import('react').Ref<HTMLElement | null>;
-}) => import('../_shared/chart-config/config-factory').ChartWidgetConfigResult<ScatterplotWidgetData, ScatterplotConfig, "scatterplot">;
+import { ScatterplotConfig, ScatterplotWidgetConfig, ScatterplotWidgetData } from './types';
+import { DownloadItem } from '../actions';
+import { ConfigProps } from '../root/types';
+export declare function scatterplotDownloadConfig({ refUI, }: ConfigProps): DownloadItem<ScatterplotWidgetData>[];
+export declare function scatterplotConfig(props: ScatterplotConfig): ScatterplotWidgetConfig;

package/dist/types/widgets/scatterplot/index.d.ts

@@ -1,3 +1,3 @@
-export type { ScatterplotProps, ScatterplotWidgetData, ScatterplotWidgetState, ScatterplotWidgetConfig, } from './types';
-export { scatterplotConfig } from './config';
+export type { ScatterplotWidgetData, ScatterplotWidgetState, ScatterplotWidgetConfig, ScatterplotConfig, } from './types';
+export { scatterplotConfig, scatterplotDownloadConfig } from './config';
 export { ScatterplotSkeleton } from './skeleton';

package/dist/types/widgets/scatterplot/types.d.ts

@@ -1,15 +1,9 @@
-import { BaseWidgetProps } from '../widget/types';
-import { BaseConfig } from '../config-loader';
-import { EchartWidgetConfig, EchartWidgetState } from '../echart';
-export interface ScatterplotProps extends BaseWidgetProps<ScatterplotWidgetConfig> {
-    type: 'scatterplot';
-    data: ScatterplotWidgetData | undefined;
-}
+import { EchartWidgetState } from '../echart';
+import { EchartWidgetOptionProps, EchartWidgetProps } from '../echart/types';
+import { ConfigProps } from '../root';
 export type ScatterplotWidgetData = [number, number][][];
 export type ScatterplotWidgetState = EchartWidgetState;
-export type ScatterplotWidgetConfig = ScatterplotConfig & EchartWidgetConfig<ScatterplotWidgetData> & {
-    type: ScatterplotProps['type'];
+export type ScatterplotWidgetConfig = EchartWidgetProps & {
+    type: 'scatterplot';
 };
-export interface ScatterplotConfig extends Omit<BaseConfig, 'data'> {
-    data?: ScatterplotWidgetData;
-}
+export type ScatterplotConfig = ConfigProps & EchartWidgetOptionProps<ScatterplotWidgetData>;

package/dist/types/widgets/selection-summary/index.d.ts

@@ -0,0 +1,2 @@
+export { SelectionSummary } from './selection-summary';
+export type { SelectedProps, SelectionSummaryLabels } from './types';

package/dist/types/widgets/selection-summary/selection-summary.d.ts

@@ -0,0 +1,2 @@
+import { SelectedProps } from './types';
+export declare function SelectionSummary({ selections, onClear, labels, }: SelectedProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/widgets/selection-summary/style.d.ts

@@ -0,0 +1,9 @@
+import { Theme } from '@mui/material';
+export declare const styles: {
+    root: {
+        display: "flex";
+        alignItems: "center";
+        flex: string;
+        gap: ({ spacing }: Theme) => string;
+    };
+};

package/dist/types/widgets/selection-summary/types.d.ts

@@ -0,0 +1,13 @@
+export interface SelectedProps {
+    selections: number;
+    onClear?: () => void;
+    labels?: Partial<SelectionSummaryLabels>;
+}
+export interface SelectionSummaryLabels {
+    /** Label for "All selected" state */
+    allSelected: string;
+    /** Label for number of selections */
+    selections: (count: number) => string;
+    /** Label for clear button */
+    clear: string;
+}

package/dist/types/widgets/spread/config.d.ts

@@ -1,2 +1,10 @@
-import { SpreadConfig, SpreadWidgetConfig } from './types';
-export declare function spreadConfig({ refUI, data, ...props }: SpreadConfig): SpreadWidgetConfig;
+import { DownloadItem } from '../actions';
+import { ConfigProps } from '../root/types';
+import { SpreadWidgetConfig, SpreadWidgetData } from './types';
+import { SeriesConfig } from '../formula/types';
+export interface SpreadConfigProps {
+    formatter?: (value: number) => string;
+    series?: SeriesConfig[];
+}
+export declare function spreadDownloadConfig({ refUI, }: ConfigProps): DownloadItem<SpreadWidgetData>[];
+export declare function spreadConfig(): SpreadWidgetConfig;

package/dist/types/widgets/spread/index.d.ts

@@ -1,8 +1,9 @@
 export { SpreadUI } from './spread-ui';
 export { SpreadSkeleton } from './skeleton';
+export { spreadConfig, spreadDownloadConfig } from './config';
 export { MinValue } from './components/min-value';
 export { MaxValue } from './components/max-value';
 export { Separator } from './components/separator';
 export { Item, Row, Prefix, Suffix, Series } from '../formula';
-export type { RowProps, ValueProps, SpreadWidgetState, ItemProps, SpreadDataItem, SpreadUIProps, } from './types';
+export type { RowProps, ValueProps, SpreadWidgetState, SpreadWidgetConfig, SpreadWidgetData, SpreadDownloadConfig, ItemProps, SpreadDataItem, SpreadUIProps, } from './types';
 export type { SeriesConfig } from '../formula/types';

package/dist/types/widgets/spread/types.d.ts

@@ -1,16 +1,9 @@
 import { TypographyProps } from '@mui/material';
 import { ReactNode } from 'react';
 import { BaseWidgetState, WidgetsStoreProps } from '../stores/types';
-import { DownloadState } from '../actions';
-import { DownloadConfigProps } from '../actions/download/types';
 import { WrapperState } from '../wrapper/types';
-import { BaseWidgetProps } from '../widget/types';
-import { BaseConfig } from '../config-loader';
+import { DownloadItem } from '../actions/download/types';
 import { SeriesConfig } from '../formula/types';
-export interface SpreadProps extends BaseWidgetProps<SpreadWidgetConfig> {
-    type: 'spread';
-    data: SpreadWidgetData | undefined;
-}
 export interface SpreadUIProps {
     id: WidgetsStoreProps['id'];
 }
@@ -37,16 +30,11 @@ export interface ItemProps {
     TypographyProps?: TypographyProps;
 }
 export type SpreadWidgetData = SpreadDataItem[];
-export type SpreadWidgetState = BaseWidgetState<WrapperState<DownloadState<SpreadProps & {
+export type SpreadWidgetState = BaseWidgetState<WrapperState<SpreadWidgetConfig> & {
+    data: SpreadWidgetData;
+}>;
+export interface SpreadWidgetConfig {
     formatter?: (value: number) => string;
     series?: SeriesConfig[];
-}, SpreadWidgetData>>>;
-export type SpreadWidgetConfig = BaseConfig & DownloadConfigProps<SpreadWidgetData> & {
-    type: SpreadProps['type'];
-    formatter?: SpreadWidgetState['formatter'];
-    series?: SeriesConfig[];
-};
-export interface SpreadConfig extends Omit<BaseConfig, 'data'> {
-    data?: SpreadWidgetData;
-    series?: SeriesConfig[];
 }
+export type SpreadDownloadConfig = DownloadItem<SpreadWidgetData>[];

package/dist/types/widgets/stores/index.d.ts

@@ -0,0 +1,2 @@
+export { useWidgetStore } from './widget-store';
+export type { BaseWidgetState, WidgetsStoreProps, WidgetState, WidgetStore, WidgetStoreActions, WidgetStoreState, } from './types';

package/dist/types/widgets/stores/types.d.ts

@@ -1,25 +1,132 @@
 import { RefObject } from 'react';
+/**
+ * Sort direction for table columns
+ */
+export type StoreSortDirection = 'asc' | 'desc';
+/**
+ * Pagination mode for tables
+ */
+export type StorePaginationMode = 'local' | 'remote';
+/**
+ * Sort mode for tables
+ */
+export type StoreSortMode = 'local' | 'remote';
+/**
+ * Table pagination state stored in widget store
+ */
+export interface TablePaginationStoreState {
+    /** Current page (0-indexed) */
+    page: number;
+    /** Rows per page */
+    rowsPerPage: number;
+    /** Available rows per page options */
+    rowsPerPageOptions: number[];
+    /** Pagination mode: local or remote */
+    mode: StorePaginationMode;
+}
+/**
+ * Table sort state stored in widget store
+ */
+export interface TableSortStoreState {
+    /** Column ID being sorted */
+    columnId: string | null;
+    /** Sort direction */
+    direction: StoreSortDirection;
+    /** Sort mode: local or remote */
+    mode: StoreSortMode;
+}
+/**
+ * Table selection state stored in widget store
+ */
+export interface TableSelectionStoreState {
+    /** Set of selected row IDs */
+    selectedIds: Set<string | number>;
+}
+/**
+ * Combined table state for widget store
+ */
+export interface TableStoreState {
+    pagination?: TablePaginationStoreState;
+    sort?: TableSortStoreState;
+    selection?: TableSelectionStoreState;
+}
 export interface WidgetsStoreProps {
     /** Unique identifier for the widget */
     id: string;
     /** Type of widget */
     type: string;
-    /** Widget title/label */
-    title?: string;
+    /** Widget data - flexible to accommodate different widget types */
+    data: unknown;
     /** Loading state */
     isLoading: boolean;
     /** Fetching state (e.g., for async data) */
-    isFetching?: boolean;
+    isFetching: boolean;
     /** Error message if any */
     error?: string;
     /** Whether widget is visible */
-    visible: boolean;
-    /** Widget data - flexible to accommodate different widget types */
-    data?: unknown;
-    /** Additional notes about the widget */
-    note?: string;
+    visible?: boolean;
     /** Reference to the widget ui instance */
     refUI?: RefObject<HTMLElement | null>;
+    /** Registered tools for the widget's transformation pipeline */
+    registeredTools?: ToolRegistration[];
+}
+/**
+ * Tool transformation function type
+ * Can be synchronous or asynchronous to support remote operations
+ */
+export type ToolTransformFunction = (data: unknown, config?: Record<string, unknown>) => Promise<unknown> | unknown;
+/**
+ * Tool registration for widget pipeline
+ *
+ * @example Basic tool registration
+ * ```typescript
+ * registerTool(widgetId, {
+ *   id: 'searcher',
+ *   order: 10,
+ *   enabled: true,
+ *   fn: (data) => filterData(data),
+ * })
+ * ```
+ *
+ * @example Tool with dependencies
+ * ```typescript
+ * registerTool(widgetId, {
+ *   id: 'lock-selection',
+ *   order: 20,
+ *   enabled: true,
+ *   fn: (data) => lockData(data),
+ *   disables: ['searcher', 'relative-data'], // Disable these when active
+ * })
+ * ```
+ *
+ * Dependency Management:
+ * - Multiple tools can disable the same target (reference counting)
+ * - Target is only re-enabled when ALL disabling tools are inactive
+ * - Original enabled state is preserved and restored
+ * - Circular dependencies are detected and throw errors
+ */
+export interface ToolRegistration {
+    /** Unique tool identifier (e.g., 'searcher', 'relative-data') */
+    id: string;
+    /** Execution priority - lower numbers execute first */
+    order: number;
+    /** Transformation function */
+    fn: ToolTransformFunction;
+    /** Whether tool is currently enabled */
+    enabled: boolean;
+    /** Tool-specific configuration */
+    config?: Record<string, unknown>;
+    /**
+     * Array of tool IDs to disable when this tool is active.
+     * During pipeline execution, if this tool is enabled, any tools listed
+     * in this array will be excluded from the pipeline.
+     *
+     * @example
+     * ```typescript
+     * disables: ['searcher', 'relative-data']
+     * ```
+     */
+    disables?: string[];
 }
 /**
  * Base widget state interface
@@ -30,7 +137,7 @@ export type BaseWidgetState<T> = WidgetsStoreProps & T;
  */
 export type WidgetState = BaseWidgetState<unknown>;
 /**
- * Widget store state
+ * Widget store state with tool registration
  */
 export interface WidgetStoreState {
     /** Map of widget id to widget state */
@@ -44,9 +151,9 @@ export interface WidgetStoreActions {
      * Add or update a widget in the store
      * @param id - Widget ID
      * @param widget - Widget state properties to merge (accepts any object structure)
-     * @template T - Optional type parameter for backward compatibility (unused)
+     * @template T - Type of the widget state for type-safe access
      */
-    setWidget: <T extends WidgetState>(id: WidgetState['id'], widget: Partial<Omit<T, 'id'>>) => void;
+    setWidget: <T = any>(id: WidgetState['id'], widget: Partial<T>) => void;
     /**
      * Remove a widget from the store
      * @param id - Widget ID to remove
@@ -62,6 +169,63 @@ export interface WidgetStoreActions {
      * @returns Widget state or undefined if not found
      */
     getWidget: <T extends WidgetState = WidgetState>(id: WidgetState['id']) => T | undefined;
+    /**
+     * Set table pagination state for a widget
+     * @param id - Widget ID
+     * @param pagination - Partial pagination state to merge
+     */
+    setTablePagination: (id: WidgetState['id'], pagination: Partial<TablePaginationStoreState>) => void;
+    /**
+     * Set table sort state for a widget
+     * @param id - Widget ID
+     * @param sort - Partial sort state to merge
+     */
+    setTableSort: (id: WidgetState['id'], sort: Partial<TableSortStoreState>) => void;
+    /**
+     * Set table selection state for a widget
+     * @param id - Widget ID
+     * @param selection - Partial selection state to merge
+     */
+    setTableSelection: (id: WidgetState['id'], selection: Partial<TableSelectionStoreState>) => void;
+    /**
+     * Get table state for a widget
+     * @param id - Widget ID
+     * @returns Table state or undefined if not found
+     */
+    getTableState: (id: WidgetState['id']) => TableStoreState | undefined;
+    /**
+     * Register a tool with the widget's transformation pipeline
+     * @param widgetId - Widget ID
+     * @param tool - Tool registration object
+     */
+    registerTool: (widgetId: string, tool: ToolRegistration) => void;
+    /**
+     * Unregister a tool from the widget's transformation pipeline
+     * @param widgetId - Widget ID
+     * @param toolId - Tool ID to remove
+     */
+    unregisterTool: (widgetId: string, toolId: string) => void;
+    /**
+     * Update tool configuration
+     * @param widgetId - Widget ID
+     * @param toolId - Tool ID
+     * @param config - New configuration to merge
+     */
+    updateToolConfig: (widgetId: string, toolId: string, config: Record<string, unknown>) => void;
+    /**
+     * Set tool enabled state
+     * @param widgetId - Widget ID
+     * @param toolId - Tool ID
+     * @param enabled - Whether tool should be enabled
+     */
+    setToolEnabled: (widgetId: string, toolId: string, enabled: boolean) => void;
+    /**
+     * Execute the tool transformation pipeline
+     * Supports both synchronous and asynchronous tools
+     * @param widgetId - Widget ID
+     * @param sourceData - Original data to transform
+     */
+    executeToolPipeline: (widgetId: string, sourceData: unknown) => Promise<void>;
 }
 /**
  * Complete widget store interface

package/dist/types/widgets/stores/widget-store.d.ts

@@ -1,4 +1,4 @@
-import { WidgetState, WidgetStore } from './types';
+import { WidgetStore } from './types';
 /**
  * Zustand store for managing widget state across the application.
  *
@@ -36,29 +36,4 @@ import { WidgetState, WidgetStore } from './types';
  * const formulaWidgets = getWidgetsByType('formula')
  * ```
  */
-export declare const useWidgetStore: import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<WidgetStore>, "setState" | "devtools"> & {
-    setState(partial: WidgetStore | Partial<WidgetStore> | ((state: WidgetStore) => WidgetStore | Partial<WidgetStore>), replace?: false | undefined, action?: (string | {
-        [x: string]: unknown;
-        [x: number]: unknown;
-        [x: symbol]: unknown;
-        type: string;
-    }) | undefined): void;
-    setState(state: WidgetStore | ((state: WidgetStore) => WidgetStore), replace: true, action?: (string | {
-        [x: string]: unknown;
-        [x: number]: unknown;
-        [x: symbol]: unknown;
-        type: string;
-    }) | undefined): void;
-    devtools: {
-        cleanup: () => void;
-    };
-}>;
-/** Hook to get a specific widget by ID
- * @param id - Widget ID
- * @returns Widget state or undefined if not found
- * @example
- * ```tsx
- * const widget = useWidget('widget-1')
- * ```
- */
-export declare const useWidget: <T extends WidgetState>(id: string) => T | undefined;
+export declare const useWidgetStore: import('zustand').UseBoundStore<import('zustand').StoreApi<WidgetStore>>;

package/dist/types/widgets/subheader/index.d.ts

@@ -0,0 +1,2 @@
+export { Subheader } from './subheader';
+export type { SubheaderComponentProps } from './types';

package/dist/types/widgets/subheader/style.d.ts

@@ -0,0 +1,19 @@
+import { Theme } from '@mui/material';
+export declare const styles: {
+    root: {
+        display: "flex";
+        alignItems: "center";
+        gap: ({ spacing }: Theme) => string;
+        minHeight: ({ spacing }: Theme) => string;
+    };
+    slotLeft: {
+        flexShrink: number;
+    };
+    slotRight: {
+        flexGrow: number;
+        display: "flex";
+        justifyContent: "flex-end";
+        alignItems: "center";
+        gap: ({ spacing }: Theme) => string;
+    };
+};

package/dist/types/widgets/subheader/subheader.d.ts

@@ -0,0 +1,2 @@
+import { SubheaderComponentProps } from './types';
+export declare function Subheader({ slotLeft, slotRight, sx, }: SubheaderComponentProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/widgets/subheader/types.d.ts

@@ -0,0 +1,10 @@
+import { SxProps, Theme } from '@mui/material';
+import { ReactNode } from 'react';
+export interface SubheaderComponentProps {
+    /** Content for the left slot */
+    slotLeft?: ReactNode;
+    /** Content for the right slot*/
+    slotRight?: ReactNode;
+    /** Custom styles */
+    sx?: SxProps<Theme>;
+}

package/dist/types/widgets/table/components/cell-header.d.ts

@@ -0,0 +1,5 @@
+import { CellHeaderProps } from '../types';
+/**
+ * Table cell header component with optional sorting and select-all checkbox
+ */
+export declare function CellHeader({ column, sortState, onSort, isSelectAll, isAllSelected, isIndeterminate, onSelectAll, }: CellHeaderProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/widgets/table/components/cell.d.ts

@@ -0,0 +1,16 @@
+import { TableColumn } from '../types';
+/**
+ * Props for Cell component
+ */
+export interface CellProps {
+    /** Column definition */
+    column: TableColumn;
+    /** Cell value */
+    value: unknown;
+}
+/**
+ * Table cell component with automatic markdown support for string values
+ * Markdown is rendered when the raw value is a string and no formatter is defined.
+ * If a formatter is used, its output is rendered directly without markdown parsing.
+ */
+export declare function Cell({ column, value }: CellProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/widgets/table/components/index.d.ts

@@ -0,0 +1,4 @@
+export { CellHeader } from './cell-header';
+export { Row } from './row';
+export { Pagination } from './pagination';
+export { PaginationActions } from './pagination-actions';

package/dist/types/widgets/table/components/pagination-actions.d.ts

@@ -0,0 +1,5 @@
+import { PaginationActionsProps } from '../types';
+/**
+ * Custom pagination actions with first/prev/next/last buttons
+ */
+export declare function PaginationActions({ count, page, rowsPerPage, onPageChange, }: PaginationActionsProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/widgets/table/components/pagination.d.ts

@@ -0,0 +1,5 @@
+import { PaginationProps } from '../types';
+/**
+ * Table pagination component
+ */
+export declare function Pagination({ page, rowsPerPage, total, rowsPerPageOptions, onPageChange, onRowsPerPageChange, }: PaginationProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/widgets/table/components/row.d.ts

@@ -0,0 +1,5 @@
+import { RowProps } from '../types';
+/**
+ * Table row component with selection and hover support
+ */
+export declare function Row({ row, columns, isSelected, selectable, onClick, onSelect, onMouseEnter, onMouseLeave, }: RowProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/widgets/table/config.d.ts

@@ -0,0 +1,11 @@
+import { ConfigProps } from '../root/types';
+import { TableDownloadConfig, TableWidgetConfig, TableColumn } from './types';
+/**
+ * Default table download configuration
+ * Supports PNG export (screenshot) and CSV export (data)
+ */
+export declare function tableDownloadConfig({ refUI, }: ConfigProps): TableDownloadConfig;
+/**
+ * Default table widget configuration
+ */
+export declare function tableConfig(columns?: TableColumn[]): TableWidgetConfig;

package/dist/types/widgets/table/helpers.d.ts

@@ -0,0 +1,38 @@
+import { ReactNode } from 'react';
+/**
+ * Get formatted cell value for display
+ * Handles primitives, arrays, objects, and custom formatters
+ *
+ * @param cellValue - Raw cell value
+ * @param formatter - Optional formatter function
+ * @returns Formatted value for display
+ */
+export declare function getCellValue<T>(cellValue: T): ReactNode;
+/**
+ * Compare two values for sorting
+ * Handles strings, numbers, and other types
+ *
+ * @param a - First value
+ * @param b - Second value
+ * @param direction - Sort direction
+ * @returns Comparison result (-1, 0, 1)
+ */
+export declare function compareValues(a: unknown, b: unknown, direction: 'asc' | 'desc'): number;
+/**
+ * Sort data array by column
+ *
+ * @param data - Data array to sort
+ * @param columnId - Column ID to sort by
+ * @param direction - Sort direction
+ * @returns Sorted data array (new array, does not mutate original)
+ */
+export declare function sortData<T extends Record<string, unknown>>(data: T[], columnId: string, direction: 'asc' | 'desc'): T[];
+/**
+ * Paginate data array
+ *
+ * @param data - Data array to paginate
+ * @param page - Current page (0-indexed)
+ * @param rowsPerPage - Number of rows per page
+ * @returns Paginated data slice
+ */
+export declare function paginateData<T>(data: T[], page: number, rowsPerPage: number): T[];

package/dist/types/widgets/table/helpers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/widgets/table/hooks/index.d.ts

@@ -0,0 +1,6 @@
+export { usePagination } from './use-pagination';
+export { useSort } from './use-sort';
+export { useSelection } from './use-selection';
+export type { UsePaginationOptions, UsePaginationResult, } from './use-pagination';
+export type { UseSortOptions, UseSortResult } from './use-sort';
+export type { UseSelectionOptions, UseSelectionResult } from './use-selection';

package/dist/types/widgets/table/hooks/use-pagination.d.ts

@@ -0,0 +1,45 @@
+import { TableRow, PaginationMode } from '../types';
+export interface UsePaginationOptions {
+    /** Pagination mode: local or remote */
+    mode: PaginationMode;
+    /** Initial page (0-indexed) */
+    initialPage?: number;
+    /** Initial rows per page */
+    initialRowsPerPage?: number;
+    /** Available rows per page options */
+    rowsPerPageOptions?: number[];
+    /** Total rows (for remote pagination) */
+    total?: number;
+    /** Callback when page changes (for remote pagination) */
+    onPageChange?: (page: number, rowsPerPage: number) => void;
+}
+export interface UsePaginationResult<T> {
+    /** Current page (0-indexed) */
+    page: number;
+    /** Rows per page */
+    rowsPerPage: number;
+    /** Total row count */
+    total: number;
+    /** Available rows per page options */
+    rowsPerPageOptions: number[];
+    /** Paginated data (for local mode) */
+    paginatedData: T[];
+    /** Set current page */
+    setPage: (page: number) => void;
+    /** Set rows per page */
+    setRowsPerPage: (rowsPerPage: number) => void;
+    /** Go to first page */
+    goToFirstPage: () => void;
+    /** Go to last page */
+    goToLastPage: () => void;
+    /** Go to next page */
+    goToNextPage: () => void;
+    /** Go to previous page */
+    goToPreviousPage: () => void;
+}
+/**
+ * Hook for managing table pagination
+ * Supports both local (client-side) and remote (server-side) pagination
+ * State is persisted in the widget store for the given widgetId
+ */
+export declare function usePagination<T extends TableRow>(widgetId: string, data: T[], options: UsePaginationOptions): UsePaginationResult<T>;

package/dist/types/widgets/table/hooks/use-pagination.test.d.ts

@@ -0,0 +1 @@
+export {};