@stackcraftmx/calcita 0.0.0-stage → 0.25.0

package/dist/types/DataTable/ColumnFilters/MultiSelectColumnFilter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @param {object} props
+ * @param {string[]} [props.value]
+ * @param {(value: string[]) => void} props.onChange
+ * @param {Array<{value: string, total: number}>} [props.options] faceta del servidor
+ * @param {(value: string) => import('react').ReactNode} [props.renderOption] cómo se lee el valor (diccionario)
+ */
+export default function MultiSelectColumnFilter({ value, onChange, options, renderOption }: {
+    value?: string[];
+    onChange: (value: string[]) => void;
+    options?: Array<{
+        value: string;
+        total: number;
+    }>;
+    renderOption?: (value: string) => import('react').ReactNode;
+}): import("react").JSX.Element;

package/dist/types/DataTable/ColumnFilters/SortableFilterHeader.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @param {object} props
+ * @param {string} props.label
+ * @param {boolean} [props.sortable]
+ * @param {{column: string, direction: 'asc'|'desc'}} [props.sortEntry]
+ * @param {() => void} [props.onSort]
+ * @param {() => void} [props.onClearSort]
+ * @param {boolean} [props.filterable]
+ * @param {number} [props.activeCount]
+ * @param {() => void} [props.onClear]
+ * @param {import('react').ReactNode} [props.children] el filtro de la columna
+ */
+export default function SortableFilterHeader({ label, sortable, sortEntry, onSort, onClearSort, filterable, activeCount, onClear, children, }: {
+    label: string;
+    sortable?: boolean;
+    sortEntry?: {
+        column: string;
+        direction: 'asc' | 'desc';
+    };
+    onSort?: () => void;
+    onClearSort?: () => void;
+    filterable?: boolean;
+    activeCount?: number;
+    onClear?: () => void;
+    children?: import('react').ReactNode;
+}): import("react").JSX.Element;

package/dist/types/DataTable/ColumnFilters/TextColumnFilter.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param {{value: string, onChange: (value: string) => void, label?: string}} props label ya traducido
+ */
+export default function TextColumnFilter({ value, onChange, label }: {
+    value: string;
+    onChange: (value: string) => void;
+    label?: string;
+}): import("react").JSX.Element;

package/dist/types/DataTable/ColumnFilters/index.d.ts

@@ -0,0 +1,4 @@
+export { default as HeaderFilterPopover } from './HeaderFilterPopover.js';
+export { default as MultiSelectColumnFilter } from './MultiSelectColumnFilter.js';
+export { default as SortableFilterHeader } from './SortableFilterHeader.js';
+export { default as TextColumnFilter } from './TextColumnFilter.js';

package/dist/types/DataTable/EmptyState.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @param {object} [props]
+ * @param {boolean} [props.filtered]
+ * @param {string} [props.label] ya traducido
+ * @param {() => void} [props.onClearFilters]
+ * @param {object} [props.texts] los textos que cambian, con la forma de `table` en los textos del paquete
+ */
+export default function EmptyState({ filtered, label, onClearFilters, texts }?: {
+    filtered?: boolean;
+    label?: string;
+    onClearFilters?: () => void;
+    texts?: object;
+}): import("react").JSX.Element;

package/dist/types/DataTable/FilterChips.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @param {object} props
+ * @param {Array<object>} props.chipConfig lo que arma buildChipConfig
+ * @param {object} props.filters
+ * @param {(field: string, value: unknown) => void} props.onSetFilter
+ * @param {() => void} props.onClearAll
+ * @param {number} [props.quickActiveCount] accesos rápidos puestos que no tienen chip aquí
+ * @param {object} [props.texts] los textos que cambian, con la forma de `table` en los textos del paquete
+ */
+export default function FilterChips({ chipConfig, filters, onSetFilter, onClearAll, quickActiveCount, texts }: {
+    chipConfig: Array<object>;
+    filters: object;
+    onSetFilter: (field: string, value: unknown) => void;
+    onClearAll: () => void;
+    quickActiveCount?: number;
+    texts?: object;
+}): import("react").JSX.Element | null;

