@apia/table2-controller 4.0.20

package/dist/index.d.ts

@@ -0,0 +1,330 @@
+import * as react from 'react';
+import { HTMLAttributes, ReactNode, FC, ThHTMLAttributes, FocusEvent } from 'react';
+import { EventEmitter } from '@apia/util';
+
+type RowsGroupBaseState = ElementBaseState & {
+    rows: Row[];
+    domProperties?: HTMLAttributes<HTMLTableSectionElement>;
+    properties?: Record<string, unknown>;
+};
+declare class RowsGroup<U extends RowsGroupBaseState> extends Element<U & RowsGroupBaseState> {
+    table: TableController;
+    constructor(table: TableController, state: U);
+    get rows(): Row[];
+    addRow(row: Row): this;
+    addRows(rows: Row[]): this;
+    clear(): Row[];
+    getRowById(id: string | number): Row | undefined;
+    getRowByIndex(index: number): Row;
+    getRowIndex(row: Row): number;
+    insertAfter(anchor: Row, newElement: Row): void;
+    insertBefore(anchor: Row, newElement: Row): void;
+    removeRow(row: Row): void;
+    swapRows(a: Row, b: Row): void;
+    private runAddRowPlugin;
+}
+
+type RowProperties = {
+    id: string;
+    cells: Cell[];
+    isExpandible?: boolean;
+    isExpanded?: boolean;
+    isHidden?: boolean;
+    isSelectable?: boolean;
+    isSelected?: boolean;
+    domProperties?: HTMLAttributes<HTMLTableRowElement>;
+    properties?: Record<string, unknown>;
+};
+type TBuildRow = Omit<RowProperties, 'cells'> & {
+    cells: CellState[];
+};
+type RowState = Omit<RowProperties, 'isSelected'>;
+declare class Row extends Element<RowState> {
+    private properties?;
+    protected container: null | RowsGroup<RowsGroupBaseState>;
+    addCell(cell: Cell): this;
+    addCellAfter(anchor: Cell, newElement: Cell): void;
+    addCellBefore(anchor: Cell, newElement: Cell): void;
+    build(data: TBuildRow): void;
+    constructor(id: string, properties?: Omit<RowProperties, "id"> | undefined);
+    get cells(): Cell<CellState<any>>[];
+    get isSelected(): boolean;
+    getCellByColumnName(colName: string): Cell<CellState<any>> | undefined;
+    getCellByIndex(index: number): Cell<CellState<any>>;
+    getCellIndex(cell: Cell): number;
+    getContainer(): RowsGroup<RowsGroupBaseState> | null;
+    getFollowingRow(): Row;
+    get index(): number;
+    getPreviousRow(): Row;
+    insertAfter(row: Row): void;
+    insertBefore(row: Row): void;
+    remove(): void;
+    scrollIntoView(): void;
+    setContainer(container: null | RowsGroup<RowsGroupBaseState>): this;
+    setTable(table: null | TableController): this;
+    swap(withRow: Row): void;
+    toggleSelection(forceState?: boolean): void;
+}
+
+type TableBodyState = ElementBaseState & RowsGroupBaseState & {};
+type TBuildBody = {
+    rows: TBuildRow[];
+};
+declare class TableBody extends RowsGroup<TableBodyState> {
+    constructor(table: TableController);
+    build(data: TBuildBody): void;
+}
+
+type TableHeadState = ElementBaseState & RowsGroupBaseState & {};
+type TBuildHead = {
+    columns: CellState[];
+    filters: any[];
+};
+declare class TableHead extends RowsGroup<TableHeadState> {
+    constructor(table: TableController);
+    build(data: TBuildHead): void;
+}
+
+/**
+ * This class is the default way to customize the table behavior.
+ */
+interface TablePlugin {
+    getRenderers?: () => {
+        cell?: React.FC<{
+            cell: Cell;
+        }>;
+    };
+    onAddRow?: (controller: TableController, target: RowsGroup<any>, newRow: Row) => void;
+    onResize?: (controller: TableController, colName: string, newSize: number) => void;
+    /**
+     * This hook is called when the table is renderized.
+     * The elements returned by this hook will be added to the dom of the element.
+     */
+    useElementDomProps?: (controller: TableController, _element: TableController | Element<any>, _context: any) => HTMLAttributes<HTMLElement>;
+}
+declare const defaultPlugins: () => (WaiAriaPlugin | FocusControllerPlugin)[];
+
+type TableState = {
+    allowEdition: boolean;
+    allowResize: boolean;
+    allowSelection: boolean;
+    editionMode: boolean;
+    focusedCell: Cell | null;
+    hiddenColumns: Set<string>;
+    isSelectionMultiple: boolean;
+    plugins: TablePlugin[];
+    selection: Set<Row>;
+};
+type TBuildTable = TBuildHead & TBuildBody;
+declare class TableController extends EventEmitter<{
+    cellFocus: {
+        cell: Cell;
+        doFocus: boolean;
+    };
+    columnClick: Cell;
+    editionMode: boolean;
+    keyEnter: null;
+    rowDelete: Row;
+    scrollIntoRow: Row;
+    selectionChange: Row[];
+}> {
+    private state;
+    constructor(props?: Partial<Omit<TableState, 'selection'>>);
+    setHiddenColumns(cols: Set<string>): void;
+    body: TableBody;
+    head: TableHead;
+    /**
+     * Clears all data in the table, except for the events
+     * listeners and recreates the structure based on the passed data.
+     */
+    build(data: TBuildTable): void;
+    getRowById(id: string | number): Row | undefined;
+    /**
+     * EDITION MODE
+     */
+    get isEditionMode(): boolean;
+    toggleEditionMode(force?: boolean): void;
+    /**
+     * SELECTION
+     */
+    clearSelection(): void;
+    /**
+     * Returns the selected rows.
+     */
+    getSelectedRows(): Row[];
+    isSelected(row: Row): boolean;
+    /**
+     * Toggles the selection state of a given row.
+     *
+     * If the `isSelected` parameter is provided, it explicitly sets the selection
+     * state of the row to the given value (`true` for selected, `false` for deselected).
+     * If `isSelected` is not provided, the method will toggle the current selection state
+     * of the row (i.e., select it if it's currently not selected, or deselect it if it is).
+     *
+     * @param row - The row to toggle selection for.
+     * @param isSelected - Optional. A boolean indicating whether the row should be selected (`true`)
+     *                     or deselected (`false`). If not provided, the selection state will be toggled.
+     */
+    toggleRowSelection(row: Row, isSelected?: boolean): void;
+    protected restoreFocus(): void;
+    removeRow(row: Row): void;
+    /**
+     * FOCUS
+     */
+    /**
+     * @returns The currently focused cell in the table.
+     */
+    getFocusedCell(): Cell<CellState<any>> | null;
+    setFocusedCell(cell: Cell, doFocus?: boolean): void;
+    setSelection(indices: number[]): void;
+    scrollRowIntoView(row: Row): void;
+    /**
+     * STATE
+     */
+    /**
+     * Returns the current state of the `TableController` instance.
+     *
+     * @param prop - The property of the state to retrieve.
+     */
+    getState<K extends keyof TableState>(prop: K): TableState[K];
+    /**
+     * Updates the state of the `TableController` instance.
+     *
+     * This method provides two overloads:
+     * 1. A callback function that takes the current state and returns a new state.
+     * 2. A key-value pair where the key is a property of the state, and the value is the new value for that property.
+     *
+     * @param prop - Either a callback function to update the state or the key of the state property to update.
+     * @param value - (Optional) The new value for the specified state property. This is required if `prop` is a key.
+     *
+     * @returns The `TableController` instance for method chaining.
+     *
+     * ### Usage:
+     *
+     * **Using a callback function:**
+     * ```tsx
+     * tableController.setState((state) => ({
+     *   ...state,
+     *   allowEdition: false,
+     * }));
+     * ```
+     *
+     * **Using a key-value pair:**
+     * ```tsx
+     * tableController.setState('allowEdition', false);
+     * ```
+     */
+    setState(cb: (s: TableState) => TableState): this;
+    setState<K extends keyof TableState>(prop: K, value: TableState[K]): this;
+    toggleColumnVisibility(columnName: string, isVisible?: boolean): void;
+    isColumnVisible(columnName: string): boolean;
+    /**
+     * PLUGINS
+     */
+    getPluginOfType<T extends TablePlugin>(clazz: new (...args: any[]) => T): T | undefined;
+    /**
+     * Sets the plugins for the table.
+     */
+    setPlugins(cb: (currentPlugins: TablePlugin[]) => TablePlugin[]): void;
+    getApplicablePlugins<K extends keyof TablePlugin>(method: K): ((...args: Parameters<NonNullable<TablePlugin[K]>> extends [
+        any,
+        ...infer Rest
+    ] ? Rest : void[]) => ReturnType<NonNullable<TablePlugin[K]>>)[];
+}
+
+type ElementBaseState = {
+    properties?: Record<string, unknown>;
+};
+declare abstract class Element<T extends ElementBaseState> {
+    protected state: T;
+    protected table: TableController;
+    constructor(state: T);
+    getTable(): TableController;
+    setTable(table: null | TableController): this;
+    getState<K extends keyof T>(prop: K): T[K];
+    setState(cb: (s: T) => T): this;
+    setState<K extends keyof T>(prop: K, value: T[K]): this;
+}
+
+type CellState<T extends CellState<any> = CellState<any>> = {
+    colName: string;
+    content?: ReactNode;
+    className?: string;
+    isFocused?: boolean;
+    isHidden?: boolean;
+    Renderer?: FC<{
+        cell: Cell<T>;
+    }>;
+    domProperties?: ThHTMLAttributes<HTMLTableCellElement>;
+    properties?: Record<string, unknown>;
+};
+declare class Cell<State extends CellState<any> = CellState<any>> extends Element<State> {
+    protected parentRow: Row;
+    getIndex(): number;
+    getRow(): Row;
+    setRow(row: Row): this;
+    /**
+     *
+     * @param doFocus - If true, the cell will be focused after being set as the focused cell.
+     *                 If false, the cell will contain the tabIndex = 0 but will not be focused.
+     */
+    focus(doFocus?: boolean): void;
+    updateState(state: Partial<State>): void;
+}
+
+declare class FocusControllerPlugin implements TablePlugin {
+    rootElement: HTMLElement | null;
+    scrollIntoView(rowId: string): void;
+    useElementDomProps(controller: TableController, element: TableController | Element<any>, _context: any): {
+        className: string;
+        onClick: (ev: react.MouseEvent) => void;
+        onKeyDown: (ev: react.KeyboardEvent) => void;
+        onBlur: (ev: FocusEvent) => void;
+        ref: (el: HTMLElement | null) => void;
+    } | {
+        className?: undefined;
+        onClick?: undefined;
+        onKeyDown?: undefined;
+        onBlur?: undefined;
+        ref?: undefined;
+    };
+}
+
+declare class WaiAriaPlugin implements TablePlugin {
+    useElementDomProps(controller: TableController, element: TableController | Element<any>, context: any): {
+        'aria-selected': boolean;
+        'aria-rowindex': any;
+        'aria-colindex'?: undefined;
+        role?: undefined;
+        'aria-multiselectable'?: undefined;
+        'aria-colcount'?: undefined;
+        'aria-rowcount'?: undefined;
+    } | {
+        'aria-colindex': any;
+        'aria-selected'?: undefined;
+        'aria-rowindex'?: undefined;
+        role?: undefined;
+        'aria-multiselectable'?: undefined;
+        'aria-colcount'?: undefined;
+        'aria-rowcount'?: undefined;
+    } | {
+        role: string;
+        'aria-multiselectable': boolean | undefined;
+        'aria-colcount': number;
+        'aria-rowcount': number;
+        'aria-selected'?: undefined;
+        'aria-rowindex'?: undefined;
+        'aria-colindex'?: undefined;
+    } | {
+        'aria-selected'?: undefined;
+        'aria-rowindex'?: undefined;
+        'aria-colindex'?: undefined;
+        role?: undefined;
+        'aria-multiselectable'?: undefined;
+        'aria-colcount'?: undefined;
+        'aria-rowcount'?: undefined;
+    };
+}
+
+export { Cell, type CellState, Element, type ElementBaseState, FocusControllerPlugin, Row, type RowProperties, type RowState, RowsGroup, type RowsGroupBaseState, type TBuildBody, type TBuildHead, type TBuildRow, type TBuildTable, TableBody, type TableBodyState, TableController, TableHead, type TableHeadState, type TablePlugin, type TableState, WaiAriaPlugin, defaultPlugins };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

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