rez-table-listing-mui/dist/index.d.ts

A rez table listing component built on TanStack Table

import * as react_jsx_runtime from 'react/jsx-runtime';
import { SortingState, PaginationState, RowSelectionState, ExpandedState, ColumnDef, Row, Table, ColumnOrderState, Header } from '@tanstack/react-table';
import React, { Dispatch, SetStateAction } from 'react';

interface OperationProps {
    label: string;
    value: string;
}
type OperationMapProps = {
    [key in FilterInputDataTypes]?: OperationProps[];
};
interface FilterOperationListProps {
    label: string;
    value: string;
}
type FilterInputDataTypes = "text" | "select" | "multiselect" | "date" | "year" | "number";
interface FilterColumnsListProps {
    created_date: string | null;
    entity_type: string;
    id: string;
    name: string;
    status: string | null;
    parent_type: string;
    parent_id: string;
    code: string | null;
    created_by: string | null;
    modified_by: string | null;
    modified_date: string | null;
    enterprise_id: string | null;
    organization_id: string | null;
    app_code: string | null;
    mapped_entity_type: string;
    menu_code: string | null;
    table_name: string | null;
    col_position: number;
    sortable: string | null;
    searchable: string | null;
    attribute_key: string;
    sort_type: string | null;
    data_type: FilterInputDataTypes;
    data_source_type: string | null;
    datasource_list: any | null;
    visible: string;
}
interface FilterColumnsDataProps {
    column_list: FilterColumnsListProps[];
    operation_list: OperationMapProps;
    saved_filter: FilterOperationListProps[];
}
interface FilterDropdownDataProps {
    [key: string]: FilterOperationListProps[];
}
interface FilterDrawerProps {
    tableStates: CraftTableOptionsProps;
    open?: boolean;
    onClose?: () => void;
    onDeleteFilter?: () => void;
    onSaveFilter?: (name: string) => void;
    onUpdateFilter?: (name: string) => void;
    columnsData: FilterColumnsDataProps;
    dropdownData: FilterDropdownDataProps;
    defaultFilters?: Array<{
        filter_attribute: string;
        filter_operator: string;
        filter_value: string;
    }>;
    savedFilters?: Array<{
        label: string;
        value: string;
    }>;
    tableData?: {
        entity_list: any[];
    };
}
interface FilterStateProps {
    filter_attribute: string;
    filter_operator: string;
    filter_value: string | string[];
}
interface FilterMasterStateProps {
    attributes: {
        selected: string;
        radio: string[];
    };
    saved_filters: {
        selectedId: string;
        selectedName: string;
    };
    activeFilterTabIndex: number;
}

interface QuickFilterModalProps {
    show?: boolean;
    filterSettingStates: craftTableFilterSettingsOptionsProps;
    onClose?: () => void;
    columnsData: FilterColumnsDataProps;
    columnsDataLoading: boolean;
    tabsApiData?: string[];
    tabsApiDataLoading?: boolean;
    onSaveSettingsData?: (data: any) => void;
}
type TabName = string;
type SortingType = "asc" | "desc";
type QuickTabSortingType = "asc" | "dsc" | "count_asc" | "count_dsc" | "custom";
interface QuickTabConfigProps {
    attribute?: string;
    sorting?: QuickTabSortingType;
    hide_list?: string[];
    show_list?: string[];
    isAllSelected?: boolean;
    isCombineOther?: boolean;
}
interface ColumnItem {
    label: string;
    value: string;
}
interface ColumnTab {
    tab_name: TabName;
    show_list: ColumnItem[];
    hide_list: ColumnItem[];
}
interface SortingConfigSortByProps {
    column: string;
    order: SortingType;
}
interface SortingConfigTabProps {
    tab_name: TabName;
    sortby: SortingConfigSortByProps[];
}
interface SortingConfigProps {
    isDefault?: boolean;
    sortby?: SortingConfigSortByProps[];
    tabs?: SortingConfigTabProps[];
}
interface ColumnTabConfigProps {
    isDefault?: boolean;
    show_list?: ColumnItem[];
    hide_list?: ColumnItem[];
    tabs?: ColumnTab[];
}
interface SettingsDataProps {
    isDefault?: boolean;
    show_list?: ColumnItem[];
    hide_list?: ColumnItem[];
    tabs?: ColumnTab[];
    quick_tab?: QuickTabConfigProps;
    column?: ColumnTabConfigProps;
    sorting?: SortingConfigProps;
}
interface SavedButtonErrorProps {
    hasError: boolean;
    messages: {
        type: string;
        message: string;
    }[];
}