package/dist/types/DataTable/GoToPage.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @param {object} props
+ * @param {number} props.page cuenta desde 0
+ * @param {number} props.pageCount
+ * @param {(page: number) => void} props.onChange
+ * @param {object} [props.texts] los textos que cambian, con la forma de `table` en los textos del paquete
+ */
+export default function GoToPage({ page, pageCount, onChange, texts }: {
+    page: number;
+    pageCount: number;
+    onChange: (page: number) => void;
+    texts?: object;
+}): import("react").JSX.Element | null;

package/dist/types/DataTable/SelectionBar.d.ts

@@ -0,0 +1,32 @@
+/** Dónde va la barra de los elegidos: todo en el renglón, o dividida en el teléfono (arriba el conteo, abajo las acciones). */
+export declare const SELECTION_BAR_VARIANT: Readonly<{
+    row: "row";
+    header: "header";
+    actions: "actions";
+}>;
+/**
+ * @param {object} props
+ * @param {string} props.countText «5 elegidos», ya traducido
+ * @param {Array<{key: string, label: string, icon?: import('react').ReactNode, color?: string, isDisabled?: boolean}>} props.actions
+ *     las acciones de la pantalla, con isDisabled ya resuelto para la selección de ahora
+ * @param {string|null} props.runningActionKey la acción que está corriendo: mientras, las demás se apagan
+ * @param {(actionKey: string) => void} props.onRunAction
+ * @param {() => void} props.onClear quitar la selección
+ * @param {'row'|'header'|'actions'} [props.variant] SELECTION_BAR_VARIANT; por omisión el renglón
+ * @param {object} [props.sx]
+ */
+export default function SelectionBar({ countText, actions, runningActionKey, onRunAction, onClear, variant, sx }: {
+    countText: string;
+    actions: Array<{
+        key: string;
+        label: string;
+        icon?: import('react').ReactNode;
+        color?: string;
+        isDisabled?: boolean;
+    }>;
+    runningActionKey: string | null;
+    onRunAction: (actionKey: string) => void;
+    onClear: () => void;
+    variant?: 'row' | 'header' | 'actions';
+    sx?: object;
+}): import("react").JSX.Element;

package/dist/types/DataTable/ServerTable.d.ts

