@carto/ps-react-ui 5.0.0-widgets.9 → 5.1.0

package/dist/types/widgets/skeleton-loader/types.d.ts

@@ -1,5 +1,5 @@
 import { ElementType, ReactNode } from 'react';
-import { WidgetState } from '../stores/types';
+import { WidgetState } from '../stores/types.js';
 export interface SkeletonLoaderProps {
     id: WidgetState['id'];
     Skeleton: ElementType | null;

package/dist/types/widgets/spread/components/max-value.d.ts

@@ -1,2 +1,5 @@
-import { ValueProps } from '../types';
-export declare function MaxValue({ id, index, ...props }: ValueProps): import("react/jsx-runtime").JSX.Element;
+import { ValueProps } from '../types.js';
+/**
+ * Displays the formatted maximum value for a spread widget data item.
+ */
+export declare function MaxValue({ id, index, ...props }: ValueProps): import('react').JSX.Element;

package/dist/types/widgets/spread/components/min-value.d.ts

@@ -1,2 +1,5 @@
-import { ValueProps } from '../types';
-export declare function MinValue({ id, index, ...props }: ValueProps): import("react/jsx-runtime").JSX.Element;
+import { ValueProps } from '../types.js';
+/**
+ * Displays the formatted minimum value for a spread widget data item.
+ */
+export declare function MinValue({ id, index, ...props }: ValueProps): import('react').JSX.Element;

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

@@ -1,2 +1,5 @@
-import { ItemProps } from '../../formula/types';
-export declare function Separator(props: Omit<ItemProps, 'children'>): import("react/jsx-runtime").JSX.Element;
+import { ItemProps } from '../../formula/types.js';
+/**
+ * Renders a dash separator between the min and max values in a spread widget.
+ */
+export declare function Separator(props: Omit<ItemProps, 'children'>): import('react').JSX.Element;

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

@@ -1,10 +1,16 @@
-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[];
-}
+import { DownloadItem } from '../actions/index.js';
+import { ConfigProps } from '../loader/types.js';
+import { SpreadWidgetConfig, SpreadWidgetData } from './types.js';
+/**
+ * Creates download configuration for spread widgets, supporting PNG (screenshot) and CSV (min/max data) exports.
+ *
+ * @param props - Configuration with `refUI` reference for PNG export.
+ * @returns Array of download items for use with the Download action.
+ */
 export declare function spreadDownloadConfig({ refUI, }: ConfigProps): DownloadItem<SpreadWidgetData>[];
+/**
+ * Returns the default configuration for spread (min/max value range) widgets.
+ *
+ * @returns Default spread widget config with empty series.
+ */
 export declare function spreadConfig(): SpreadWidgetConfig;

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

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

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

@@ -1 +1 @@
-export declare function SpreadSkeleton(): import("react/jsx-runtime").JSX.Element;
+export declare function SpreadSkeleton(): import('react').JSX.Element;

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

@@ -1,2 +1,5 @@
-import { SpreadUIProps } from './types';
-export declare function SpreadUI(props: SpreadUIProps): import("react/jsx-runtime").JSX.Element;
+import { SpreadUIProps } from './types.js';
+/**
+ * Renders a spread widget displaying min-max value pairs with optional prefixes, suffixes, and series indicators.
+ */
+export declare function SpreadUI(props: SpreadUIProps): import('react').JSX.Element;

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

@@ -1,9 +1,9 @@
 import { TypographyProps } from '@mui/material';
 import { ReactNode } from 'react';
-import { BaseWidgetState, WidgetsStoreProps } from '../stores/types';
-import { WrapperState } from '../wrapper/types';
-import { DownloadItem } from '../actions/download/types';
-import { SeriesConfig } from '../formula/types';
+import { BaseWidgetState, WidgetsStoreProps } from '../stores/types.js';
+import { WrapperState } from '../wrapper/types.js';
+import { DownloadItem } from '../actions/download/types.js';
+import { SeriesConfig } from '../formula/types.js';
 export interface SpreadUIProps {
     id: WidgetsStoreProps['id'];
 }

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

