react-base-data-table 0.3.8 → 0.4.0

package/dist/types/components/BaseTable/dialogs/columnsDialog/HeaderItem.d.ts

@@ -0,0 +1,20 @@
+import type BaseTableHeader from "../../models/BaseTableHeaders";
+declare const HeaderItem: React.FC<{
+    header: BaseTableHeader;
+    parentId?: string;
+    idx: number;
+    depth: number;
+    hiddenColumns: string[];
+    dropIndicator?: "above" | "below";
+    dragInfo?: {
+        parentId: string | undefined;
+        fromIdx: number;
+    };
+    setDragInfo: React.Dispatch<React.SetStateAction<{
+        parentId: string | undefined;
+        fromIdx: number;
+    } | undefined>>;
+    onCheckboxChange: (headerId: string, checked: boolean) => void;
+    getAllChildrenIds: (header: BaseTableHeader) => string[];
+}>;
+export default HeaderItem;

package/dist/types/components/BaseTable/hooks/useCellPopup.d.ts

@@ -0,0 +1,16 @@
+interface UsePopupParams {
+    isInteractionDisabled: () => boolean;
+    canOpenCell: () => boolean;
+    onOpen: () => void;
+    onClose: () => void;
+    timeoutDuration?: number;
+}
+interface UseCellPopupReturn {
+    isMouseOverPopup: boolean;
+    handleMouseEnter: () => void;
+    handleMouseLeave: () => void;
+    handlePopupMouseEnter: () => void;
+    handlePopupMouseLeave: () => void;
+}
+export declare function useCellPopup({ isInteractionDisabled, canOpenCell, onOpen, onClose, timeoutDuration, }: UsePopupParams): UseCellPopupReturn;
+export {};

package/dist/types/components/BaseTable/hooks/useRowDragDrop.d.ts

@@ -0,0 +1,16 @@
+import type TableItem from "../models/TableItem";
+interface UseRowDragDropProps {
+    items: TableItem[];
+    onRowsReordered?: (fromIndex: number, toIndex: number, draggedItem: TableItem, targetItem: TableItem) => void;
+    groupBy?: string;
+}
+export declare const useRowDragDrop: ({ items, onRowsReordered, groupBy, }: UseRowDragDropProps) => {
+    draggedRowIndex: number | null;
+    dropTargetIndex: number | null;
+    isDraggingRow: boolean;
+    handleRowDragStart: (index: number, tableItem: TableItem) => void;
+    handleDrop: (targetItem: TableItem) => void;
+    handleDragEnd: () => void;
+    handleRowDragOver: (index: number) => void;
+};
+export {};

package/dist/types/components/BaseTable/hooks/useTableData.d.ts

@@ -0,0 +1,19 @@
+import type TableItem from "../models/TableItem";
+import type BaseTableHeader from "../models/BaseTableHeaders";
+import type ActiveTableFilter from "../models/ActiveTableFilter";
+interface UseTableDataReturn {
+    activeFilters: ActiveTableFilter[];
+    setActiveFilters: (filters: ActiveTableFilter[]) => void;
+    clearActiveFilters: () => void;
+    setActiveTableFilter: (headerId: string, itemsToHide: string[] | number[]) => void;
+    filterItemsCache: Record<string, (string | number)[]>;
+    currentSortId: string | undefined;
+    setCurrentSortId: (id: string | undefined) => void;
+    ascendingOrder: boolean;
+    setAscendingOrder: (ascending: boolean) => void;
+    onResetSort: () => void;
+    onSortByColumn: (header: BaseTableHeader | undefined) => void;
+    processedItems: TableItem[];
+}
+export default function useTableData(items: TableItem[], headers: BaseTableHeader[], initialFilters?: ActiveTableFilter[], initialSortId?: string, onSortCallback?: (columnId: string) => void): UseTableDataReturn;
+export {};

package/dist/types/components/BaseTable/hooks/useTableFiltering.d.ts