@@ -0,0 +1,171 @@
+import { SELECTION_PHONE_LAYOUT } from '../ui/actions/SelectionActions.js';
+export { SELECTION_PHONE_LAYOUT };
+export type RowSelection = import('./rowSelection.js').RowSelection;
+/** @typedef {import('./rowSelection.js').RowSelection} RowSelection */
+/**
+ * @param {object} props
+ * @param {(params: {filters: Record<string, any>, sortOrders: Array<{column: string, direction: 'asc'|'desc'}>, page: number, pageSize: number}, signal: AbortSignal) => Promise<{rows: any[], total: number, facets?: Record<string, Array<{value: any, total: number}> | number>, capped?: boolean}>} props.fetchPage
+ *     page cuenta desde 0; toServerTableParams lo convierte a la query del API
+ * @param {string} props.queryKey cambia cuando cambia el CONJUNTO (no los filtros): dispara recarga
+ * @param {boolean} [props.enabled] false mientras la sección está oculta: una tabla que nadie ve no consulta
+ * @param {Array<object>} props.columns textColumn / facetColumn / detailColumn o columnas del DataGrid
+ * @param {Record<string, string>} [props.filterKinds]
+ * @param {Record<string, unknown>} [props.filterDefaults]
+ * @param {Array<object>} [props.chipConfig] buildChipConfig
+ * @param {Array<object>} [props.quickFilters] {field, facetKey, caption, allLabel, renderLabel, order, clears,
+ *     isOverridden, renderExtra, allCountKey, hideAllCount}
+ * @param {string|null} [props.searchField] filtro de texto que se saca a la barra; null quita la caja
+ * @param {string} [props.searchPlaceholder]
+ * @param {boolean} [props.searchInBar] la caja de búsqueda va arriba, en la barra de la app (BarActions): en escritorio,
+ *     como el buscador de una ventana de macOS; en el teléfono con cápsulas flota arriba con las demás; sin cápsulas se
+ *     queda aquí. Por omisión no
+ * @param {boolean} [props.collapseSearchInBar] en la barra, sin usar se encoge a la lupa y se estira al picarla; por
+ *     omisión sí (false: siempre abierta)
+ * @param {string} [props.emptyLabel]
+ * @param {(total: number) => string} [props.countLabel] "12 pedidos"; por defecto "12 registros"
+ * @param {number[]} [props.pageSizeOptions]
+ * @param {number} [props.defaultPageSize]
+ * @param {(row: any) => string|number} [props.getRowId]
+ * @param {string} [props.prefix] estado en la URL con este prefijo (nuqs); sin él, en memoria
+ * @param {unknown} [props.refreshToken] cambia para volver a consultar la misma página (después de una acción)
+ * @param {(summary: {total: number, capped: boolean}) => import('react').ReactNode} [props.footer]
+ * @param {import('react').ReactNode} [props.toolbarExtra] a la derecha del conteo (p. ej. el selector de año)
+ * @param {(summary: {countText: string, total: number, capped: boolean}) => import('react').ReactNode} [props.header] reemplaza
+ *     el renglón del conteo: la página pinta título, conteo y controles en uno solo. countText ya viene traducido y con
+ *     el tope
+ * @param {import('react').ReactNode} [props.beforeQuickFilters] arriba de los accesos rápidos (p. ej. las pestañas de producto)
+ * @param {Array<object>} [props.columnGroupingModel] bandas que agrupan columnas bajo un nombre, arriba de sus
+ *     encabezados (columnGroupingModel del DataGrid). Con ellas el encabezado mide un renglón más
+ * @param {(params: any) => string} [props.getRowClassName]
+ * @param {(row: any) => boolean} [props.isRowVisible] cuáles renglones de la página se pintan; los demás se esconden
+ *     SIN volver a consultar (p. ej. plegar un grupo de renglones). Sin ella se pintan todos. OJO: va con useCallback;
+ *     una función nueva en cada pintada haría filtrar la página cada vez
+ * @param {boolean} [props.striped] renglones alternos (cebra) con el color de hover del tema; al pasar el cursor se usa
+ *     el de «seleccionado» para que el renglón bajo el cursor se siga distinguiendo
+ * @param {(params: any) => number|'auto'|null} [props.getRowHeight]
+ * @param {boolean} [props.hideFooterWhenAllRowsFit] esconde el pie (el paginador) mientras todo lo que hay cabe en la
+ *     página; si un día no cabe, el pie vuelve solo. Para tablas que casi nunca pasan de una página
+ * @param {boolean} [props.showGoToPage] «Ir a página N» junto al paginador; por omisión escondido (con las flechas basta en
+ *     casi todas las tablas). Para listas de muchas páginas que se recorren por número
+ * @param {object} [props.gridSx] estilos extra del DataGrid (clases de renglón)
+ * @param {number} [props.maxGridHeight] alto máximo del contenedor; sin él la tabla crece con sus renglones (default)
+ * @param {string} [props.ariaLabel] nombre de la tabla para lectores de pantalla
+ * @param {string} [props.fixedColumn] campo de la columna que se queda pegada a la izquierda al deslizar de lado (como
+ *     fixedSelectColumn de mui-datatables)
+ * @param {Array<{key: string, label: string, icon?: import('react').ReactNode, color?: 'inherit'|'primary'|'secondary'|'error'|'info'|'success'|'warning', isDisabled?: (selection: RowSelection) => boolean, onClick: (selection: RowSelection, helpers: {clearSelection: () => void, refresh: () => void}) => unknown}>} [props.selectionActions]
+ *     con ellas cada renglón lleva su casilla y, al elegir, sale la barra de los elegidos con estas acciones. label ya
+ *     traducido; onClick recibe la selección (con isAllMatching mande `filters`, no `ids`) y cómo quitar la selección y volver
+ *     a consultar después de actuar
+ * @param {(row: any) => boolean} [props.isRowSelectable] cuáles renglones se pueden elegir (un pedido entregado no se cancela)
+ * @param {boolean} [props.allowSelectAllMatching] la casilla de arriba elige todos los que coinciden (la acción recibe los
+ *     filtros) y el aviso deja quedarse solo con la página; por omisión sí. false: la casilla elige la página y nunca se
+ *     ofrece «todos»
+ * @param {(selection: RowSelection) => void} [props.onSelectionChange] cada que cambia la selección; también enciende las
+ *     casillas sin barra de acciones (la pantalla pinta las suyas)
+ * @param {'top'|'split'} [props.selectionPhoneLayout] SELECTION_PHONE_LAYOUT: en el teléfono con vidrio o minimalista, todo
+ *     arriba (por omisión) o el conteo arriba y las acciones abajo. Sin vidrio, en el renglón como en escritorio
+ * @param {(request: {filters: Record<string, any>, sortOrders: Array<{column: string, direction: 'asc'|'desc'}>, page: number, pageSize: number}) => void} [props.onQueryChange]
+ *     cada que cambia lo que pide la tabla (un filtro, el orden, la página), antes de consultar: para la lógica de negocio que
+ *     depende de lo filtrado («si eligió Cancelados, enseñe el motivo»)
+ * @param {(result: {rows: any[], total: number, facets: object, capped: boolean}) => void} [props.onLoaded] cada que llega una
+ *     página del servidor
+ * @param {(error: unknown) => void} [props.onLoadError] cuando la consulta falla (la tabla ya enseña su aviso con «Reintentar»)
+ * @param {object} [props.gridProps] lo demás del DataGrid de MUI, sobre todo sus eventos (onRowClick, onRowDoubleClick,
+ *     onCellKeyDown…). OJO: lo que la tabla controla (paginar, ordenar y filtrar en el servidor, el alto, la selección) no se
+ *     reemplaza desde aquí: para eso están sus props
+ * @param {object} [props.texts] los textos de la tabla que cambian, con la forma de `table` en los textos del paquete
+ *     (src/locales/es.js), ya en el idioma de la pantalla: {selection: {clear: 'Deseleccionar'}, empty: {filtered: '…'}}.
+ *     También les llegan a sus filtros de columna, sus chips y su barra de elegidos
+ */
+export default function ServerTable({ fetchPage, queryKey, enabled, columns, filterKinds, filterDefaults, chipConfig, quickFilters, searchField, searchPlaceholder, searchInBar, collapseSearchInBar, emptyLabel, countLabel, pageSizeOptions, defaultPageSize, getRowId, prefix, refreshToken, footer, toolbarExtra, header, beforeQuickFilters, columnGroupingModel, getRowClassName, isRowVisible, hideFooterWhenAllRowsFit, showGoToPage, striped, getRowHeight, gridSx, maxGridHeight, ariaLabel, fixedColumn, selectionActions, isRowSelectable, allowSelectAllMatching, onSelectionChange, selectionPhoneLayout, onQueryChange, onLoaded, onLoadError, gridProps, texts, }: {
+    fetchPage: (params: {
+        filters: Record<string, any>;
+        sortOrders: Array<{
+            column: string;
+            direction: 'asc' | 'desc';
+        }>;
+        page: number;
+        pageSize: number;
+    }, signal: AbortSignal) => Promise<{
+        rows: any[];
+        total: number;
+        facets?: Record<string, Array<{
+            value: any;
+            total: number;
+        }> | number>;
+        capped?: boolean;
+    }>;
+    queryKey: string;
+    enabled?: boolean;
+    columns: Array<object>;
+    filterKinds?: Record<string, string>;
+    filterDefaults?: Record<string, unknown>;
+    chipConfig?: Array<object>;
+    quickFilters?: Array<object>;
+    searchField?: string | null;
+    searchPlaceholder?: string;
+    searchInBar?: boolean;
+    collapseSearchInBar?: boolean;
+    emptyLabel?: string;
+    countLabel?: (total: number) => string;
+    pageSizeOptions?: number[];
+    defaultPageSize?: number;
+    getRowId?: (row: any) => string | number;
+    prefix?: string;
+    refreshToken?: unknown;
+    footer?: (summary: {
+        total: number;
+        capped: boolean;
+    }) => import('react').ReactNode;
+    toolbarExtra?: import('react').ReactNode;
+    header?: (summary: {
+        countText: string;
+        total: number;
+        capped: boolean;
+    }) => import('react').ReactNode;
+    beforeQuickFilters?: import('react').ReactNode;
+    columnGroupingModel?: Array<object>;
+    getRowClassName?: (params: any) => string;
+    isRowVisible?: (row: any) => boolean;
+    striped?: boolean;
+    getRowHeight?: (params: any) => number | 'auto' | null;
+    hideFooterWhenAllRowsFit?: boolean;
+    showGoToPage?: boolean;
+    gridSx?: object;
+    maxGridHeight?: number;
+    ariaLabel?: string;
+    fixedColumn?: string;
+    selectionActions?: Array<{
+        key: string;
+        label: string;
+        icon?: import('react').ReactNode;
+        color?: 'inherit' | 'primary' | 'secondary' | 'error' | 'info' | 'success' | 'warning';
+        isDisabled?: (selection: RowSelection) => boolean;
+        onClick: (selection: RowSelection, helpers: {
+            clearSelection: () => void;
+            refresh: () => void;
+        }) => unknown;
+    }>;
+    isRowSelectable?: (row: any) => boolean;
+    allowSelectAllMatching?: boolean;
+    onSelectionChange?: (selection: RowSelection) => void;
+    selectionPhoneLayout?: 'top' | 'split';
+    onQueryChange?: (request: {
+        filters: Record<string, any>;
+        sortOrders: Array<{
+            column: string;
+            direction: 'asc' | 'desc';
+        }>;
+        page: number;
+        pageSize: number;
+    }) => void;
+    onLoaded?: (result: {
+        rows: any[];
+        total: number;
+        facets: object;
+        capped: boolean;
+    }) => void;
+    onLoadError?: (error: unknown) => void;
+    gridProps?: object;
+    texts?: object;
+}): import("react").JSX.Element;

