@apia/table 0.1.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+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

@@ -0,0 +1,28 @@
+# Initiator
+
+Este package se creó con la única utilidad de copiarlo entero y pegarlo a la hora de crear un nuevo package.
+
+Este iniciador permite crear un paquete que compila typescript y puede ser importado desde otros packages.
+
+## IMPORTANTE
+
+Los archivos **tsconfig.json** y **tsup.config.ts** no son archivos únicos sino symlinks a archivos de configuración comunes a todos los packages. En caso de que sea necesario modificar alguno de ellos **que en la gran mayoría de los casos no sería necesario**, es necesario eliminar el archivo a modificar y crear uno nuevo.
+
+## Procedimiento
+
+ - Copiar la carpeta initiator y pegarla con otro nombre dentro de packages.
+ - Modificar el package.json:
+   - Eliminar la línea ```private: true```.
+   - Cambiar la ocurrencia `initiator` por el nombre del nuevo paquete. 
+   - Agregar los scripts convenientes: dev, build, etc.
+ - Ejecutar el comando lerna bootstrap desde la carpeta raíz.
+
+Luego de ejecutar estos pasos, el package estaría listo para comenzar a usarse.
+
+Este package trae como dependencias por defecto theme-ui y react. Si se desea agregar más dependencias se debe ejecutar el comando ```lerna add --scope="@apia/packageName" dependencyName```. Ejemplo, si creamos un paquete con el nombre @apia/myPackage y queremos agregar lodash como dependencia, ejecutamos el comando ```lerna add --scope="@apia/myPackage" lodash```. 
+
+**Importante 1**: Dado que estamos desarrollando packages, es importante determinar si las dependencias que vamos a agregar son de tipo dependency o de tipo peerDependency.
+
+**Importante 2**: lerna no permite instalar de a varias dependencias a la vez como lo hace npm, por lo tanto, si se desea agregar varias dependencias se debe ejecutar el comando anterior tantas veces como dependencias se quiera agregar.
+
+**Importante 3**: React y theme-ui vienen instalados como peerDependencies. En caso de no ser necesarios pueden ser removidos, pero en cualquier caso asegurarse de que estas dependencias no sean instaladas como dependencies puesto que esto causaría comportamientos indeseados en la aplicación.

package/cleanDist.json

@@ -0,0 +1,3 @@
+{
+  "cleanDist": 0.1481583416616694
+}

package/dist/index.d.ts