@@ -0,0 +1,13 @@
+import type ActiveTableFilter from "../models/ActiveTableFilter";
+import type TableItem from "../models/TableItem";
+import type BaseTableHeader from "../models/BaseTableHeaders";
+interface UseTableFilteringReturn {
+    activeFilters: ActiveTableFilter[];
+    setActiveFilters: (filters: ActiveTableFilter[]) => void;
+    clearActiveFilters: () => void;
+    setActiveTableFilter: (headerId: string, itemsToHide: string[] | number[]) => void;
+    filteredItems: TableItem[];
+    filterItemsCache: Record<string, (string | number)[]>;
+}
+export default function useTableFiltering(items: TableItem[], headers: BaseTableHeader[], initialFilters?: ActiveTableFilter[], sortedItems?: TableItem[]): UseTableFilteringReturn;
+export {};

package/dist/types/components/BaseTable/hooks/useTableGrouping.d.ts

@@ -0,0 +1,14 @@
+import type TableItem from "../models/TableItem";
+import type ItemWithGroupInfo from "../models/ItemWithGroupInfo";
+import type GroupInfo from "../models/GroupInfo";
+interface UseTableGroupingReturn {
+    groupedItemsEntries: [string, {
+        rowIndex: number;
+        item: TableItem;
+    }[]][];
+    flatGroupedItems: Array<GroupInfo | ItemWithGroupInfo>;
+    isGroupLinked: (groupName: string) => boolean;
+    getMasterGroupNameLinked: (groupName: string) => string | undefined;
+}
+export default function useTableGrouping(): UseTableGroupingReturn;
+export {};

package/dist/types/components/BaseTable/hooks/useTableInteractions.d.ts

@@ -0,0 +1,43 @@
+import { type CSSProperties } from "react";
+import type BaseTableHeader from "../models/BaseTableHeaders";
+import type TableItem from "../models/TableItem";
+import type CellCoordinate from "../models/CellCordinate";
+import type HighlightCondition from "../models/HighlightCondition";
+import type CommentData from "../models/CommentData";
+interface UseTableInteractionsProps<T extends TableItem> {
+    items: TableItem[];
+    groupedItemsEntries?: [string, {
+        rowIndex: number;
+        item: TableItem;
+    }[]][];
+    onChange?: (itemUpdated: T, originalIndex: number, fromArrayIndex?: number) => Promise<void> | void;
+    onBulkChange?: (items: {
+        itemUpdated: T;
+        originalIndex: number;
+    }[], headerId: string) => Promise<void> | void;
+    onRowDoubleClick?: (item: T) => Promise<void> | void;
+    onSaveComment?: (comment: CommentData, item: TableItem) => Promise<void> | void;
+    onDeleteComment?: (comment: CommentData, item: TableItem) => Promise<void> | void;
+    onSetHighlightCondition?: (highlightCondition: HighlightCondition, item: TableItem) => Promise<void> | void;
+    onRemoveHighlightCondition?: (highlightCondition: HighlightCondition, cssPropertyToRemove: keyof CSSProperties, item: TableItem) => Promise<void> | void;
+    onAddListOption?: (newOption: string, header: BaseTableHeader) => Promise<void> | void;
+}
+export declare function useTableInteractions<T extends TableItem>({ items, groupedItemsEntries, onChange, onBulkChange, onRowDoubleClick, onSaveComment, onDeleteComment, onSetHighlightCondition, onRemoveHighlightCondition, onAddListOption, }: UseTableInteractionsProps<T>): {
+    setExpandedSelection: (cells: CellCoordinate[]) => void;
+    onCellBlur: (editValue: string | number | undefined, item: TableItem, header: BaseTableHeader, cellCoordinate: CellCoordinate) => Promise<void>;
+    onCellEnter: (editValue: string | number | undefined, item: TableItem, header: BaseTableHeader, cellCoordinate: CellCoordinate) => Promise<void>;
+    onCellClick: (cellCoordinate: CellCoordinate) => void;
+    handleCellKeyDown: (e: React.KeyboardEvent) => void;
+    handleRowDoubleClick: (item: TableItem) => Promise<void>;
+    saveCommentHandler: (comment: CommentData, item: TableItem) => Promise<void>;
+    deleteCommentHandler: (comment: CommentData, item: TableItem) => Promise<void>;
+    setHighlightCondition: (item: TableItem, headerId: string, cssStyle: React.CSSProperties) => Promise<void>;
+    removeHighlightCondition: (item: TableItem, headerId: string, cssPropertyToRemove: keyof CSSProperties) => void;
+    onCellMouseDown: (e: React.MouseEvent<HTMLTableCellElement>, cellCoordinate: CellCoordinate) => void;
+    onCellMouseEnter: (e: React.MouseEvent<HTMLTableCellElement>, _cellCoordinate: CellCoordinate) => void;
+    onMouseMove: (e: React.MouseEvent) => void;
+    onRightClick: (cellCoordinate: CellCoordinate, e: React.MouseEvent) => void;
+    addListOption: (newOption: string, header: BaseTableHeader) => Promise<void>;
+    getItemFromCellCoordinates: (cell: CellCoordinate) => TableItem | undefined;
+};
+export {};