package/dist/types/DataTable/buildChipConfig.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @param {object} declaration
+ * @param {Array<{key: string, label: string, format?: (value: string) => string}>} [declaration.text]
+ * @param {Array<{key: string, label: string, itemLabel?: (value: string) => string}>} [declaration.multiSelect]
+ * @returns {Array<{key: string, isActive: (value: unknown) => boolean, chipsFor: Function}>}
+ */
+export declare function buildChipConfig({ text, multiSelect }?: {
+    text?: Array<{
+        key: string;
+        label: string;
+        format?: (value: string) => string;
+    }>;
+    multiSelect?: Array<{
+        key: string;
+        label: string;
+        itemLabel?: (value: string) => string;
+    }>;
+}): Array<{
+    key: string;
+    isActive: (value: unknown) => boolean;
+    chipsFor: Function;
+}>;

package/dist/types/DataTable/columns.d.ts

@@ -0,0 +1,93 @@
+export type GridColumnProps = {
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    flex?: number;
+    align?: 'left' | 'center' | 'right';
+    headerAlign?: 'left' | 'center' | 'right';
+    valueFormatter?: (value: any, row: any) => string;
+    valueGetter?: (value: any, row: any) => any;
+    renderCell?: (params: any) => import('react').ReactNode;
+} & Record<string, any>;
+/**
+ * Las props de columna del DataGrid que más se usan, con su tipo, y cualquier otra suya (Record). OJO: tipo propio y no
+ * GridColDef del DataGrid: apuntar a sus tipos hace que un proyecto estricto (skipLibCheck: false) revise los internos del
+ * DataGrid, que no compilan con TypeScript 7.
+ *
+ * @typedef {{width?: number, minWidth?: number, maxWidth?: number, flex?: number, align?: 'left'|'center'|'right', headerAlign?: 'left'|'center'|'right', valueFormatter?: (value: any, row: any) => string, valueGetter?: (value: any, row: any) => any, renderCell?: (params: any) => import('react').ReactNode} & Record<string, any>} GridColumnProps
+ */
+/**
+ * Columna de texto con orden y filtro "contiene" en el servidor.
+ *
+ * @param {{field: string, label: string, sort?: boolean, filter?: boolean} & GridColumnProps} columnDeclaration
+ *     label ya traducido; lo demás son props de columna del DataGrid (width, flex, valueFormatter, renderCell…)
+ */
+export declare function textColumn({ field, label, sort, filter, ...gridColumnProps }: {
+    field: string;
+    label: string;
+    sort?: boolean;
+    filter?: boolean;
+} & GridColumnProps): {
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    flex?: number;
+    align?: 'left' | 'center' | 'right';
+    headerAlign?: 'left' | 'center' | 'right';
+    valueFormatter?: (value: any, row: any) => string;
+    valueGetter?: (value: any, row: any) => any;
+    renderCell?: (params: any) => import('react').ReactNode;
+    field: string;
+    headerName: string;
+    sortable: boolean;
+    filterable: boolean;
+    renderHeader: () => import("react").JSX.Element;
+};
+/**
+ * Columna con filtro de opciones alimentado por las FACETAS del servidor.
+ *
+ * @param {{field: string, label: string, facetKey?: string, renderOption?: (value: string) => import('react').ReactNode, sort?: boolean} & GridColumnProps} columnDeclaration
+ */
+export declare function facetColumn({ field, label, facetKey, renderOption, sort, ...gridColumnProps }: {
+    field: string;
+    label: string;
+    facetKey?: string;
+    renderOption?: (value: string) => import('react').ReactNode;
+    sort?: boolean;
+} & GridColumnProps): {
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    flex?: number;
+    align?: 'left' | 'center' | 'right';
+    headerAlign?: 'left' | 'center' | 'right';
+    valueFormatter?: (value: any, row: any) => string;
+    valueGetter?: (value: any, row: any) => any;
+    renderCell?: (params: any) => import('react').ReactNode;
+    field: string;
+    headerName: string;
+    sortable: boolean;
+    filterable: boolean;
+    renderHeader: () => import("react").JSX.Element;
+};
+/**
+ * Columna de acción al final de la fila: un icono que abre el detalle (la ruta propia del renglón). Un icono y no la
+ * fila entera a propósito: la fila como botón se dispara al seleccionar texto y no se ve que se puede abrir.
+ *
+ * @param {{onOpen: (row: any) => void, ariaLabelOf?: (row: any) => string}} declaration ariaLabelOf ya traducido
+ */
+export declare function detailColumn({ onOpen, ariaLabelOf }: {
+    onOpen: (row: any) => void;
+    ariaLabelOf?: (row: any) => string;
+}): {
+    field: string;
+    headerName: string;
+    sortable: boolean;
+    filterable: boolean;
+    disableColumnMenu: boolean;
+    width: number;
+    align: string;
+    renderCell: ({ row }: {
+        row: any;
+    }) => import("react").JSX.Element;
+};