@@ -0,0 +1,615 @@
+import React, { FunctionComponent } from 'react';
+import { BoxProps } from 'theme-ui';
+import * as theme_ui_jsx_runtime from 'theme-ui/jsx-runtime';
+import { IconType } from '@meronex/icons';
+import * as _apia_util from '@apia/util';
+import { TApiaFilter, TModify } from '@apia/util';
+import * as _reduxjs_toolkit from '@reduxjs/toolkit';
+import { PayloadAction } from '@reduxjs/toolkit';
+import * as immer_dist_internal from 'immer/dist/internal';
+import * as react_redux from 'react-redux';
+import * as redux from 'redux';
+
+type TAccordionCellRendererProps<CellProps = Record<string, unknown>> = {
+    cell: TResponsiveTableCell<CellProps>;
+    column: TResponsiveTableColumn;
+    columnIndex: number;
+    row: TResponsiveTableRow;
+    rowIndex: number;
+};
+type TAccordionCellRenderer<CellProps = Record<string, unknown>> = FunctionComponent<TAccordionCellRendererProps<CellProps>>;
+declare const AccordionCell: TAccordionCellRenderer<Record<string, unknown>>;
+
+type TColoredElement = {
+    background?: string;
+    color?: string;
+};
+/**
+ * Se encontró en algunos casos particulares que
+ * el servidor devuelve Up y Down para referirse
+ * al orden actual de una columna.
+ */
+type TResponsiveTableSortValue = null | 'A' | 'D' | 'Down' | 'Up';
+/**
+ * Cada vez que se hace click en el botón del
+ * cabezal de una columna, si la columna tiene
+ * habilitado el ordenamiento, se emite un
+ * evento de este tipo, informando cuál columna
+ * emitió el evento, y cuál es el nuevo sortValue.
+ */
+type TResponsiveTableSortChangeEvent = {
+    name: string;
+    column: TResponsiveTableColumn;
+    columnIndex: number;
+    /**
+     * Es el orden que la columna debería tener
+     * si no hay ningún motivo para evitar que
+     * la acción de ordenamiento se lleve a cabo.
+     *
+     * Es importante notar que el componente
+     * responsiveTable no realiza ninguna acción
+     * de ordenamiento por defecto, sino que es
+     * quien la usa, quien debe realizar las
+     * acciones correspondientes e informarlo a
+     * la tabla actualizando los registros y el
+     * estado de la columna correspondiente.
+     */
+    sortValue: TResponsiveTableSortValue;
+};
+/**
+ * Cada celda admite un renderer, que recibe
+ * propiedades personalizadas. Este tipo define
+ * cuál es la forma de esas propiedades.
+ */
+type TResponsiveTableCellRendererProps<RendererPropsType extends Partial<Record<keyof RendererPropsType, unknown>> = Record<string, unknown>, HTML = HTMLTableCellElement> = {
+    cell: TResponsiveTableCell<RendererPropsType>;
+    column: TResponsiveTableColumn;
+    row: TResponsiveTableRow;
+} & React.AllHTMLAttributes<HTML>;
+type TResponsiveTableCellRenderer<RendererPropsType extends Partial<Record<keyof RendererPropsType, unknown>> = Record<string, unknown>> = React.FunctionComponent<TResponsiveTableCellRendererProps<RendererPropsType>>;
+/**
+ * Algunos elementos de la tabla admiten un
+ * Renderer personalizado. Dichos elementos
+ * extienden este tipo.
+ */
+type TResponsiveTableWithRendererElement<RendererPropsType extends Partial<Record<keyof RendererPropsType, unknown>> = Record<string, unknown>> = {
+    /**
+     * Si se desea, el elemento admite un componente
+     * personalizado para encargarse del renderizado
+     * del mismo en el modo responsivo. De esta forma, se puede proveer
+     * de comportamiento específico a cualquier
+     * elemento de la tabla.
+     */
+    AccordionRenderer?: TAccordionCellRenderer<any>;
+    /**
+     * Son las propiedades que se desean pasar al
+     * componente de renderizado personalizado que
+     * se haya establecido.
+     *
+     * Estas props serán obviadas en caso de que
+     * no haya componente de renderizado personalizado.
+     */
+    rendererProps?: RendererPropsType;
+    /**
+     * Si se desea, el elemento admite un componente
+     * personalizado para encargarse del renderizado
+     * del mismo. De esta forma, se puede proveer
+     * de comportamiento específico a cualquier
+     * elemento de la tabla.
+     */
+    Renderer?: TResponsiveTableCellRenderer<any>;
+};
+type TResponsiveTableCell<RendererPropsType extends Partial<Record<keyof RendererPropsType, unknown>> = Record<string, unknown>> = {
+    children?: number | string;
+} & TResponsiveTableWithRendererElement<RendererPropsType> & Partial<Pick<HTMLTableCellElement, 'ariaLabel' | 'className' | 'colSpan' | 'id' | 'rowSpan' | 'title'>> & TColoredElement;
+/**
+ * Cada celda admite un renderer, que recibe
+ * propiedades personalizadas. Este tipo define
+ * cuál es la forma de esas propiedades.
+ */
+type TResponsiveTableRowRendererProps<RendererPropsType extends Partial<Record<keyof RendererPropsType, unknown>> = Record<string, unknown>> = {
+    row: TResponsiveTableRow<RendererPropsType>;
+    rowIndex: number;
+} & React.AllHTMLAttributes<HTMLTableRowElement>;
+type TResponsiveTableRowRenderer<RendererPropsType extends Partial<Record<keyof RendererPropsType, unknown>> = Record<string, unknown>> = React.FunctionComponent<TResponsiveTableRowRendererProps<RendererPropsType>>;
+type TResponsiveTableRow<RendererPropsType extends Partial<Record<keyof RendererPropsType, unknown>> = Record<string, unknown>> = TBasicRow & TColoredElement & {
+    cells: TResponsiveTableCell[];
+    /**
+     * Si se pasa en true, la fila se mostrará como un separador
+     */
+    separator?: boolean;
+    initiallySelected?: boolean;
+    renderer?: TResponsiveTableRowRenderer<RendererPropsType>;
+    rendererProps?: RendererPropsType;
+    /**
+     * Permite pasar propiedades arbitrarias a un row y recuperarlas en los
+     * eventos de onClick por ejemplo.
+     */
+    rowProps?: RendererPropsType;
+    isHidden?: boolean;
+    /**
+     * Los estados de la fila agregan un ícono en la columna
+     * especial que es la que se muestra a la izquierda y
+     * contiene, cuando existe, el botón de más información.
+     */
+    states?: TResponsiveTableRowState[];
+} & Partial<Pick<HTMLTableCellElement, 'ariaLabel' | 'colSpan' | 'className' | 'rowSpan' | 'title'>>;
+type TResponsiveTableRowState = {
+    /**
+     * Es un className que se agregará al elemento <tr>
+     */
+    className?: string;
+    Icon: IconType;
+    color?: string;
+    tooltip: string;
+};
+type TResponsiveTableColumn = TResponsiveTableWithRendererElement & {
+    /** Con esta propiedad se puede pasar parámetros opcionales */
+    additionalData?: Record<string, unknown>;
+    /**
+     * Determina si la columna admite ordenamiento.
+     */
+    allowSorting?: boolean;
+    children?: React.ReactNode;
+    /**
+     * Cuando la columna admite ordenamiento, muestra
+     * una flecha indicando el orden actual. Esta
+     * propiedad establece si la flecha apunta hacia
+     * arriba, abajo, o si la flecha es un guión.
+     */
+    currentSorting?: TResponsiveTableSortValue;
+    /** *
+     * Valor para decirle al server cuál columna se está ordenando
+     */
+    dataSortBy?: string;
+    hidden?: boolean;
+    /**
+     * Normalmente, todas las columnas se van a mostrar
+     * como renglones en el acordión, cuando este es
+     * expandido.
+     *
+     * Si este flag es pasado en true, la columna
+     * correspondiente no se va a mostrar en modo
+     * responsivo.
+     */
+    hideFromAccordion?: boolean;
+    /**
+     * Elemento id del dom.
+     */
+    id?: string;
+    /**
+     * Es el texto que se mostrará en el cabezal.
+     */
+    label: string;
+    maxWidth?: number | string;
+    minWidth?: number | string;
+    /**
+     * El nombre de la columna debe ser único, se utiliza
+     * para realizar la asosiación entre las columnas
+     * y los filtros, así como con los eventos de orden.
+     */
+    name: string;
+    /**
+     * Si se pasa required: true, se pone un asterisco
+     * rojo en el cabezal de la columna para señalar que
+     * la columna es requerida.
+     */
+    required?: boolean;
+    /**
+     * Algunas columnas podrán mostrarse mediante un botón
+     * "mostrar más", para ello deberán ser marcadas con
+     * esta prop en true.
+     */
+    showAsAdditional?: boolean;
+    /**
+     * Cuando no se pasa esta propiedad en ninguna columna,
+     * la aplicación encuentra la primera fila sin celdas
+     * vacías y la utiliza como título.
+     *
+     * En cambio, si al menos una columna tiene este flag
+     * en true, el título de cada fila del acordión estará
+     * compuesto por los valores de estas columnas.
+     */
+    showInAccordionTitle?: boolean;
+    /**
+     * Elemento title de html (El tooltip).
+     */
+    title?: string;
+    width?: number | string;
+} & Partial<Pick<HTMLTableCellElement, 'ariaLabel' | 'className' | 'colSpan' | 'rowSpan'>>;
+type TResponsiveTableStoreProps = {
+    /**
+     * Habla sobre el orden de las filas en función de
+     * las columnas. Esta propiedad habilita/deshabilita
+     * el ordenado de las columnas al hacer click en los
+     * cabezales.
+     *
+     * La tabla admite ordenamiento por defecto, a menos
+     * que esta prop venga en false. En caso de que se
+     * pase false no importa qué digan las columnas,
+     * el ordenamiento no estará habilitado.
+     */
+    allowSorting?: boolean;
+    columns: TResponsiveTableColumn[];
+    filters?: TApiaFilter[];
+    rows: TResponsiveTableRow<any>[];
+    /**
+     * Por defecto, la tabla permitirá seleccionar
+     * múltiples valores, a menos que esta prop venga
+     * en false.
+     */
+    isMultiple?: boolean;
+    label?: string;
+    /**
+     * Es normal que una tabla tenga paginación y que en cada página haya una
+     * cantidad distinta de estados. Si se quiere mantener consistencia en el
+     * tamaño de las páginas, es posible reservar un tamaño para una cantidad
+     * definida de estados con este parámetro.
+     */
+    reserveColumnsForStates?: number;
+};
+type TResponsiveTableRowsSelectionEvent = {
+    index: number;
+    row: TResponsiveTableRow;
+}[];
+type TResponsiveTableContextProps = TResponsiveTableStoreProps & Pick<ISelectableState, 'allowRowsKeyboardSorting' | 'allowEdition' | 'allowSelection'> & {
+    /**
+     * Cuando se actualiza el array de rows de la tabla
+     * desde las props del ResponsiveTableContext, se
+     * reinicia el estado de selección de acuerdo a cómo
+     * viene definido en el prop. **Si esta prop se pasa
+     * en true**, este comportamiento es deshabilitado.
+     */
+    avoidReparseSelectionOnRowChange?: boolean;
+    children?: React.ReactNode;
+    className?: string;
+    /**
+     * Permite redefinir el comportamiento de los breakpoints pasando un índice
+     * personalizado. Cuando es pasado, deja de prestar atención al breakpoint
+     * de la pantalla y comienza a prestar atención a este índice.
+     */
+    currentBreakPoint?: number;
+    customLabels?: typeof defaultLabels;
+    /**
+     * Se puede utilizar este booleano para que la tabla
+     * deshabilite las opciones de filtrado y ordenado mientras
+     * se está ejecutando una acción ajax.
+     */
+    isLoading?: boolean;
+    /**
+     * La tabla debe tener un nombre único que será usado para
+     * acceder a las propiedades de la misma en el store. En caso
+     * de que no se pase ninguno, la tabla lo generará
+     * automaticamente.
+     */
+    name?: string;
+    onFilterChange?: (ev: TApiaFilter) => void | Promise<boolean>;
+    onFilterBlur?: (ev: TApiaFilter) => unknown;
+    onFilterPressEnter?: (ev: TApiaFilter) => unknown;
+    onChangeSelection?: (ev: TResponsiveTableRowsSelectionEvent) => unknown;
+    /**
+     * Este evento será llamado cada vez que el usuario esté
+     * haciendo foco en la tabla, tenga una selección de
+     * filas no vacía y presione la tecla Enter.
+     */
+    onSelectRows?: (ev: TResponsiveTableRowsSelectionEvent, focusedRowIndex: number) => unknown;
+    /**
+     * Es llamado cada vez que el usuario hace click en el botón
+     * del cabezal de la columna. **Importante:** la tabla no
+     * realizará ninguna acción de ordenamiento, sino solamente
+     * avisar de que el usuario desea que las filas sean ordenadas
+     * por alguna columna en particular.
+     */
+    onSortChange?: (ev: TResponsiveTableSortChangeEvent) => unknown;
+    variant?: string;
+};
+/**
+ * Los callbacks del responsiveTable estarán
+ * disponibles a través de un contexto, de
+ * forma que cualquier elemento activo que
+ * desee informar de un evento en particular
+ * pueda hacerlo en forma sencilla.
+ */
+type TResponsiveTableContext = TModify<Pick<TResponsiveTableContextProps, 'currentBreakPoint' | 'name' | 'onChangeSelection' | 'onFilterBlur' | 'onFilterChange' | 'onFilterPressEnter' | 'onSelectRows' | 'onSortChange' | 'label'>, {
+    labels: typeof defaultLabels;
+    name: string;
+}>;
+declare const defaultLabels: {
+    noRegisters: string;
+};
+
+type TResponsiveTableIndexColumns = {
+    index: number;
+    column: TResponsiveTableColumn;
+}[];
+type TResponsiveTableState = Omit<TResponsiveTableStoreProps, 'columns' | 'rows' | 'filters'> & ISelectableState<TResponsiveTableStoreProps['columns'][0], NonNullable<TResponsiveTableStoreProps['filters']>[0], TResponsiveTableStoreProps['rows'][0]> & {
+    accordionIndexColumns: TResponsiveTableIndexColumns;
+    isLoading: boolean;
+};
+type TResponsiveTableSlice = Record<string, TResponsiveTableState>;
+type TResponsiveTableAction<P = Record<string, unknown>, T extends string = string, M = never, E = never> = PayloadAction<P & {
+    tableName: string;
+}, T, M, E>;
+
+/**
+ * Representa la intención de establecer foco en
+ * un elemento de la grilla y alterar el estado
+ * de la misma.
+ */
+interface INewFocus {
+    altKey?: boolean;
+    ctrlKey?: boolean;
+    isFocused?: boolean;
+    newFocusedRow?: number;
+    newFocusedColumn?: number;
+    shouldSelectNewFocused?: boolean;
+    shiftKey?: boolean;
+}
+/**
+ * Contiene las partes importantes para el handler
+ * de un evento de teclado.
+ */
+type THandleKey = {
+    ev: React.KeyboardEvent;
+};
+/**
+ * Son los elementos mínimos que toda columna debe
+ * tener para ser parte de esta grilla.
+ */
+interface IBasicColumn {
+    currentSorting?: TResponsiveTableSortValue;
+    name: string;
+}
+/**
+ * Son los elementos mínimos que todo filtro debe
+ * tener para ser parte de esta grilla.
+ */
+interface IBasicFilter {
+    /**
+     * LEGACY: El nombre de la columna a la que
+     * pertenece este filtro. Puede no tener columna
+     * y entonces será tratado como filtro adicional.
+     *
+     * Me gustaría nombrarlo columnName pero se
+     * estableció así desde el principio del desarrollo
+     * y está impregnado en todo el desarrollo, haciendo
+     * imposible cambiar su nombre con sencillez.
+     */
+    column?: string;
+    showAsAdditional?: boolean;
+}
+type TBasicRow = {
+    /**
+     * Si esta propiedad es pasada en true, esta fila
+     * no podrá ser seleccionada.
+     */
+    forbidSelection?: boolean;
+    /**
+     * El id es obligatorio para los rows, ya que de
+     * esta forma se logra mejorar el performance.
+     */
+    id: string;
+    /**
+     * Si esta propiedad es pasada como true, esta fila
+     * será bloqueada.
+     */
+    isLocked?: boolean;
+};
+/**
+ * Esta interfaz representa el estado de selección
+ * en una grilla. Los tipos ColumnType y RowType
+ * son opcionales y solamente se ofrecen como una
+ * utilidad para la implementación.
+ */
+interface ISelectableState<ColumnType extends IBasicColumn = IBasicColumn, FilterType extends IBasicFilter = IBasicFilter, RowType extends TBasicRow | string = TBasicRow | string> {
+    /**
+     * IMPORTANTE: Por defecto la grilla no permitirá edición,
+     * para permitirlo, se debe especificar allowEdition: true.
+     */
+    allowEdition?: boolean;
+    /**
+     * Si esta propiedad se pasa en true, es posible
+     * reordenar las filas de la tabla. Para ello es
+     * necesario estar en foco en la tabla y presionar
+     * ctrl+m para mover una fila de lugar. Se presiona
+     * Enter o Escape para salir del modo orden.
+     */
+    allowRowsKeyboardSorting?: boolean;
+    /**
+     * Por defecto, la grilla permitirá la selección de filas,
+     * para evitar este comportamiento se debe pasar
+     * allowSelection: false.
+     */
+    allowSelection?: boolean;
+    /**
+     * Es importante conocer las columnas para no hacer foco
+     * en una columna que no exista.
+     */
+    columns: ColumnType[];
+    draggingRow?: number;
+    /**
+     * Es importante conocer cuáles filas están expandidas de
+     * modo que al filtrar las filas no seleccionables, las
+     * expandidas no se van a tomar en cuenta.
+     */
+    expandedRows: number[];
+    /**
+     * La grilla debe conocer los filtros que se aplican a ella
+     * para saber si existe fila de filtros o no.
+     */
+    filters: FilterType[];
+    focusedRow: number;
+    focusedColumn: number;
+    hasNonAdditionalFilters: boolean;
+    /**
+     * Hay grillas que admiten edición, con este booleano
+     * es posible evitar que el keyHandler altere el
+     * estado de la selección cuando la grilla está en ese
+     * modo.
+     */
+    isEditionMode?: boolean;
+    /**
+     * Para efectuar las acciones de foco, es necesario saber
+     * si la grilla tiene el foco activo, de modo de evitar
+     * que el foco se dispare cuando se está trabajando con
+     * otros controles.
+     */
+    isFocused: boolean;
+    /**
+     * Indica si se pueden seleccionar muchas filas o una
+     * sola.
+     */
+    isMultiple?: boolean;
+    /**
+     * Es importante conocer las filas para no hacer foco
+     * en una fila que no exista.
+     */
+    nonAdditionalColumnsCount: number;
+    rows: RowType[];
+    /**
+     * Representa cuáles filas fueron seleccionadas por el
+     * usuario. El array resultante es el conjunto de índices
+     * de filas seleccionadas. Este array es actualizado
+     * automáticamente por el keyHandler.
+     */
+    selectedRows: number[];
+    statesColumns: number;
+}
+
+declare const ResponsiveTable: React.MemoExoticComponent<React.ForwardRefExoticComponent<BoxProps & React.RefAttributes<HTMLDivElement>>>;
+
+declare const ResponsiveTableContext: React.MemoExoticComponent<({ allowEdition, allowRowsKeyboardSorting, allowSelection, allowSorting, avoidReparseSelectionOnRowChange, children, className, currentBreakPoint, customLabels, columns, filters, rows, label, isMultiple, name, onChangeSelection, onFilterBlur, onFilterChange, onFilterPressEnter, onSelectRows, onSortChange, reserveColumnsForStates, variant, }: TResponsiveTableContextProps) => theme_ui_jsx_runtime.JSX.Element>;
+
+declare const responsiveTableStore: redux.Store<redux.CombinedState<{
+    responsiveTableSlice: TResponsiveTableSlice;
+}>, redux.AnyAction>;
+declare const useResponsiveTable: <TSelected>(selector: (state: {
+    responsiveTableSlice: TResponsiveTableSlice;
+}) => TSelected, equalityFn?: react_redux.EqualityFn<TSelected> | undefined) => TSelected;
+declare const responsiveTableActions: _reduxjs_toolkit.CaseReducerActions<{
+    handleKey(state: immer_dist_internal.WritableDraft<Record<string, ISelectableState<IBasicColumn, IBasicFilter, string | TBasicRow>>>, { payload }: {
+        payload: THandleKey & {
+            id: string;
+        };
+        type: string;
+    }): void;
+    selectionStateUpdate(state: immer_dist_internal.WritableDraft<Record<string, ISelectableState<IBasicColumn, IBasicFilter, string | TBasicRow>>>, { payload: { id, ...payload } }: {
+        payload: Partial<ISelectableState<IBasicColumn, IBasicFilter, string | TBasicRow>> & {
+            id: string;
+        };
+        type: string;
+    }): void;
+    setNewFocused(state: immer_dist_internal.WritableDraft<Record<string, ISelectableState<IBasicColumn, IBasicFilter, string | TBasicRow>>>, { payload: { id, ...payload } }: {
+        payload: INewFocus & {
+            id: string;
+        };
+        type: string;
+    }): void;
+    updateByClick(state: immer_dist_internal.WritableDraft<Record<string, ISelectableState<IBasicColumn, IBasicFilter, string | TBasicRow>>>, { payload: { id, colIndex, rowIndex, ariaColIndex, ariaRowIndex, isFocused, ...payload }, }: {
+        payload: (_apia_util.TRequireOnlyOne<{
+            ariaRowIndex: number;
+            rowIndex: number;
+        }, "ariaRowIndex" | "rowIndex"> & _apia_util.TRequireOnlyOne<{
+            ariaColIndex?: number | undefined;
+            colIndex: number;
+        }, "ariaColIndex" | "colIndex"> & Pick<INewFocus, "isFocused" | "altKey" | "ctrlKey" | "shiftKey">) & {
+            id: string;
+        };
+        type: string;
+    }): void;
+    update(state: immer_dist_internal.WritableDraft<TResponsiveTableSlice>, { payload: { tableName, ...rest }, }: TResponsiveTableAction<Partial<TResponsiveTableState> & {
+        isFocused?: boolean;
+    }>): void;
+    addRows(state: immer_dist_internal.WritableDraft<TResponsiveTableSlice>, { payload }: TResponsiveTableAction<{
+        newRows: TResponsiveTableRow[];
+    }>): void;
+    deleteRows(state: immer_dist_internal.WritableDraft<TResponsiveTableSlice>, { payload }: TResponsiveTableAction<{
+        rowIndices: number[];
+    }>): void;
+    destroy(state: immer_dist_internal.WritableDraft<TResponsiveTableSlice>, { payload: { tableName } }: TResponsiveTableAction): void;
+    swapFocusedRow(state: immer_dist_internal.WritableDraft<TResponsiveTableSlice>, { payload: { newIndex, tableName }, }: {
+        payload: {
+            newIndex: number;
+        } & {
+            tableName: string;
+        };
+        type: string;
+    }): void;
+}, "responsiveTableSlice">;
+
+type TDocNameCellRendererProps$1 = {
+    docName: string;
+    docUrl: string;
+};
+declare const DocNameCellRenderer: TResponsiveTableCellRenderer<TDocNameCellRendererProps$1>;
+
+type TDocNameCellRendererProps = {
+    docName: string;
+    docUrl: string;
+};
+type TDocNameCellRenderer = TAccordionCellRendererProps<TDocNameCellRendererProps>;
+declare const AccordionDocNameCellRenderer: TAccordionCellRenderer<TDocNameCellRendererProps>;
+
+interface IAccordionElement {
+    row: TResponsiveTableRow;
+    rowIndex: number;
+}
+declare const AccordionElement: ({ row, rowIndex }: IAccordionElement) => theme_ui_jsx_runtime.JSX.Element | null;
+
+declare const AccordionHTMLCellRenderer: TAccordionCellRenderer<{
+    html: string;
+}>;
+
+declare const AccordionRenderer: React.MemoExoticComponent<() => theme_ui_jsx_runtime.JSX.Element>;
+
+declare const AdditionalColumnDefaultRenderer: React.MemoExoticComponent<({ column, cell, }: TResponsiveTableCellRendererProps) => theme_ui_jsx_runtime.JSX.Element>;
+
+declare const DefaultCellRenderer: React.ForwardRefExoticComponent<{
+    cell: TResponsiveTableCell<Record<string, unknown>>;
+    column: TResponsiveTableColumn;
+    row: TResponsiveTableRow<Record<string, unknown>>;
+} & React.AllHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+
+declare const DefaultRowRenderer: TResponsiveTableRowRenderer<Record<string, unknown>>;
+
+declare const HTMLCellRenderer: TResponsiveTableCellRenderer<{
+    html: string;
+}>;
+
+declare const IsLoadingRenderer: () => theme_ui_jsx_runtime.JSX.Element;
+
+declare function makeAccordionAsyncRenderer(additionalInfoGetter: (row: TResponsiveTableRow) => Promise<{
+    label?: string;
+    name: string;
+}[]>): TResponsiveTableCellRenderer<Record<string, unknown>>;
+
+declare function makeAsyncRenderer(additionalInfoGetter: (row: TResponsiveTableRow) => Promise<{
+    label?: string;
+    name: string;
+    newline?: boolean;
+}[]>): TResponsiveTableCellRenderer<Record<string, unknown>>;
+
+declare const NoRegistersRenderer: () => theme_ui_jsx_runtime.JSX.Element;
+
+declare const PriorityAccordionRenderer: TAccordionCellRenderer<Record<string, unknown>>;
+
+declare function getPriorityHandler(priority: string | undefined): string | undefined;
+declare const PriorityRenderer: TResponsiveTableCellRenderer<{
+    src: string;
+}>;
+
+declare const RowStatesRenderer: React.MemoExoticComponent<({ state, }: {
+    state: TResponsiveTableRowState;
+}) => theme_ui_jsx_runtime.JSX.Element>;
+
+declare const StatusAccordionRenderer: TAccordionCellRenderer<Record<string, unknown>>;
+
+declare function getStatusRendererClassName(cellValue: string, columnName: string): string;
+declare const StatusRenderer: TResponsiveTableCellRenderer<{
+    src: string;
+}>;
+
+declare const TableRenderer: React.MemoExoticComponent<() => theme_ui_jsx_runtime.JSX.Element>;
+
+export { AccordionCell, AccordionDocNameCellRenderer, AccordionElement, AccordionHTMLCellRenderer, AccordionRenderer, AdditionalColumnDefaultRenderer, DefaultCellRenderer, DefaultRowRenderer, DocNameCellRenderer, HTMLCellRenderer, IAccordionElement, IsLoadingRenderer, NoRegistersRenderer, PriorityAccordionRenderer, PriorityRenderer, ResponsiveTable, ResponsiveTableContext, RowStatesRenderer, StatusAccordionRenderer, StatusRenderer, TAccordionCellRenderer, TAccordionCellRendererProps, TColoredElement, TDocNameCellRenderer, TDocNameCellRendererProps, TResponsiveTableCell, TResponsiveTableCellRenderer, TResponsiveTableCellRendererProps, TResponsiveTableColumn, TResponsiveTableContext, TResponsiveTableContextProps, TResponsiveTableRow, TResponsiveTableRowRenderer, TResponsiveTableRowRendererProps, TResponsiveTableRowState, TResponsiveTableRowsSelectionEvent, TResponsiveTableSortChangeEvent, TResponsiveTableSortValue, TResponsiveTableStoreProps, TResponsiveTableWithRendererElement, TableRenderer, defaultLabels, getPriorityHandler, getStatusRendererClassName, makeAccordionAsyncRenderer, makeAsyncRenderer, responsiveTableActions, responsiveTableStore, useResponsiveTable };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":[],"sourcesContent":[],"names":[],"mappings":""}