@@ -1,2 +1,3 @@
-export { useWidgetStore } from './widget-store';
-export type { BaseWidgetState, WidgetsStoreProps, WidgetState, WidgetStore, WidgetStoreActions, WidgetStoreState, } from './types';
+export { useWidgetStore, widgetStoreActions } from './widget-store.js';
+export { useWidgetSelector } from './use-widget-selector.js';
+export type { BaseWidgetState, ToolRegistration, ToolTransformFunction, ToolType, WidgetsStoreProps, WidgetState, WidgetStore, WidgetStoreActions, WidgetStoreState, } from './types.js';

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

@@ -1,4 +1,10 @@
 import { RefObject } from 'react';
+/**
+ * Tool type determines which pipeline a tool participates in.
+ * - 'data': transforms widget data (default)
+ * - 'config': transforms widget config/option
+ */
+export type ToolType = 'data' | 'config';
 export interface WidgetsStoreProps {
     /** Unique identifier for the widget */
     id: string;
@@ -6,6 +12,10 @@ export interface WidgetsStoreProps {
     type: string;
     /** Widget data - flexible to accommodate different widget types */
     data: unknown;
+    /** Original pre-pipeline data. Used by NoData to distinguish
+     *  "no data from API" from "pipeline tools filtered everything out".
+     *  Set automatically by executeToolPipeline — not a component prop. */
+    sourceData?: unknown;
     /** Loading state */
     isLoading: boolean;
     /** Fetching state (e.g., for async data) */
@@ -21,12 +31,18 @@ export interface WidgetsStoreProps {
     refUI?: RefObject<HTMLElement | null>;
     /** Registered tools for the widget's transformation pipeline */
     registeredTools?: ToolRegistration[];
+    /** Formatter function for widget values */
+    formatter?: (value: number) => string;
+    /** Formatter function for widget label/category values */
+    labelFormatter?: (value: string | number) => string | number;
+    /** Locale for number formatting (e.g., 'en-US', 'es-ES', 'fr-FR') */
+    locale?: string;
 }
 /**
  * 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;
+export type ToolTransformFunction = (data: unknown) => unknown;
 /**
  * Tool registration for widget pipeline
  *
@@ -66,8 +82,8 @@ export interface ToolRegistration {
     fn: ToolTransformFunction;
     /** Whether tool is currently enabled */
     enabled: boolean;
-    /** Tool-specific configuration */
-    config?: Record<string, unknown>;
+    /** 'data' (default) transforms data, 'config' transforms widget config/option */
+    type?: ToolType;
     /**
      * Array of tool IDs to disable when this tool is active.
      * During pipeline execution, if this tool is enabled, any tools listed
@@ -133,13 +149,6 @@ export interface WidgetStoreActions {
      * @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
@@ -147,6 +156,11 @@ export interface WidgetStoreActions {
      * @param enabled - Whether tool should be enabled
      */
     setToolEnabled: (widgetId: string, toolId: string, enabled: boolean) => void;
+    /**
+     * Trigger pipeline re-execution by bumping the registeredTools reference.
+     * @param widgetId - Widget ID
+     */
+    triggerToolPipeline: (widgetId: string) => void;
     /**
      * Execute the tool transformation pipeline
      * Supports both synchronous and asynchronous tools
@@ -154,6 +168,13 @@ export interface WidgetStoreActions {
      * @param sourceData - Original data to transform
      */
     executeToolPipeline: (widgetId: string, sourceData: unknown) => Promise<void>;
+    /**
+     * Execute the config transformation pipeline
+     * Applies config-type tools to the base config, then sets the result on the widget
+     * @param widgetId - Widget ID
+     * @param baseConfig - Base config to transform
+     */
+    executeConfigPipeline: (widgetId: string, baseConfig: object) => Promise<void>;
 }
 /**
  * Complete widget store interface

package/dist/types/widgets/stores/use-widget-selector.d.ts

@@ -0,0 +1,35 @@
+import { WidgetState } from './types.js';
+/**
+ * Scoped selector hook for reading a single widget's state from the store.
+ *
+ * Consolidates multiple `useWidgetStore(useShallow(...))` calls into a single
+ * subscription per component. The selector receives only this widget's state
+ * (or undefined if not yet registered), and uses shallow comparison to avoid
+ * re-renders when unrelated properties change.
+ *
+ * @param widgetId - The widget ID to subscribe to.
+ * @param selector - A function that extracts the needed properties from the widget state.
+ *   Must be a stable reference (inline arrow is fine due to useCallback wrapping).
+ *
+ * @example
+ * ```tsx
+ * // Before: 4 separate subscriptions
+ * const title = useWidgetStore(useShallow((s) => s.getWidget(id)?.title))
+ * const collapsed = useWidgetStore(useShallow((s) => s.getWidget(id)?.collapsed))
+ * const disabled = useWidgetStore(useShallow((s) => s.getWidget(id)?.disabled))
+ * const isFetching = useWidgetStore(useShallow((s) => s.getWidget(id)?.isFetching))
+ *
+ * // After: 1 subscription
+ * const { title, collapsed, disabled, isFetching } = useWidgetSelector(id, (w) => ({
+ *   title: w?.title, collapsed: w?.collapsed, disabled: w?.disabled, isFetching: w?.isFetching,
+ * }))
+ *
+ * // With extra dependencies (e.g., index prop):
+ * const value = useWidgetSelector(
+ *   id,
+ *   (w) => (w as MyState | undefined)?.data?.[index]?.value,
+ *   [index],
+ * )
+ * ```
+ */
+export declare function useWidgetSelector<T>(widgetId: string, selector: (widget: WidgetState | undefined) => T): T;

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

@@ -1,39 +1,60 @@
-import { WidgetStore } from './types';
+import { WidgetStore, WidgetStoreActions } from './types.js';
 /**
  * Zustand store for managing widget state across the application.
  *
- * This store provides centralized state management for all widget UI components
+ * Provides centralized state management for all widget UI components, including
+ * data/config transformation pipelines via registered tools.
  *
- * @example
+ * **Performance optimizations:**
+ * - `registerTool` skips the store update when structural properties (order, enabled,
+ *   type, disables) haven't changed — only `fn` is updated via direct mutation,
+ *   avoiding a new `registeredTools` array reference and WidgetLoader pipeline cascades.
+ * - `setToolEnabled` skips the store update when the enabled state is already the
+ *   requested value.
+ * - `executeToolPipeline` / `executeConfigPipeline` skip the final `set()` when
+ *   the transformed data/config is referentially identical to what's already in the store.
+ * - Both pipelines support cancellation — newer executions for the same widget
+ *   automatically cancel in-progress ones.
+ *
+ * @example Reading widget state (prefer useWidgetSelector for performance)
  * ```tsx
- * // Import the store
- * import { useWidgetStore } from '@carto/ps-react-ui/widgets'
- *
- * // Use in a component
- * function MyWidget() {
- *   const setWidget = useWidgetStore((state) => state.setWidget)
- *   const widget = useWidgetStore((state) => state.widgets['my-widget'])
- *
- *   useEffect(() => {
- *     setWidget({
- *       id: 'my-widget',
- *       type: 'formula',
- *       title: 'Total Sales',
- *       isLoading: false,
- *       visible: true,
- *       data: { value: 1000, prefix: '$' }
- *     })
- *   }, [setWidget])
- *
- *   return <div>{widget?.data?.value}</div>
+ * import { useWidgetSelector } from '@carto/ps-react-ui/widgets'
+ *
+ * function MyWidget({ id }: { id: string }) {
+ *   const { title, data } = useWidgetSelector(id, (w) => ({
+ *     title: w?.title,
+ *     data: w?.data,
+ *   }))
+ *   return <div>{title}: {JSON.stringify(data)}</div>
  * }
  * ```
  *
- * @example
+ * @example Writing widget state
  * ```tsx
- * // Get widgets by type
- * const getWidgetsByType = useWidgetStore((state) => state.getWidgetsByType)
- * const formulaWidgets = getWidgetsByType('formula')
+ * import { widgetStoreActions } from '@carto/ps-react-ui/widgets'
+ *
+ * const { setWidget } = widgetStoreActions
+ * setWidget('my-widget', { type: 'formula', isLoading: false, data: { value: 1000 } })
  * ```
  */
 export declare const useWidgetStore: import('zustand').UseBoundStore<import('zustand').StoreApi<WidgetStore>>;
+/**
+ * Stable references to store actions, accessible without creating a subscription.
+ *
+ * Use this instead of `useWidgetStore((state) => state.setWidget)` to avoid
+ * unnecessary subscriber evaluations. Actions are stable functions that never
+ * change, so subscribing to them wastes cycles on every store update.
+ *
+ * @example
+ * ```tsx
+ * import { widgetStoreActions } from '@carto/ps-react-ui/widgets'
+ *
+ * const { setWidget, registerTool } = widgetStoreActions
+ *
+ * useEffect(() => {
+ *   registerTool(id, { id: 'my-tool', order: 10, enabled: true, fn: (d) => d })
+ *   return () => widgetStoreActions.unregisterTool(id, 'my-tool')
+ * }, [id])
+ * ```
+ */
+export declare const widgetStoreActions: WidgetStoreActions;

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

@@ -1,2 +1,2 @@
-export { WidgetSubHeader } from './subheader';
-export type { WidgetSubHeaderProps } from './types';
+export { WidgetSubHeader } from './subheader.js';
+export type { WidgetSubHeaderProps } from './types.js';

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

@@ -1,2 +1,13 @@
-import { WidgetSubHeaderProps } from './types';
-export declare function WidgetSubHeader({ slotLeft, slotRight, sx, }: WidgetSubHeaderProps): import("react/jsx-runtime").JSX.Element;
+import { WidgetSubHeaderProps } from './types.js';
+/**
+ * Flexible two-slot layout for displaying supplementary widget information such as totals, timestamps, or controls. Uses flexbox with space-between justification.
+ *
+ * @example
+ * ```tsx
+ * <WidgetSubHeader
+ *   slotLeft={<Typography variant="caption">Total: 1,234</Typography>}
+ *   slotRight={<Typography variant="caption">Updated: 2m ago</Typography>}
+ * />
+ * ```
+ */
+export declare function WidgetSubHeader({ slotLeft, slotRight, sx, }: WidgetSubHeaderProps): import('react').JSX.Element;

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

@@ -1,5 +1,5 @@
-import { CellHeaderProps } from '../types';
+import { CellHeaderProps } from '../types.js';
 /**
  * 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;
+export declare function CellHeader({ column, sortState, onSort, isSelectAll, isAllSelected, isIndeterminate, onSelectAll, }: CellHeaderProps): import('react').JSX.Element;

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

@@ -1,10 +1,12 @@
-import { TableColumn } from '../types';
+import { TableColumn, TableRow } from '../types.js';
 /**
  * Props for Cell component
  */
 export interface CellProps {
     /** Column definition */
     column: TableColumn;
+    /** Full table row for context */
+    row: TableRow;
     /** Cell value */
     value: unknown;
 }
@@ -13,4 +15,4 @@ export interface CellProps {
  * 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;
+export declare function Cell({ column, row, value }: CellProps): import('react').JSX.Element;

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

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

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

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

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

@@ -1,5 +1,5 @@
-import { RowProps } from '../types';
+import { RowProps } from '../types.js';
 /**
  * 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;
+export declare function Row({ row, columns, isSelected, selectable, onClick, onSelect, onMouseEnter, onMouseLeave, }: RowProps): import('react').JSX.Element;

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

@@ -1,17 +1,21 @@
-import { ConfigProps } from '../root/types';
-import { TableDownloadConfig, TableWidgetConfig, TableColumn, Mode, SortDirection } from './types';
-export declare const DEFAULT_MODE: Mode;
+import { ConfigProps } from '../loader/types.js';
+import { TableDownloadConfig, TableWidgetConfig, TableColumn, SortDirection } from './types.js';
 export declare const DEFAULT_PAGE = 0;
 export declare const DEFAULT_ROWS_PER_PAGE = 10;
 export declare const DEFAULT_ROWS_PER_PAGE_OPTIONS: number[];
 export declare const DEFAULT_COLUMN_ID: null;
 export declare const DEFAULT_DIRECTION: SortDirection;
 /**
- * Default table download configuration
- * Supports PNG export (screenshot) and CSV export (data)
+ * Creates download configuration for table widgets, supporting PNG (screenshot) and CSV (data) exports. CSV output uses column keys as headers and filters out `id` fields.
+ *
+ * @param props - Configuration with `refUI` reference for PNG export.
+ * @returns Array of download items for use with the Download action.
  */
 export declare function tableDownloadConfig({ refUI, }: ConfigProps): TableDownloadConfig;
 /**
- * Default table widget configuration
+ * Returns the default configuration for table widgets with pagination and sorting, including column definitions and local data mode.
+ *
+ * @param columns - Array of column definitions for the table.
+ * @returns Default table widget config.
  */
 export declare function tableConfig(columns?: TableColumn[]): TableWidgetConfig;

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

@@ -1,4 +1,4 @@
-import { TableRow } from '../types';
+import { TableRow } from '../types.js';
 export interface UsePaginationResult<T> {
     /** Whether pagination is enabled */
     paginationEnabled: boolean;
@@ -26,8 +26,16 @@ export interface UsePaginationResult<T> {
     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
+ * Hook for managing table pagination with support for both local (client-side) and remote (server-side) modes.
+ * State is persisted in the widget store for the given widget ID.
+ *
+ * @param widgetId - The widget ID to persist pagination state under.
+ * @param data - The full data array (used for local pagination and total count fallback).
+ * @returns Pagination state and navigation helpers.
+ *
+ * @example
+ * ```tsx
+ * const { page, setPage, paginatedData, totalPages } = usePagination(widgetId, data)
+ * ```
  */
 export declare function usePagination<T extends TableRow>(widgetId: string, data: T[]): UsePaginationResult<T>;

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

@@ -1,4 +1,4 @@
-import { TableRow } from '../types';
+import { TableRow } from '../types.js';
 export interface UseSelectionOptions {
     /** Callback when selection changes */
     onSelectionChange?: (selectedIds: (string | number)[]) => void;
@@ -24,7 +24,16 @@ export interface UseSelectionResult {
     clearSelection: () => void;
 }
 /**
- * Hook for managing table row selection
- * Selection persists across pagination and is stored in the widget store
+ * Hook for managing table row selection with persistence across pagination.
+ * Selection state is stored in the widget store for the given widget ID.
+ *
+ * @param widgetId - The widget ID to persist selection state under.
+ * @param options - Optional configuration including an `onSelectionChange` callback.
+ * @returns Selection state and control functions (toggle, select, deselect, clear).
+ *
+ * @example
+ * ```tsx
+ * const { selectedIds, isAllSelected, handleSelectRow, clearSelection } = useSelection(widgetId)
+ * ```
  */
 export declare function useSelection(widgetId: string, options?: UseSelectionOptions): UseSelectionResult;

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

@@ -1,4 +1,4 @@
-import { TableRow, SortDirection, SortState } from '../types';
+import { TableRow, SortDirection, SortState } from '../types.js';
 export interface UseSortResult<T> extends SortState {
     /** Whether sorting is enabled */
     sortEnabled: boolean;
@@ -15,8 +15,16 @@ export interface UseSortResult<T> extends SortState {
     clearSort: () => void;
 }
 /**
- * Hook for managing table sorting
- * Supports both local (client-side) and remote (server-side) sorting
- * State is persisted in the widget store for the given widgetId
+ * Hook for managing table sorting with support for both local (client-side) and remote (server-side) modes.
+ * State is persisted in the widget store for the given widget ID.
+ *
+ * @param widgetId - The widget ID to persist sort state under.
+ * @param data - The data array to sort (for local mode).
+ * @returns Sort state, sorted data, and sort control functions.
+ *
+ * @example
+ * ```tsx
+ * const { sortedData, sortField, sortDirection, handleSort } = useSort(widgetId, data)
+ * ```
  */
 export declare function useSort<T extends TableRow>(widgetId: string, data: T[]): UseSortResult<T>;

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

@@ -1,13 +1,17 @@
-export { CellHeader } from './components/cell-header';
-export { Row } from './components/row';
-export { Pagination } from './components/pagination';
-export { PaginationActions } from './components/pagination-actions';
-export { Table } from './table-ui';
-export { usePagination, useSort, useSelection } from './hooks';
-export { tableConfig, tableDownloadConfig } from './config';
-export { TableSkeleton } from './skeleton';
-export { sanitizeTableRow, sanitizeTableData } from './serializer';
-export { getCellValue, compareValues, sortData, paginateData } from './helpers';
-export { styles as tableStyles } from './style';
-export type { TableUIProps, TableColumn, TableRow, TableWidgetData, TablePaginationState, SortDirection, SortState, Mode, TableWidgetConfig, TableWidgetState, TableDownloadConfig, TableProps, CellHeaderProps, RowProps, PaginationProps, PaginationActionsProps, } from './types';
-export type { UsePaginationOptions, UsePaginationResult, UseSortOptions, UseSortResult, UseSelectionOptions, UseSelectionResult, } from './hooks';
+export { CellHeader } from './components/cell-header.js';
+export { Row } from './components/row.js';
+export { Pagination } from './components/pagination.js';
+export { PaginationActions } from './components/pagination-actions.js';
+export { Table } from './table-ui.js';
+export { usePagination } from './hooks/use-pagination.js';
+export { useSort } from './hooks/use-sort.js';
+export { useSelection } from './hooks/use-selection.js';
+export { tableConfig, tableDownloadConfig } from './config.js';
+export { TableSkeleton } from './skeleton.js';
+export { sanitizeTableRow, sanitizeTableData } from './serializer.js';
+export { getCellValue, compareValues, sortData, paginateData } from './helpers.js';
+export { styles as tableStyles } from './style.js';
+export type { TableUIProps, TableColumn, TableRow, TableWidgetData, TablePaginationState, SortDirection, SortState, Mode, TableWidgetConfig, TableWidgetState, TableDownloadConfig, TableProps, CellHeaderProps, RowProps, PaginationProps, PaginationActionsProps, } from './types.js';
+export type { UsePaginationResult } from './hooks/use-pagination.js';
+export type { UseSortResult } from './hooks/use-sort.js';
+export type { UseSelectionOptions, UseSelectionResult, } from './hooks/use-selection.js';

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

@@ -1,4 +1,4 @@
-import { TableRow, TableWidgetData } from './types';
+import { TableRow, TableWidgetData } from './types.js';
 /**
  * Sanitizes a table row by ensuring all values are serializable.
  * Converts ReactNode and function values to undefined.

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

@@ -7,4 +7,4 @@ export interface TableSkeletonProps {
 /**
  * Table skeleton loader component
  */
-export declare function TableSkeleton({ columns, rows }: TableSkeletonProps): import("react/jsx-runtime").JSX.Element;
+export declare function TableSkeleton({ columns, rows }: TableSkeletonProps): import('react').JSX.Element;

package/dist/types/widgets/table/table-ui.d.ts

@@ -1,10 +1,10 @@
 import { TableCell, TableProps as MuiTableProps } from '@mui/material';
 import { Ref } from 'react';
-import { TableUIProps } from './types';
+import { TableUIProps } from './types.js';
 /**
  * Props for the base Table component
  */
-export interface TableComponentProps extends MuiTableProps {
+interface TableComponentProps extends MuiTableProps {
     /** Table element ref */
     ref?: Ref<HTMLTableElement>;
 }
@@ -12,21 +12,21 @@ export interface TableComponentProps extends MuiTableProps {
  * Base Table component with compound component pattern
  * Provides Table.Head, Table.Body, Table.Row, Table.Cell, Table.CellHeader, Table.Pagination
  */
-declare function Table({ children, ref, stickyHeader, ...props }: TableComponentProps): import("react/jsx-runtime").JSX.Element;
+declare function Table({ children, ref, stickyHeader, ...props }: TableComponentProps): import('react').JSX.Element;
 declare namespace Table {
     var Head: import("@mui/material/OverridableComponent").OverridableComponent<import("@mui/material").TableHeadTypeMap<{}, "thead">>;
-    var CellHeader: typeof import(".").CellHeader;
+    var CellHeader: typeof import("./index.js").CellHeader;
     var Body: import("@mui/material/OverridableComponent").OverridableComponent<import("@mui/material").TableBodyTypeMap<{}, "tbody">>;
-    var Row: typeof import(".").Row;
+    var Row: typeof import("./index.js").Row;
     var Cell: typeof TableCell;
     var Container: typeof TableContainer;
     var Paper: import("@mui/material/OverridableComponent").OverridableComponent<import("@mui/material").PaperTypeMap<{}, "div">>;
-    var Pagination: typeof import(".").Pagination;
-    var PaginationActions: typeof import(".").PaginationActions;
+    var Pagination: typeof import("./index.js").Pagination;
+    var PaginationActions: typeof import("./index.js").PaginationActions;
 }
 export { Table };
 /**
  * TableContainer widget component
  * Integrates with widget store and provides ref registration using custom hook
  */
-declare function TableContainer(props: TableUIProps): import("react/jsx-runtime").JSX.Element;
+declare function TableContainer(props: TableUIProps): import('react').JSX.Element;