package/dist/types/DataTable/filterContext.d.ts

@@ -0,0 +1,13 @@
+export declare const TableFilterContext: import("react").Context<null>;
+/**
+ * @returns {{filters: object, setFilter: Function, clearFilter: Function, sortOrders: Array, toggleSort: Function, clearSort: Function, facets: object}}
+ */
+export declare function useTableFilter(): {
+    filters: object;
+    setFilter: Function;
+    clearFilter: Function;
+    sortOrders: any[];
+    toggleSort: Function;
+    clearSort: Function;
+    facets: object;
+};

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

@@ -0,0 +1,13 @@
+export { default as AuditTrailDialog } from './AuditTrailDialog.js';
+export { default as AuditTrailTable } from './AuditTrailTable.js';
+export { default as EmptyState } from './EmptyState.js';
+export { default as FilterChips } from './FilterChips.js';
+export { default as GoToPage } from './GoToPage.js';
+export { SELECTION_PHONE_LAYOUT, default as ServerTable } from './ServerTable.js';
+export { buildChipConfig } from './buildChipConfig.js';
+export { detailColumn, facetColumn, textColumn } from './columns.js';
+export { TableFilterContext, useTableFilter } from './filterContext.js';
+export { toServerTableParams } from './serverTableParams.js';
+export { buildTableActors, tableMachine } from './tableMachine.js';
+export { useDebouncedFilter } from './useDebouncedFilter.js';
+export { FILTER_KINDS, isFilterActive, useTableState } from './useTableState.js';