interface CraftTableOptionsProps {
    sorting: SortingState;
    setSorting: Dispatch<SetStateAction<SortingState>>;
    pagination: PaginationState;
    setPagination: Dispatch<SetStateAction<PaginationState>>;
    rowSelection: RowSelectionState;
    setRowSelection: Dispatch<SetStateAction<RowSelectionState>>;
    isCompactTable?: boolean;
    setIsCompactTable?: Dispatch<SetStateAction<boolean>>;
    expanded: ExpandedState;
    setExpanded: Dispatch<SetStateAction<ExpandedState>>;
    wrapColumns: Record<string, boolean>;
    setWrapColumns: Dispatch<SetStateAction<Record<string, boolean>>>;
    filters: FilterStateProps[];
    setFilters: Dispatch<SetStateAction<FilterStateProps[]>>;
    savedFilterEditValue: string | number;
    setSavedFilterEditValue: Dispatch<SetStateAction<string | number>>;
    filterToDelete: FilterOperationListProps | null;
    setFilterToDelete: Dispatch<SetStateAction<FilterOperationListProps | null>>;
    filterSelectedAttributeValue: string;
    setFilterSelectedAttributeValue: Dispatch<SetStateAction<string>>;
    filterMaster: FilterMasterStateProps | null;
    setFilterMaster: Dispatch<SetStateAction<FilterMasterStateProps | null>>;
    showTableFilter: boolean;
    setShowTableFilter: Dispatch<SetStateAction<boolean>>;
    showFilterOptions: boolean;
    setShowFilterOption: Dispatch<SetStateAction<boolean>>;
}
interface craftTableFilterSettingsOptionsProps {
    settingsData: SettingsDataProps;
    setSettingsData: Dispatch<SetStateAction<SettingsDataProps>>;
    showListViewSettings: boolean;
    setShowListViewSettings: Dispatch<SetStateAction<boolean>>;
    quickTabStates: QuickTabConfigProps;
    setQuickTabStates: Dispatch<SetStateAction<QuickTabConfigProps>>;
    columnTabState: ColumnTabConfigProps;
    setColumnTabState: Dispatch<SetStateAction<ColumnTabConfigProps>>;
    sortingTabState: SortingConfigProps;
    setSortingTabState: Dispatch<SetStateAction<SortingConfigProps>>;
    saveButtonError: SavedButtonErrorProps;
    setSaveButtonError: Dispatch<SetStateAction<SavedButtonErrorProps>>;
}
interface CraftTableFeatureProps {
    enableSorting?: boolean;
    enableServerSidePagination?: boolean;
    enableServerSideSorting?: boolean;
    enableRowSelection?: boolean;
    enableColumnResizing?: boolean;
    enableColumnReordering?: boolean;
    enableColumnPinning?: boolean;
    enableMultiColumnSorting?: boolean;
    enableTopbar?: boolean;
    enableWordBreakAll?: boolean;
    stickyHeader?: boolean;
    compactTable?: boolean;
    striped?: boolean;
}