package/dist/types/components/BaseTable/hooks/useTableSorting.d.ts

@@ -0,0 +1,13 @@
+import type BaseTableHeader from "../models/BaseTableHeaders";
+import type TableItem from "../models/TableItem";
+interface UseTableSortingReturn {
+    currentSortId: string | undefined;
+    setCurrentSortId: (id: string | undefined) => void;
+    ascendingOrder: boolean;
+    setAscendingOrder: (ascending: boolean) => void;
+    onResetSort: () => void;
+    onSortByColumn: (header: BaseTableHeader | undefined) => void;
+    sortedItems: TableItem[];
+}
+export default function useTableSorting(items: TableItem[], headers: BaseTableHeader[], initialSortId?: string, onSortCallback?: (columnId: string) => void): UseTableSortingReturn;
+export {};

package/dist/types/components/BaseTable/hooks/useVirtualRows.d.ts

@@ -0,0 +1,11 @@
+import type { MutableRefObject } from "react";
+export type Props = {
+    rowsCount: number;
+    scrollRef: MutableRefObject<HTMLElement | null>;
+};
+export declare const useVirtualRows: ({ rowsCount, scrollRef }: Props) => {
+    virtualizer: import("@tanstack/virtual-core").Virtualizer<HTMLElement, Element>;
+    virtualRows: import("@tanstack/virtual-core").VirtualItem[];
+    before: number;
+    after: number;
+};

package/dist/types/components/BaseTable/models/ActiveTableFilter.d.ts

@@ -0,0 +1,6 @@
+import type { NumberCondition } from "../tableFilter/filterImplementations/NumberFilter/NumberFilter";
+export default interface ActiveTableFilter {
+    headerId: string;
+    itemsToHide: string[] | number[];
+    numberConditions?: NumberCondition[];
+}

package/dist/types/components/BaseTable/models/AdvancedTableSettings.d.ts

@@ -0,0 +1,19 @@
+export default interface AdvancedTableSettings {
+    marginTop?: string;
+    noBorder?: boolean;
+    pinColumns?: boolean;
+    alignCenterInLine?: boolean;
+    currentSortId?: string;
+    contrastRow?: boolean;
+    indexUseOriginalOrder?: boolean;
+    enableRowDragDrop?: boolean;
+    currentUsername?: string;
+    showIndex?: boolean;
+    selectNewOptionOnAdd?: boolean;
+    canAddListOptions?: boolean;
+    showFooter?: boolean;
+    rowIdProperty?: string;
+    tableId?: string;
+    focusedRowIndex?: number;
+    hasContextMenu?: boolean;
+}

package/dist/types/components/BaseTable/models/BaseTableHeaders.d.ts

@@ -0,0 +1,38 @@
+import { type ReactNode } from "react";
+import type TableItem from "./TableItem";
+export declare const TableHeaderType: {
+    readonly STRING: "string";
+    readonly LIST: "list";
+    readonly NUMBER: "number";
+};
+export type TableHeaderType = (typeof TableHeaderType)[keyof typeof TableHeaderType];
+export default interface BaseTableHeader {
+    id: string;
+    text: string;
+    hasFilter?: boolean;
+    width?: number;
+    children?: BaseTableHeader[];
+    editOptions?: {
+        editable?: boolean;
+        isDisabled?: (item: TableItem, fromArrayData?: {
+            index: number;
+        }) => boolean;
+        notApplicable?: (item: TableItem, fromArrayData?: {
+            index: number;
+        }) => boolean;
+        greyedOutIfNotEditable?: boolean;
+        required?: boolean;
+        type: TableHeaderType;
+        options?: string[];
+        defaultValue?: string | number;
+        canAddNewOption?: boolean;
+    };
+    fromArray?: string;
+    sortable?: boolean;
+    align?: "left" | "center" | "right";
+    customSort?: (a: TableItem, b: TableItem, ascendingOrder: boolean) => number;
+    customHeader?: (header: BaseTableHeader) => ReactNode;
+    customRender?: (item: TableItem, header: BaseTableHeader, fromArrayData?: {
+        index: number;
+    }) => ReactNode;
+}