package/dist/types/DataTable/rowSelection.d.ts

@@ -0,0 +1,113 @@
+export type RowSelection = {
+    /**
+     * los ids elegidos; vacío con isAllMatching
+     */
+    ids: Array<string | number>;
+    /**
+     * los renglones elegidos tal como se vieron; vacío con isAllMatching
+     */
+    rows: any[];
+    /**
+     * cuántos van: los elegidos o, con isAllMatching, el total de la tabla
+     */
+    count: number;
+    /**
+     * true = todos los que coinciden con `filters` (mande los filtros, no los ids)
+     */
+    isAllMatching: boolean;
+    /**
+     * con isAllMatching, el total es «al menos esto» (el servidor cuenta hasta un tope)
+     */
+    isCapped: boolean;
+    /**
+     * los filtros puestos en la tabla
+     */
+    filters: Record<string, any>;
+};
+/**
+ * Lo que recibe cada acción de los elegidos (y onSelectionChange).
+ *
+ * @typedef {object} RowSelection
+ * @property {Array<string|number>} ids los ids elegidos; vacío con isAllMatching
+ * @property {any[]} rows los renglones elegidos tal como se vieron; vacío con isAllMatching
+ * @property {number} count cuántos van: los elegidos o, con isAllMatching, el total de la tabla
+ * @property {boolean} isAllMatching true = todos los que coinciden con `filters` (mande los filtros, no los ids)
+ * @property {boolean} isCapped con isAllMatching, el total es «al menos esto» (el servidor cuenta hasta un tope)
+ * @property {Record<string, any>} filters los filtros puestos en la tabla
+ */
+/** Nada elegido. */
+export declare const EMPTY_ROW_SELECTION: Readonly<{
+    rowsById: Map<any, any>;
+    isAllMatching: false;
+}>;
+/**
+ * Lo que reciben las acciones, a partir del estado de la tabla.
+ *
+ * @param {{rowsById: Map<string|number, any>, isAllMatching: boolean}} selection
+ * @param {{total: number, capped?: boolean, filters: Record<string, any>}} table
+ * @returns {RowSelection}
+ */
+export declare function rowSelectionOf(selection: {
+    rowsById: Map<string | number, any>;
+    isAllMatching: boolean;
+}, { total, capped, filters }: {
+    total: number;
+    capped?: boolean;
+    filters: Record<string, any>;
+}): RowSelection;
+/**
+ * Los ids que el DataGrid debe pintar marcados en la página que se ve. Con «todos los que coinciden», todos los de la
+ * página que se pueden elegir.
+ *
+ * @param {{rowsById: Map<string|number, any>, isAllMatching: boolean}} selection
+ * @param {Array<string|number>} selectablePageIds los ids de la página que se pueden elegir
+ * @returns {Set<string|number>}
+ */
+export declare function checkedIdsOf(selection: {
+    rowsById: Map<string | number, any>;
+    isAllMatching: boolean;
+}, selectablePageIds: Array<string | number>): Set<string | number>;
+/**
+ * El DataGrid avisó qué ids quedaron marcados (por una casilla de renglón o la de la página).
+ *
+ * Con «todos los que coinciden», desmarcar uno sale de ese modo y se quedan elegidos los de esta página que siguen
+ * marcados (lo mismo que hace Gmail).
+ *
+ * Con allMatchingOnWholePage, la página completa elegida DE UN GOLPE (la casilla de arriba, o un rango con Shift que la
+ * cubre) elige todos los que coinciden. OJO: se decide por lo que cambió y no por el motivo que manda el DataGrid, que usa
+ * el mismo para la casilla de arriba y para un rango. Llenar la página picando uno por uno no: ahí el aviso lo ofrece. Si
+ * no hay más renglones que los de la página, se quedan los picados (la acción recibe ids, que es lo más claro).
+ *
+ * @param {{rowsById: Map<string|number, any>, isAllMatching: boolean}} selection
+ * @param {Set<string|number>} checkedIds lo que el DataGrid trae marcado (incluye los de otras páginas)
+ * @param {Map<string|number, any>} pageRowsById los renglones de la página que se ve, por id
+ * @param {Array<string|number>} selectablePageIds los ids de la página que se pueden elegir
+ * @param {{allMatchingOnWholePage?: boolean, total?: number, capped?: boolean}} [options]
+ * @returns {{rowsById: Map<string|number, any>, isAllMatching: boolean}}
+ */
+export declare function selectionAfterCheck(selection: {
+    rowsById: Map<string | number, any>;
+    isAllMatching: boolean;
+}, checkedIds: Set<string | number>, pageRowsById: Map<string | number, any>, selectablePageIds: Array<string | number>, { allMatchingOnWholePage, total, capped }?: {
+    allMatchingOnWholePage?: boolean;
+    total?: number;
+    capped?: boolean;
+}): {
+    rowsById: Map<string | number, any>;
+    isAllMatching: boolean;
+};
+/**
+ * ¿Se le ofrece «Elegir los N que coinciden»? Cuando ya eligió toda la página y hay más renglones que esos.
+ *
+ * @param {{rowsById: Map<string|number, any>, isAllMatching: boolean}} selection
+ * @param {Array<string|number>} selectablePageIds
+ * @param {{total: number, capped?: boolean}} table
+ * @returns {boolean}
+ */
+export declare function canSelectAllMatching(selection: {
+    rowsById: Map<string | number, any>;
+    isAllMatching: boolean;
+}, selectablePageIds: Array<string | number>, { total, capped }: {
+    total: number;
+    capped?: boolean;
+}): boolean;