interface CraftTablePaginationProps {
    totalRows?: number;
    rowsPerPageArray?: number[];
    showPagination?: boolean;
    paginationPosition?: "top" | "bottom";
    paginationView?: "full" | "compact";
}
interface LoadingOptionsProps {
    isLoading: boolean;
    loaderText?: string;
    loadingComponent?: React.ReactNode;
}
interface TopbarOptionsProps {
    tableStates: CraftTableOptionsProps;
    leftSideComponent?: React.ReactNode;
    rightSideComponent?: React.ReactNode;
    showColumnToggle?: boolean;
    showCompactTableToggle?: boolean;
    showChangeLayoutToggle?: boolean;
    viewMoreToggle?: boolean;
    showSearch?: boolean;
    showSortingToggle?: boolean;
    showFilterToggle?: boolean;
    searchValue?: string;
    onSearchChange?: (val: string) => void;
    onFilterButtonClick?: () => void;
}
interface CustomRenderContext<T> {
    value: unknown;
    row: Row<T>;
    table: Row<T>[];
}
type CustomRenderFnMap<T> = {
    [key: string]: (ctx: CustomRenderContext<T>) => React.ReactNode;
};
type CustomColumnMeta = {
    type?: "custom";
    propName?: string;
    [key: string]: any;
};
type CustomColumnDef<T> = ColumnDef<T> & {
    meta?: CustomColumnMeta;
};
interface CraftTableStyleProps {
    wrapperStyle?: React.CSSProperties;
}
interface FilterOptionsProps {
    onClick?: () => void;
    show?: boolean;
    component: React.ReactNode;
}
interface settingsOptionsProps {
    showIcon?: boolean;
    onClick?: () => void;
}
interface CraftTableProps<T> {
    data: T[];
    columns: CustomColumnDef<T>[];
    tableStates: CraftTableOptionsProps;
    paginationOptions?: CraftTablePaginationProps;
    featureOptions?: CraftTableFeatureProps;
    nestedComponent?: React.ComponentType<{
        row: Row<T>;
    }>;
    loadingOptions?: LoadingOptionsProps;
    topbarOptions?: TopbarOptionsProps;
    customRenderFn?: CustomRenderFnMap<T>;
    shouldHideColumn?: (accessorKey?: string) => boolean;
    styleOptions?: CraftTableStyleProps;
    emptyListComponent?: React.ReactNode;
    filterOptions?: FilterOptionsProps;
    settingsOptions?: settingsOptionsProps;
    craftTableFilterSettingsOptions?: craftTableFilterSettingsOptionsProps;
}
interface CraftTableComponentProps<T> {
    table: Table<T>;
    featureOptions: CraftTableFeatureProps;
    NestedComponent?: React.ComponentType<{
        row: Row<T>;
    }>;
    columnOrder: ColumnOrderState;
    setColumnOrder: React.Dispatch<React.SetStateAction<ColumnOrderState>>;
    isCompactTable: boolean;
    tableStates: CraftTableOptionsProps;
}
interface TableHeaderProps<T> {
    header: Header<T, unknown>;
    featureOptions: CraftTableFeatureProps;
    tableStates: CraftTableOptionsProps;
}

declare function TableWrapper<T>({ data, columns, tableStates, paginationOptions, featureOptions, topbarOptions, nestedComponent, loadingOptions, customRenderFn, shouldHideColumn, emptyListComponent, filterOptions, }: CraftTableProps<T>): react_jsx_runtime.JSX.Element;

declare function useCraftTable(paginationPageSize?: number): CraftTableOptionsProps;

declare function useCraftTableFilterSettings(): craftTableFilterSettingsOptionsProps;

interface TabDataProps {
    tab_value: string | null;
    tab_value_count: string | number;
}
interface TableTabsProps {
    loading?: boolean;
    tabsData?: TabDataProps[];
    activeTab?: string;
    tableStates: CraftTableOptionsProps;
    onClick: (state: string) => void;
    columns?: any[];
    settingsOptions?: settingsOptionsProps;
}
declare function TableTabs({ loading, tabsData, activeTab, onClick, tableStates, settingsOptions, }: TableTabsProps): react_jsx_runtime.JSX.Element;

declare function TableFilter({ onClose, columnsData, tableStates, onDeleteFilter, onSaveFilter, onUpdateFilter, dropdownData, }: FilterDrawerProps): react_jsx_runtime.JSX.Element;

declare function QuickFilterSettings({ show, filterSettingStates, onClose, columnsData, columnsDataLoading, tabsApiData, tabsApiDataLoading, onSaveSettingsData, }: QuickFilterModalProps): react_jsx_runtime.JSX.Element;

export { TableFilter as CraftTableFilter, QuickFilterSettings as CraftTableSettings, TableTabs as CraftTableTabs, TableWrapper, useCraftTable, useCraftTableFilterSettings };
export type { CraftTableComponentProps, CraftTableFeatureProps, CraftTableOptionsProps, CraftTablePaginationProps, CraftTableProps, CustomRenderContext, CustomRenderFnMap, FilterOptionsProps, TableHeaderProps, TopbarOptionsProps, craftTableFilterSettingsOptionsProps, settingsOptionsProps };