package/dist/types/components/BaseTable/models/CellCordinate.d.ts

@@ -0,0 +1,8 @@
+export default interface CellCoordinate {
+    rowIndex: number;
+    columnIndex: number;
+    fromArrayData?: {
+        index: number;
+        fromArray: string;
+    };
+}

package/dist/types/components/BaseTable/models/CommentData.d.ts

@@ -0,0 +1,10 @@
+export default interface CommentData {
+    propertyId: string;
+    value: unknown;
+    date: Date;
+    formatDateFunction?: (date: Date) => string;
+    author?: string;
+    commentId?: number;
+    columnId?: string;
+    text: string;
+}

package/dist/types/components/BaseTable/models/ContextMenu.d.ts

@@ -0,0 +1,10 @@
+import type BaseTableHeader from "./BaseTableHeaders";
+import type CellCoordinate from "./CellCordinate";
+import type TableItem from "./TableItem";
+export default interface ContextMenu {
+    x: number;
+    y: number;
+    header: BaseTableHeader;
+    item?: TableItem;
+    cellCoordinate?: CellCoordinate;
+}

package/dist/types/components/BaseTable/models/ContextMenuAction.d.ts

@@ -0,0 +1,12 @@
+import type CellCoordinate from "./CellCordinate";
+import type TableItem from "./TableItem";
+export default interface ContextMenuAction {
+    icon?: string;
+    iconColor?: string;
+    text: string;
+    onClick: (event: React.MouseEvent, item?: TableItem, itemCoordinates?: CellCoordinate) => void;
+    groupName?: string;
+    disabled?: boolean;
+    subActions?: ContextMenuAction[];
+    customRender?: () => React.ReactNode;
+}

package/dist/types/components/BaseTable/models/DialogItem.d.ts

@@ -0,0 +1,9 @@
+export default interface DialogItem {
+    id: string;
+    title: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    dialogImplementation: React.ReactNode;
+}

package/dist/types/components/BaseTable/models/GroupInfo.d.ts

@@ -0,0 +1,7 @@
+export default interface GroupInfo {
+    isGroup: boolean;
+    groupName: string;
+    isCollapsed?: boolean;
+    masterGroupName?: string;
+    linkedGroupNames?: string[];
+}

package/dist/types/components/BaseTable/models/HighlightCondition.d.ts

@@ -0,0 +1,7 @@
+import { type CSSProperties } from "react";
+export default interface HighlightCondition {
+    propertyId: string;
+    value: unknown;
+    style: CSSProperties;
+    columnId?: string;
+}

package/dist/types/components/BaseTable/models/ItemWithGroupInfo.d.ts

@@ -0,0 +1,7 @@
+import type GroupInfo from "./GroupInfo";
+import type TableItem from "./TableItem";
+export default interface ItemWithGroupInfo extends GroupInfo {
+    isGroup: false;
+    rowIndex: number;
+    item: TableItem;
+}

package/dist/types/components/BaseTable/models/LinkedGroup.d.ts

@@ -0,0 +1,4 @@
+export default interface LinkedGroup {
+    master: string;
+    linked: string[];
+}

package/dist/types/components/BaseTable/models/TableConfiguration.d.ts

@@ -0,0 +1,4 @@
+export default interface TableConfiguration {
+    defaultSortBy?: string;
+    defaultSortDesc?: boolean;
+}

package/dist/types/components/BaseTable/models/TableItem.d.ts

@@ -0,0 +1,4 @@
+export default interface TableItem {
+    [key: string]: string | number | Array<any> | undefined;
+    section?: string;
+}