package/dist/types/DataTable/serverTableParams.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @param {{filters?: object, sortOrders?: Array<{column: string, direction: 'asc'|'desc'}>, page: number, pageSize: number}} tableRequest
+ * @param {{parameterNames?: Record<string, string>}} [options] campo de la tabla → nombre del parámetro en el API
+ * @returns {Record<string, unknown>} params para getInfo
+ */
+export declare function toServerTableParams({ filters, sortOrders, page, pageSize }: {
+    filters?: object;
+    sortOrders?: Array<{
+        column: string;
+        direction: 'asc' | 'desc';
+    }>;
+    page: number;
+    pageSize: number;
+}, { parameterNames }?: {
+    parameterNames?: Record<string, string>;
+}): Record<string, unknown>;

package/dist/types/DataTable/tableMachine.d.ts

@@ -0,0 +1,41 @@
+/**
+ * ¿El error es una cancelación (axios o fetch)? Cancelar una consulta que ya no interesa no es un error que mostrar.
+ *
+ * @param {unknown} error
+ * @returns {boolean}
+ */
+export declare function isCancellation(error: unknown): boolean;
+export declare const tableMachine: import("xstate").StateMachine<import("xstate").MachineContext, import("xstate").AnyEventObject, {
+    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<never, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
+}, {
+    src: "fetchPage";
+    logic: import("xstate").PromiseActorLogic<never, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+    id: string | undefined;
+}, never, {
+    type: "isCancellation";
+    params: unknown;
+} | {
+    type: "isStaleResponse";
+    params: unknown;
+}, never, {}, string, import("xstate").NonReducibleUnknown, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+    states?: {} | undefined;
+    id?: string | undefined;
+}, import("xstate").MetaObject>;
+/**
+ * El actor fetchPage a partir de la función de la pantalla.
+ *
+ * @param {(params: {filters: object, sortOrders: Array, page: number, pageSize: number}, signal: AbortSignal) => Promise<{rows: Array, total: number, facets?: object, capped?: boolean}>} fetchPage
+ */
+export declare function buildTableActors(fetchPage: (params: {
+    filters: object;
+    sortOrders: any[];
+    page: number;
+    pageSize: number;
+}, signal: AbortSignal) => Promise<{
+    rows: any[];
+    total: number;
+    facets?: object;
+    capped?: boolean;
+}>): {
+    fetchPage: import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+};

package/dist/types/DataTable/useDebouncedFilter.d.ts

@@ -0,0 +1,8 @@
+export declare const DEFAULT_DEBOUNCE_MILLISECONDS = 350;
+/**
+ * @param {string|undefined} value valor confirmado (el de la URL)
+ * @param {(value: string) => void} commit se llama con el valor ya rebotado
+ * @param {number} [delayMilliseconds]
+ * @returns {[string, (value: string) => void]} borrador que pinta la caja y su setter
+ */
+export declare function useDebouncedFilter(value: string | undefined, commit: (value: string) => void, delayMilliseconds?: number): [string, (value: string) => void];