@layers-app/shared 0.0.36 → 0.0.37

package/dist/{KanbanLayout-B8RukpT8.js → KanbanLayout-VHRhOh9W.js}

@@ -11,7 +11,7 @@ import "@mantine/form";
 import "@mantine/dropzone";
 import "@mantine/notifications";
 import "lodash-es";
-import { u as F, S as z } from "./index-D_nxhqe0.js";
+import { u as F, S as z } from "./index-De7pQ4GG.js";
 import "react-dom";
 import "draggable-ui";
 import "@mantine/modals";

package/dist/{TimeLine--HywOpKf.js → TimeLine-BByQEycM.js}

@@ -11,7 +11,7 @@ import "@mantine/form";
 import "@mantine/dropzone";
 import "@mantine/notifications";
 import "lodash-es";
-import { u as L } from "./index-D_nxhqe0.js";
+import { u as L } from "./index-De7pQ4GG.js";
 import "react-dom";
 import "draggable-ui";
 import "@mantine/modals";
@@ -19,7 +19,7 @@ import "i18next";
 import "framer-motion";
 import "@mantine/dates";
 const R = S(
-  () => import("./index.esm-DbeiBKnb.js").then((r) => ({ default: r.default }))
+  () => import("./index.esm-CKK13a1d.js").then((r) => ({ default: r.default }))
 );
 function d(r, l) {
   const o = new Date(r);
@@ -169,7 +169,7 @@ const u = () => /* @__PURE__ */ a(
     }
   ], [h, w] = C(null);
   return x(() => {
-    import("./index.esm-DbeiBKnb.js").then((n) => w(n.enUS));
+    import("./index.esm-CKK13a1d.js").then((n) => w(n.enUS));
   }, []), h ? /* @__PURE__ */ e(t, { h: 700, w: "100%", direction: "column", children: /* @__PURE__ */ e(z, { children: /* @__PURE__ */ e(
     R,
     {

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

@@ -3,6 +3,7 @@ interface ColorCircleProps extends Omit<ColorSwatchProps, 'color'>, Omit<React.C
     value?: string | null;
     isActive?: boolean;
 }
+export declare const ColorCircle: import('react').ForwardRefExoticComponent<ColorCircleProps & import('react').RefAttributes<HTMLDivElement>>;
 export declare const ColorPicker: import('react').ForwardRefExoticComponent<{
     value?: string | null;
     onChange?: (v: string) => void;

package/dist/components/table/FrontTable.d.ts

@@ -0,0 +1,35 @@
+export declare const FrontTable: import('react').NamedExoticComponent<unknown> & {
+    readonly type: () => import("react/jsx-runtime").JSX.Element;
+} & {
+    Header: import('@emotion/styled').StyledComponent<{
+        theme?: import('@emotion/react').Theme;
+        as?: React.ElementType;
+    }, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+    Title: import('@emotion/styled').StyledComponent<{
+        theme?: import('@emotion/react').Theme;
+        as?: React.ElementType;
+    }, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+    Desc: import('@emotion/styled').StyledComponent<{
+        theme?: import('@emotion/react').Theme;
+        as?: React.ElementType;
+    }, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+    Pagination: import('react').MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;
+    Search: import('react').MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;
+    Root: import('@emotion/styled').StyledComponent<{
+        theme?: import('@emotion/react').Theme;
+        as?: React.ElementType;
+    }, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+    Provider: <ITEM extends import('./types').TableRowModel>({ children, store, rows, columns, loading, pageSizeOptions, rowHeight, headerHeight, rowCount, exportFileName, pagination, virtualization, searching, selection, sorting, expanding, }: import('react').PropsWithChildren<{
+        store: import('./store').CreateTableReturn;
+    } & import('./types').TableProps<ITEM>>) => import("react/jsx-runtime").JSX.Element;
+    Menu: import('react').MemoExoticComponent<({ onExport, isLoading, }: {
+        onExport?: (format: "csv" | "xlsx") => void;
+        isLoading?: boolean;
+    }) => import("react/jsx-runtime").JSX.Element>;
+};
+export * from './hooks/useCreateTable';
+export * from './hooks/useSaveRowCount';
+export * from './types';
+export * from './helpers/columns';
+export * from './components/TableSearch';
+export * from './components/TablePagination';

package/dist/components/table/api.d.ts

@@ -0,0 +1,33 @@
+import { TableFilterRow, UseStore } from './store';
+import { TableSortModel } from './types';
+export type TableAPI = ReturnType<typeof createApi>;
+export declare const createApi: (store: UseStore) => {
+    setPageSize: (v: number) => void;
+    setPage: (v: number) => void;
+    setSort: (v: TableSortModel | null) => void;
+    downloadCSV: () => void;
+    downloadExcel: () => void;
+    setSelected: (selected: string[]) => void;
+    toggleColumn: (v: string) => void;
+    setVisibleColumns: (v: string[]) => void;
+    setSearch: (v: string) => void;
+    setPrevPage: () => void;
+    setNextPage: () => void;
+    setColumnWidth: (field: string, setWidth: number) => void;
+    toggleRowExpand: (id: string) => void;
+    setHeaderWidth: (id: string, width: number) => void;
+    setRootRef: (rootRef: HTMLDivElement) => void;
+    setScrollRef: (scrollRef: HTMLDivElement) => void;
+    calculateColumnWidths: (clear?: boolean) => void;
+    selectVisibleRows: () => void;
+    unselectVisibleRows: () => void;
+    unselectRow: (id: string) => void;
+    selectRow: (id: string) => void;
+    addFilterRow: (field?: string) => void;
+    removeFilterRow: (id: string) => void;
+    changeFilterRow: ({ id, ...newRow }: Pick<TableFilterRow, "id"> & Partial<Omit<TableFilterRow, "id">>) => void;
+    setFilterCombiner: (combiner: "and" | "or") => void;
+    clearFilter: () => void;
+    setAutosize: () => void;
+    removeAutosize: () => void;
+};

package/dist/components/table/components/Table.d.ts

@@ -0,0 +1 @@
+export declare const Table: import('react').MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;

package/dist/components/table/components/TableAggregation.d.ts

@@ -0,0 +1 @@
+export declare const TableAggregation: () => import("react/jsx-runtime").JSX.Element | null;

package/dist/components/table/components/TableCell.d.ts

@@ -0,0 +1,11 @@
+import { TableColumnDef, TableRowModel } from '../types';
+interface TableCellProps {
+    column: TableColumnDef;
+    row: TableRowModel;
+}
+export declare const TableCell: import('react').MemoExoticComponent<({ column, row }: TableCellProps) => import("react/jsx-runtime").JSX.Element>;
+export declare const CellRoot: import('@emotion/styled').StyledComponent<{
+    theme?: import('@emotion/react').Theme;
+    as?: React.ElementType;
+}, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export {};

package/dist/components/table/components/TableHeaderCell.d.ts

@@ -0,0 +1,17 @@
+import { CSSProperties } from 'react';
+import { TableColumnDef, TableSortModel } from '../types';
+interface TableHeaderCellProps {
+    column: TableColumnDef;
+    sort?: TableSortModel | null;
+    style?: CSSProperties;
+}
+export declare const TableHeaderCell: ({ column, sort, style, }: TableHeaderCellProps) => import("react/jsx-runtime").JSX.Element;
+export declare const HeaderCellRoot: import('@emotion/styled').StyledComponent<{
+    theme?: import('@emotion/react').Theme;
+    as?: React.ElementType;
+}, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const HeaderCellContent: import('@emotion/styled').StyledComponent<{
+    theme?: import('@emotion/react').Theme;
+    as?: React.ElementType;
+}, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export {};

package/dist/components/table/components/TableHeaders.d.ts

@@ -0,0 +1 @@
+export declare const TableHeaders: import('react').MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;

package/dist/components/table/components/TableMenu.d.ts

@@ -0,0 +1,4 @@
+export declare const TableMenu: import('react').MemoExoticComponent<({ onExport, isLoading, }: {
+    onExport?: (format: "csv" | "xlsx") => void;
+    isLoading?: boolean;
+}) => import("react/jsx-runtime").JSX.Element>;

package/dist/components/table/components/TablePagination.d.ts

@@ -0,0 +1 @@
+export declare const TablePagination: import('react').MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;

package/dist/components/table/components/TablePanel.d.ts

@@ -0,0 +1 @@
+export declare const TablePanel: import('react').MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element | null>;

package/dist/components/table/components/TableRow.d.ts

@@ -0,0 +1,15 @@
+import { calculatePanelData } from '../selectors';
+import { RowMeta, TableRowModel } from '../types';
+interface TableRowProps {
+    start: number;
+    row: TableRowModel;
+    selected: string[];
+    meta: Partial<Record<string, RowMeta>>;
+    columns: {
+        left: ReturnType<typeof calculatePanelData>;
+        base: ReturnType<typeof calculatePanelData>;
+        right: ReturnType<typeof calculatePanelData>;
+    };
+}
+export declare const TableRow: import('react').MemoExoticComponent<({ row, meta, columns, selected, start }: TableRowProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/components/table/components/TableRows.d.ts

@@ -0,0 +1,15 @@
+import { calculatePanelData } from '../selectors';
+import { RowMeta, TableRowModel } from '../types';
+type RenderRowsProps = {
+    rows: TableRowModel[];
+    meta: Partial<Record<string, RowMeta>>;
+    selected: string[];
+    virtual?: boolean;
+    columns: {
+        left: ReturnType<typeof calculatePanelData>;
+        base: ReturnType<typeof calculatePanelData>;
+        right: ReturnType<typeof calculatePanelData>;
+    };
+};
+export declare const TableRows: import('react').MemoExoticComponent<({ rows, meta, columns, selected, virtual }: RenderRowsProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/components/table/components/TableSearch.d.ts

@@ -0,0 +1 @@
+export declare const TableSearch: import('react').MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;

package/dist/components/table/components/TableSkeleton.d.ts

@@ -0,0 +1,11 @@
+import { calculatePanelData } from '../selectors';
+type TableSkeletonProps = {
+    count: number;
+    columns: {
+        left: ReturnType<typeof calculatePanelData>;
+        base: ReturnType<typeof calculatePanelData>;
+        right: ReturnType<typeof calculatePanelData>;
+    };
+};
+export declare const TableSkeleton: import('react').MemoExoticComponent<({ count, columns }: TableSkeletonProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/components/table/components/TableTitle.d.ts

@@ -0,0 +1,16 @@
+export declare const TableTitle: import('@emotion/styled').StyledComponent<{
+    theme?: import('@emotion/react').Theme;
+    as?: React.ElementType;
+}, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const TableHeader: import('@emotion/styled').StyledComponent<{
+    theme?: import('@emotion/react').Theme;
+    as?: React.ElementType;
+}, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const TableRoot: import('@emotion/styled').StyledComponent<{
+    theme?: import('@emotion/react').Theme;
+    as?: React.ElementType;
+}, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const TableDesc: import('@emotion/styled').StyledComponent<{
+    theme?: import('@emotion/react').Theme;
+    as?: React.ElementType;
+}, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

package/dist/components/table/constants.d.ts

@@ -0,0 +1,25 @@
+export declare const TABLE_ATTRIBUTES: {
+    readonly ROW: "data-row";
+    readonly CELL: "data-cell";
+    readonly ROOT: "data-root";
+    readonly COLUMN_ALIGN: "data-al";
+    readonly SCROLLED: "data-scrolled";
+    readonly SORTABLE: "data-sortable";
+    readonly RESIZER: "data-resizer";
+    readonly RESIZER_SIDE: "data-side";
+    readonly ROW_SELECTED: "data-sel";
+    readonly ROW_CHILD: "data-child";
+    readonly SORTED: "data-sorted";
+    readonly HEADER_CELL: "data-header";
+    readonly INNER: "data-inner";
+    readonly AUTOSIZE: "data-autosize";
+    readonly PANEL_SIDE: "data-side";
+    readonly HEADER_GRID: "data-header-grid";
+    readonly VIRTUAL_CONTAINER: "data-virtual";
+    readonly BASE: "data-base";
+    readonly HEADERS: "data-headers";
+    readonly HEADER_GROUP: "data-header-group";
+};
+export declare const SELECT_COLUMN_FIELD = "__checkbox__";
+export declare const EXPAND_COLUMN_FIELD = "__expand__";
+export declare const TABLE_AGGREGATION_ROW_ID = "__aggregation__";

package/dist/components/table/export.d.ts

@@ -0,0 +1,9 @@
+import { TableColumnDef, TableRowModel } from './types';
+type ExportProps<T extends TableRowModel> = {
+    rows: T[];
+    columns: TableColumnDef<T>[];
+    fileName: string;
+};
+export declare const exportToExcel: <T extends TableRowModel>({ rows, columns, fileName, }: ExportProps<T>) => Promise<void>;
+export declare const exportToCSV: <T extends TableRowModel>({ rows, columns, fileName, }: ExportProps<T>) => Promise<void>;
+export {};

package/dist/components/table/helpers/columns.d.ts

@@ -0,0 +1,35 @@
+import { CSSProperties } from 'react';
+import { TableAPI } from '../api';
+import { DateColumnProps, TableColumnDef, TableColumnGroupDef, TableColumnPin, TableColumnState, TableColumnsProp, TableRowModel } from '../types';
+import { Numbers } from './formatters';
+export declare const getDateColumn: (props?: DateColumnProps) => Partial<TableColumnDef>;
+export declare const getNumberColumn: (props?: Numbers.FormatterProps) => Partial<TableColumnDef>;
+export declare const getRatioColumn: (props?: Numbers.FormatterProps) => Partial<TableColumnDef>;
+export declare const getPercentColumn: (props?: Omit<Numbers.FormatterProps, "value">) => Partial<TableColumnDef>;
+export declare const getCurrencyColumn: (props?: Omit<Numbers.FormatterProps, "value">) => Partial<TableColumnDef>;
+export declare const getColumnId: (str: string) => string;
+export declare const getColumnsProps: <T extends TableRowModel>(type: TableColumnDef<T>["type"]) => Partial<TableColumnDef>;
+export declare const isColumnGroup: <T extends TableRowModel>(v: TableColumnsProp<T>[number]) => v is TableColumnGroupDef<T>;
+export declare const isTechnicalColumn: <T extends TableRowModel, COL extends TableColumnDef<T>>(col: COL) => boolean;
+export declare const getLeafColumns: <T extends TableRowModel, COL extends TableColumnDef<T>>(items: TableColumnsProp<T, COL>) => COL[];
+export declare function getMaxDepth(columns: TableColumnsProp, depth?: number): number;
+export declare function buildColumnMap(columns: TableColumnsProp): Record<string, TableColumnsProp[number]>;
+export type GridAreaMap = Record<string, string>;
+export declare function computeGridAreas(columns: TableColumnsProp, maxDepth: number): GridAreaMap;
+export declare function filterPinnedColumns(columns: TableColumnsProp, pinnedSide?: TableColumnPin): TableColumnsProp;
+export declare function mapColumnsRecursive<ITEM extends TableRowModel, COL extends TableColumnDef<ITEM>>(columns: TableColumnsProp<ITEM, COL>, transform: (col: TableColumnsProp[number] | TableColumnsProp<ITEM, COL>[number]) => TableColumnsProp<ITEM, COL>[number]): (COL | TableColumnGroupDef<ITEM, COL>)[];
+export declare const mergeColumn: (current: TableColumnDef, update?: Partial<TableColumnState>) => TableColumnState;
+export declare function filterVisibleColumns(columns: TableColumnsProp): TableColumnsProp;
+export declare const getHeaderStyles: (columns: TableColumnDef[]) => CSSProperties;
+export declare const getExpandingColumn: ({ expanded, api, pinned, }: {
+    expanded: string[];
+    api: TableAPI;
+    pinned: boolean;
+}) => TableColumnState;
+export declare const getSelectionColumn: ({ selected, api, pinned, }: {
+    selected: string[];
+    api: TableAPI;
+    pinned: boolean;
+}) => TableColumnState;
+export declare const getAggregationColumns: (columns: TableColumnDef[], aggregatedRow: TableRowModel, rows: TableRowModel[]) => TableColumnDef[];
+export declare const getAggregateValue: (column: TableColumnDef, rows: TableRowModel[]) => number | null;

package/dist/components/table/helpers/filter.d.ts

@@ -0,0 +1,52 @@
+import { TableColumnType } from '../types';
+export type TableFilterValue = Date | string | number | boolean | null | undefined;
+export type TableFilterComparisonFunction = (a: TableFilterValue, b: TableFilterValue) => boolean;
+export interface TableFilterComparisonOption {
+    value: string;
+    label: string;
+    function: TableFilterComparisonFunction;
+}
+export type TableFilterSettings = {
+    default: TableFilterComparisonOption;
+    options: TableFilterComparisonOption[];
+    formatter: (value: TableFilterValue) => string;
+};
+export declare const dateComparisonSettings: {
+    readonly is: {
+        readonly label: "is";
+        readonly function: (a: Date | null, b: Date | null) => boolean;
+    };
+    readonly isNot: {
+        readonly label: "is not";
+        readonly function: (a: Date | null, b: Date | null) => boolean;
+    };
+    readonly isAfter: {
+        readonly label: "is after";
+        readonly function: (a: Date | null, b: Date | null) => boolean;
+    };
+    readonly isOnOrAfter: {
+        readonly label: "is on or after";
+        readonly function: (a: Date | null, b: Date | null) => boolean;
+    };
+    readonly isBefore: {
+        readonly label: "is before";
+        readonly function: (a: Date | null, b: Date | null) => boolean;
+    };
+    readonly isOnOrBefore: {
+        readonly label: "is on or before";
+        readonly function: (a: Date | null, b: Date | null) => boolean;
+    };
+    readonly isEmpty: {
+        readonly label: "is empty";
+        readonly function: (a: Date | null) => a is null;
+    };
+    readonly isNotEmpty: {
+        readonly label: "is not empty";
+        readonly function: (a: Date | null) => a is Date;
+    };
+};
+export declare const dateComparativeOptions: {
+    value: string;
+    label: "is" | "is not empty" | "is not" | "is empty" | "is after" | "is on or after" | "is before" | "is on or before";
+}[];
+export declare const getTableFilterSettings: (columnType?: TableColumnType) => TableFilterSettings;

package/dist/components/table/helpers/formatters.d.ts

@@ -0,0 +1,76 @@
+/**
+ * A namespace containing utility functions for number parsing, validation, and formatting
+ */
+export declare namespace Numbers {
+    type AcceptableValue = number | string | null | undefined;
+    /**
+     * Parses a value into a number, handling various input types
+     * @param value - The value to parse (can be number, string, or null/undefined)
+     * @returns The parsed number or NaN if parsing fails
+     */
+    const parse: (value: AcceptableValue) => number;
+    /**
+     * Checks if a value is a positive number
+     * @param value - The value to check
+     * @returns True if the value is a positive number, false otherwise
+     */
+    const isPositive: (value: AcceptableValue) => boolean;
+    /**
+     * Checks if a value is a negative number
+     * @param v - The value to check
+     * @returns True if the value is a negative number, false otherwise
+     */
+    const isNegative: (value: AcceptableValue) => boolean;
+    const getDynamic: (v: AcceptableValue, invert?: boolean) => DynamicType | null;
+    /**
+     * Checks if a value is a valid number
+     * @param v - The value to check
+     * @returns True if the value is a valid number, false otherwise
+     */
+    const isNumber: (value: AcceptableValue) => value is number;
+    /**
+     * Type definition for number formatting styles
+     */
+    type NumberType = 'number' | 'percent' | 'currency';
+    /**
+     * Configuration options for number formatting
+     */
+    type FormatterProps = Intl.NumberFormatOptions & {
+        /** The locale to use for formatting */
+        locale?: Intl.LocalesArgument;
+        /** Whether to force decimal places */
+        decimal?: boolean;
+        /** The value to return when formatting fails */
+        invalidValue?: string;
+        /** Whether to divide the value by 100 */
+        divide?: boolean;
+        /** Whether to use short formatting */
+        short?: boolean;
+    };
+    /**
+     * Formats a number according to the specified options
+     * @param v - The value to format
+     * @param _options
+     * @returns The formatted string or the invalidValue if formatting fails
+     */
+    const format: (v: AcceptableValue, _options?: FormatterProps) => string;
+    /**
+     * Formats a number as currency
+     * @param v - The value to format
+     * @param options - Formatting options including locale and currency
+     * @returns The formatted currency string
+     */
+    const formatCurrency: (v: AcceptableValue, options?: FormatterProps) => string;
+    /**
+     * Formats a number as a percentage
+     * @param v - The value to format
+     * @param options - Formatting options including locale
+     * @returns The formatted percentage string
+     */
+    const formatPercents: (v: AcceptableValue, options?: FormatterProps) => string;
+    const dynamicTypesList: readonly ["positive", "negative", "neutral"];
+    type DynamicType = (typeof dynamicTypesList)[number];
+    const round: (value: string | number, exp?: number, type?: "round" | "floor" | "ceil") => number;
+    const formatByType: (type: NumberType, v: AcceptableValue, options?: FormatterProps) => string;
+    const getCurrencySymbol: (currency: Intl.NumberFormatOptions["currency"], locale?: Intl.LocalesArgument) => string;
+}

package/dist/components/table/hooks/TableProvider.d.ts

@@ -0,0 +1,59 @@
+import { PropsWithChildren } from 'react';
+import { CreateTableReturn } from '../store';
+import { TableProps, TableRowModel } from '../types';
+export declare const TableContext: import('react').Context<{
+    useStore: import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<import('../store').Store>, "persist"> & {
+        persist: {
+            setOptions: (options: Partial<import('zustand/middleware').PersistOptions<import('../store').Store, {
+                page: number;
+                sort: import('../types').TableSortModel | null;
+                search: string;
+                pageSize: number;
+            }>>) => void;
+            clearStorage: () => void;
+            rehydrate: () => Promise<void> | void;
+            hasHydrated: () => boolean;
+            onHydrate: (fn: (state: import('../store').Store) => void) => () => void;
+            onFinishHydration: (fn: (state: import('../store').Store) => void) => () => void;
+            getOptions: () => Partial<import('zustand/middleware').PersistOptions<import('../store').Store, {
+                page: number;
+                sort: import('../types').TableSortModel | null;
+                search: string;
+                pageSize: number;
+            }>>;
+        };
+    }>;
+    api: {
+        setPageSize: (v: number) => void;
+        setPage: (v: number) => void;
+        setSort: (v: import('../types').TableSortModel | null) => void;
+        downloadCSV: () => void;
+        downloadExcel: () => void;
+        setSelected: (selected: string[]) => void;
+        toggleColumn: (v: string) => void;
+        setVisibleColumns: (v: string[]) => void;
+        setSearch: (v: string) => void;
+        setPrevPage: () => void;
+        setNextPage: () => void;
+        setColumnWidth: (field: string, setWidth: number) => void;
+        toggleRowExpand: (id: string) => void;
+        setHeaderWidth: (id: string, width: number) => void;
+        setRootRef: (rootRef: HTMLDivElement) => void;
+        setScrollRef: (scrollRef: HTMLDivElement) => void;
+        calculateColumnWidths: (clear?: boolean) => void;
+        selectVisibleRows: () => void;
+        unselectVisibleRows: () => void;
+        unselectRow: (id: string) => void;
+        selectRow: (id: string) => void;
+        addFilterRow: (field?: string) => void;
+        removeFilterRow: (id: string) => void;
+        changeFilterRow: ({ id, ...newRow }: Pick<import('../store').TableFilterRow, "id"> & Partial<Omit<import('../store').TableFilterRow, "id">>) => void;
+        setFilterCombiner: (combiner: "and" | "or") => void;
+        clearFilter: () => void;
+        setAutosize: () => void;
+        removeAutosize: () => void;
+    };
+}>;
+export declare const TableProvider: <ITEM extends TableRowModel>({ children, store, rows, columns, loading, pageSizeOptions, rowHeight, headerHeight, rowCount, exportFileName, pagination, virtualization, searching, selection, sorting, expanding, }: PropsWithChildren<{
+    store: CreateTableReturn;
+} & TableProps<ITEM>>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/table/hooks/useColumnsResizing.d.ts

@@ -0,0 +1,5 @@
+import { MutableRefObject } from 'react';
+export declare const useColumnsResizing: (resizing: MutableRefObject<boolean>) => {
+    onPointerDown: (...args: any) => any;
+    onDragStart: import('react').DragEventHandler;
+};

package/dist/components/table/hooks/useCreateTable.d.ts

@@ -0,0 +1,54 @@
+import { CreateTableStoreProps } from '../store';
+export declare const useCreateTable: (props?: CreateTableStoreProps) => {
+    useStore: import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<import('../store').Store>, "persist"> & {
+        persist: {
+            setOptions: (options: Partial<import('zustand/middleware').PersistOptions<import('../store').Store, {
+                page: number;
+                sort: import('../types').TableSortModel | null;
+                search: string;
+                pageSize: number;
+            }>>) => void;
+            clearStorage: () => void;
+            rehydrate: () => Promise<void> | void;
+            hasHydrated: () => boolean;
+            onHydrate: (fn: (state: import('../store').Store) => void) => () => void;
+            onFinishHydration: (fn: (state: import('../store').Store) => void) => () => void;
+            getOptions: () => Partial<import('zustand/middleware').PersistOptions<import('../store').Store, {
+                page: number;
+                sort: import('../types').TableSortModel | null;
+                search: string;
+                pageSize: number;
+            }>>;
+        };
+    }>;
+    api: {
+        setPageSize: (v: number) => void;
+        setPage: (v: number) => void;
+        setSort: (v: import('../types').TableSortModel | null) => void;
+        downloadCSV: () => void;
+        downloadExcel: () => void;
+        setSelected: (selected: string[]) => void;
+        toggleColumn: (v: string) => void;
+        setVisibleColumns: (v: string[]) => void;
+        setSearch: (v: string) => void;
+        setPrevPage: () => void;
+        setNextPage: () => void;
+        setColumnWidth: (field: string, setWidth: number) => void;
+        toggleRowExpand: (id: string) => void;
+        setHeaderWidth: (id: string, width: number) => void;
+        setRootRef: (rootRef: HTMLDivElement) => void;
+        setScrollRef: (scrollRef: HTMLDivElement) => void;
+        calculateColumnWidths: (clear?: boolean) => void;
+        selectVisibleRows: () => void;
+        unselectVisibleRows: () => void;
+        unselectRow: (id: string) => void;
+        selectRow: (id: string) => void;
+        addFilterRow: (field?: string) => void;
+        removeFilterRow: (id: string) => void;
+        changeFilterRow: ({ id, ...newRow }: Pick<import('../store').TableFilterRow, "id"> & Partial<Omit<import('../store').TableFilterRow, "id">>) => void;
+        setFilterCombiner: (combiner: "and" | "or") => void;
+        clearFilter: () => void;
+        setAutosize: () => void;
+        removeAutosize: () => void;
+    };
+};

package/dist/components/table/hooks/useSaveRowCount.d.ts

@@ -0,0 +1 @@
+export declare const useSaveRowCount: (total?: number) => number;

package/dist/components/table/hooks/useSorting.d.ts

@@ -0,0 +1,2 @@
+import { MouseEventHandler, MutableRefObject } from 'react';
+export declare const useSorting: (resizing: MutableRefObject<boolean>) => MouseEventHandler<HTMLDivElement>;

package/dist/components/table/hooks/useTableStore.d.ts

@@ -0,0 +1,53 @@
+export declare const useTableStore: () => {
+    useStore: import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<import('../store').Store>, "persist"> & {
+        persist: {
+            setOptions: (options: Partial<import('zustand/middleware').PersistOptions<import('../store').Store, {
+                page: number;
+                sort: import('../types').TableSortModel | null;
+                search: string;
+                pageSize: number;
+            }>>) => void;
+            clearStorage: () => void;
+            rehydrate: () => Promise<void> | void;
+            hasHydrated: () => boolean;
+            onHydrate: (fn: (state: import('../store').Store) => void) => () => void;
+            onFinishHydration: (fn: (state: import('../store').Store) => void) => () => void;
+            getOptions: () => Partial<import('zustand/middleware').PersistOptions<import('../store').Store, {
+                page: number;
+                sort: import('../types').TableSortModel | null;
+                search: string;
+                pageSize: number;
+            }>>;
+        };
+    }>;
+    api: {
+        setPageSize: (v: number) => void;
+        setPage: (v: number) => void;
+        setSort: (v: import('../types').TableSortModel | null) => void;
+        downloadCSV: () => void;
+        downloadExcel: () => void;
+        setSelected: (selected: string[]) => void;
+        toggleColumn: (v: string) => void;
+        setVisibleColumns: (v: string[]) => void;
+        setSearch: (v: string) => void;
+        setPrevPage: () => void;
+        setNextPage: () => void;
+        setColumnWidth: (field: string, setWidth: number) => void;
+        toggleRowExpand: (id: string) => void;
+        setHeaderWidth: (id: string, width: number) => void;
+        setRootRef: (rootRef: HTMLDivElement) => void;
+        setScrollRef: (scrollRef: HTMLDivElement) => void;
+        calculateColumnWidths: (clear?: boolean) => void;
+        selectVisibleRows: () => void;
+        unselectVisibleRows: () => void;
+        unselectRow: (id: string) => void;
+        selectRow: (id: string) => void;
+        addFilterRow: (field?: string) => void;
+        removeFilterRow: (id: string) => void;
+        changeFilterRow: ({ id, ...newRow }: Pick<import('../store').TableFilterRow, "id"> & Partial<Omit<import('../store').TableFilterRow, "id">>) => void;
+        setFilterCombiner: (combiner: "and" | "or") => void;
+        clearFilter: () => void;
+        setAutosize: () => void;
+        removeAutosize: () => void;
+    };
+};