package/dist/types/components/BaseTable/tableCell/BaseTableCell.d.ts

@@ -0,0 +1,21 @@
+import { type CSSProperties } from "react";
+import "./BaseTableCell.css";
+import type TableItem from "../models/TableItem";
+import type CommentData from "../models/CommentData";
+import type BaseTableHeader from "../models/BaseTableHeaders";
+export interface BaseTableCellProps {
+    header: BaseTableHeader;
+    item: TableItem;
+    rowIndex: number;
+    columnIndex: number;
+    rowSpan?: number;
+    comments?: CommentData[];
+    style?: CSSProperties;
+    fromArrayData?: {
+        fromArray: string;
+        index: number;
+    };
+    isInLinkedGroup: boolean;
+}
+declare const BaseTableCell: React.FC<BaseTableCellProps>;
+export default BaseTableCell;

package/dist/types/components/BaseTable/tableCell/IndexCell.d.ts

@@ -0,0 +1,8 @@
+import type TableItem from "../models/TableItem";
+interface IndexCellProps {
+    item: TableItem;
+    rowIndex: number;
+    rowSpan: number;
+}
+declare const IndexCell: React.FC<IndexCellProps>;
+export default IndexCell;

package/dist/types/components/BaseTable/tableCell/cellImplementation/ListCell.d.ts

@@ -0,0 +1,13 @@
+import type BaseTableHeader from "../../models/BaseTableHeaders";
+interface ListCellProps {
+    inputRef: React.Ref<HTMLInputElement> | null;
+    header: BaseTableHeader;
+    value?: string;
+    options: string[];
+    onSelect: (value: string) => void;
+    onEnter: (value: string) => void;
+    disabled?: boolean;
+    hideOptions?: boolean;
+}
+export default function ListCell(props: Readonly<ListCellProps>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/BaseTable/tableCell/cellImplementation/NumberCell.d.ts

@@ -0,0 +1,11 @@
+interface NumberCellProps {
+    id: string;
+    cellValue: string | number | null | undefined;
+    initialValue?: string;
+    inputRef: React.RefObject<HTMLInputElement>;
+    onBlur?: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    onChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    disabled?: boolean;
+}
+export default function NumberCell(props: Readonly<NumberCellProps>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/BaseTable/tableCell/cellImplementation/OptionList.d.ts

@@ -0,0 +1,11 @@
+interface ListCellProps {
+    onClick: (option: string, isOptionToAdd?: boolean) => void;
+    value: string;
+    text: string;
+    isSelected: boolean;
+    italic?: boolean;
+    optionKey: string;
+    isOptionToAdd?: boolean;
+}
+export default function OptionList(props: Readonly<ListCellProps>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/BaseTable/tableCell/cellImplementation/formatNumberFunctions.d.ts

@@ -0,0 +1 @@
+export declare const formatNumber: (value: number | string, precision?: number) => string;

package/dist/types/components/BaseTable/tableFilter/FilterDropdown.d.ts

@@ -0,0 +1,13 @@
+import { FilterTypes } from "../../../enum/FilterTypes";
+interface TableFilterProps {
+    show: boolean;
+    tableRef?: React.RefObject<HTMLTableElement | null>;
+    headerId: string;
+    filterType: FilterTypes;
+    items: string[] | number[];
+    filterButtonRef: React.RefObject<HTMLButtonElement | null>;
+    wrapperRef: React.RefObject<HTMLDivElement | null>;
+    onShowOrHide: (show: boolean) => void;
+}
+declare function FilterDropdown(props: Readonly<TableFilterProps>): import("react/jsx-runtime").JSX.Element;
+export default FilterDropdown;

package/dist/types/components/BaseTable/tableFilter/TableFilter.d.ts

@@ -0,0 +1,17 @@
+import { FilterTypes } from "../../../enum/FilterTypes";
+import type ActiveTableFilter from "../models/ActiveTableFilter";
+import type { NumberCondition } from "./filterImplementations/NumberFilter/NumberFilter";
+interface TableFilterProps {
+    show: boolean;
+    currentFilter?: ActiveTableFilter;
+    tableRef?: React.RefObject<HTMLTableElement | null>;
+    filterName: string;
+    headerId: string;
+    filterType: FilterTypes;
+    items: string[] | number[];
+    itemsToHide: string[] | number[];
+    onShowOrHide: (show: boolean) => void;
+    onSetFilter: (id: string, valueToFilter: string[] | number[], numberCondition?: NumberCondition[]) => void;
+}
+declare function TableFilter(props: Readonly<TableFilterProps>): import("react/jsx-runtime").JSX.Element;
+export default TableFilter;

package/dist/types/components/BaseTable/tableFilter/filterImplementations/NumberFilter/NumberConditionItem.d.ts

@@ -0,0 +1,10 @@
+import type { NumberCondition } from "./NumberFilter";
+interface NumberConditionProps {
+    numberCondition: NumberCondition;
+    isNew: boolean;
+    immediatApply?: boolean;
+    deleteCondition?: (condition: NumberCondition) => void;
+    updateCondition: (condition: NumberCondition) => void;
+}
+declare function NumberConditionItem(props: Readonly<NumberConditionProps>): import("react/jsx-runtime").JSX.Element;
+export default NumberConditionItem;

package/dist/types/components/BaseTable/tableFilter/filterImplementations/NumberFilter/NumberFilter.d.ts

@@ -0,0 +1,16 @@
+import { FilterTypes } from "../../../../../enum/FilterTypes";
+interface NumberFilterProps {
+    headerId: string;
+    filterType: FilterTypes;
+    items: string[] | number[];
+    onShowOrHide: (show: boolean) => void;
+}
+export type Operator = "=" | ">" | "<" | ">=" | "<=" | "between";
+export interface NumberCondition {
+    id: string;
+    operator: Operator;
+    value1: number;
+    value2?: number;
+}
+declare function NumberFilter(props: Readonly<NumberFilterProps>): import("react/jsx-runtime").JSX.Element;
+export default NumberFilter;

package/dist/types/components/BaseTable/tableFilter/filterImplementations/TextFilter.d.ts

@@ -0,0 +1,9 @@
+import { FilterTypes } from "../../../../enum/FilterTypes";
+interface TextFilterProps {
+    headerId: string;
+    filterType: FilterTypes;
+    items: string[] | number[];
+    onShowOrHide: (show: boolean) => void;
+}
+declare function TextFilter(props: Readonly<TextFilterProps>): import("react/jsx-runtime").JSX.Element;
+export default TextFilter;

package/dist/types/components/BaseTable/tableFunctions/CellSelection.d.ts

@@ -0,0 +1,8 @@
+import type CellCoordinate from "../models/CellCordinate";
+import type TableItem from "../models/TableItem";
+import type BaseTableHeader from "../models/BaseTableHeaders";
+declare const calculateSelectedCellAndExpandedSelection: (e: React.KeyboardEvent, selectedCell: CellCoordinate | undefined, expandedSelection: CellCoordinate[], columnsCount: number, rowsCount: number, processedLeafHeaders: BaseTableHeader[], selectedItem?: TableItem) => {
+    newSelectedCell: CellCoordinate | undefined;
+    newExpandedSelection: CellCoordinate[];
+};
+export default calculateSelectedCellAndExpandedSelection;

package/dist/types/components/BaseTable/tableFunctions/FilteringAndSorting.d.ts

@@ -0,0 +1,7 @@
+import type ActiveTableFilter from "../models/ActiveTableFilter";
+import type BaseTableHeader from "../models/BaseTableHeaders";
+import type TableItem from "../models/TableItem";
+export declare const NBSP = "\u00A0";
+export declare const filterItems: (items: TableItem[], filters: ActiveTableFilter[]) => TableItem[];
+export declare const sortItems: (items: TableItem[], headers: BaseTableHeader[], currentSortType: "asc" | "desc", sortBy: string | undefined) => TableItem[];
+export declare const tryToConvertToNumber: (item: any) => any;

package/dist/types/components/BaseTable/tableFunctions/highlightCondition.d.ts

@@ -0,0 +1,5 @@
+import type { CSSProperties } from "react";
+import type HighlightCondition from "../models/HighlightCondition";
+import type TableItem from "../models/TableItem";
+export declare const getCellHighlightConditions: (rowConditions: HighlightCondition[], columnId: string) => CSSProperties;
+export declare const getRowHighlightConditions: (row: TableItem, highlightConditions: HighlightCondition[]) => HighlightCondition[];

package/dist/types/components/ColorPicker.d.ts

@@ -0,0 +1,7 @@
+declare const ColorPicker: ({ initialColor, applyOpacity, onColorChange, onClose, }: {
+    initialColor?: string;
+    applyOpacity?: number;
+    onColorChange: (color: string) => void;
+    onClose?: () => void;
+}) => import("react/jsx-runtime").JSX.Element;
+export default ColorPicker;

package/dist/types/constants.d.ts

@@ -0,0 +1 @@
+export declare const TABLE_ID = "main-base-table";

package/dist/types/enum/DateUnits.d.ts

@@ -0,0 +1,8 @@
+export declare enum DateUnits {
+    YEARS = "Years",
+    MONTHS = "Months",
+    WEEKS = "Weeks",
+    DAYS = "Days",
+    HOURS = "Hours",
+    MINUTES = "Minutes"
+}

package/dist/types/enum/FilterTypes.d.ts

@@ -0,0 +1,4 @@
+export declare enum FilterTypes {
+    STRING = "string",
+    NUMBER = "number"
+}

package/dist/types/hooks/useClickOutside.d.ts

@@ -0,0 +1,2 @@
+import { type RefObject } from "react";
+export default function useClickOutside(ref: RefObject<HTMLElement | null> | RefObject<HTMLElement>[], callback: () => void): void;

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+export { default as BaseTable } from "./components/BaseTable/BaseTableWithContext";
+import ActiveTableFilter from "./components/BaseTable/models/ActiveTableFilter";
+export type { ActiveTableFilter };
+import BaseTableHeader from "./components/BaseTable/models/BaseTableHeaders";
+export type { BaseTableHeader };
+import TableConfiguration from "./components/BaseTable/models/TableConfiguration";
+export type { TableConfiguration };

package/dist/types/main.d.ts

@@ -0,0 +1 @@
+import "./index.css";

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

@@ -0,0 +1,13 @@
+import type CellCoordinate from "../components/BaseTable/models/CellCordinate";
+interface CommentPopupState {
+    openCommentCell?: CellCoordinate;
+    actions: {
+        setOpenCommentCell: (cell: CellCoordinate | undefined) => void;
+    };
+}
+export declare const useTableDragStore: import("zustand").UseBoundStore<import("zustand").StoreApi<CommentPopupState>>;
+export declare const useOpenCommentCell: () => CellCoordinate | undefined;
+export declare const useCommentPopupActions: () => {
+    setOpenCommentCell: (cell: CellCoordinate | undefined) => void;
+};
+export {};

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

@@ -0,0 +1,13 @@
+import type ContextMenu from "../components/BaseTable/models/ContextMenu";
+interface CommentPopupState {
+    contextMenu?: ContextMenu;
+    actions: {
+        setContextMenu: (contextMenu: ContextMenu | undefined) => void;
+    };
+}
+export declare const useContextMenuStore: import("zustand").UseBoundStore<import("zustand").StoreApi<CommentPopupState>>;
+export declare const useContextMenu: () => ContextMenu | undefined;
+export declare const useContextMenuActions: () => {
+    setContextMenu: (contextMenu: ContextMenu | undefined) => void;
+};
+export {};

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

@@ -0,0 +1,21 @@
+import type DialogItem from "../components/BaseTable/models/DialogItem";
+interface DialogsState {
+    openedDialogs: DialogItem[];
+    actions: {
+        openDialog: (position: {
+            x: number;
+            y: number;
+        }, title: string, dialogImplementation: React.ReactNode) => void;
+        closeDialog: (dialogId: string) => void;
+    };
+}
+export declare const useDialogsStore: import("zustand").UseBoundStore<import("zustand").StoreApi<DialogsState>>;
+export declare const useOpenedDialogs: () => DialogItem[];
+export declare const useDialogsActions: () => {
+    openDialog: (position: {
+        x: number;
+        y: number;
+    }, title: string, dialogImplementation: React.ReactNode) => void;
+    closeDialog: (dialogId: string) => void;
+};
+export {};