@astral/ui 0.21.0 → 0.22.0

package/esm/DataGrid/DataGridBody/DataGridBody.js

@@ -0,0 +1,35 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useMemo } from 'react';
+import { TableCell, TableRow } from '../../Table';
+import { DataGridCell } from '../DataGridCell';
+import { Checkbox } from '../../Checkbox';
+import { StyledTableBody } from './styled';
+export function DataGridBody(_a) {
+    var rows = _a.rows, columns = _a.columns, selectable = _a.selectable, onSelectRow = _a.onSelectRow, _b = _a.selectedRows, selectedRows = _b === void 0 ? [] : _b, minDisplayRows = _a.minDisplayRows, keyId = _a.keyId;
+    var renderCells = useCallback(function (row, rowId) {
+        return columns.map(function (cell, index) {
+            var cellId = "".concat(rowId, "-").concat(index);
+            return _jsx(DataGridCell, { row: row, cell: cell }, cellId);
+        });
+    }, [columns]);
+    var renderedRows = useMemo(function () {
+        return rows.map(function (row) {
+            var rowId = row[keyId];
+            var checked = selectable &&
+                Boolean(selectedRows.find(function (selectedRow) { return selectedRow[keyId] === rowId; }));
+            return (_jsxs(TableRow, { children: [selectable && (_jsx(TableCell, __assign({ padding: "checkbox" }, { children: _jsx(Checkbox, { checked: checked, onChange: onSelectRow(row) }, void 0) }), void 0)), renderCells(row, rowId)] }, rowId));
+        });
+    }, [rows, keyId, selectable, selectedRows, onSelectRow, columns]);
+    return (_jsx(StyledTableBody, __assign({ empty: !rows.length, minDisplayRows: minDisplayRows }, { children: renderedRows }), void 0));
+}

package/esm/DataGrid/DataGridBody/index.d.ts

@@ -0,0 +1 @@
+export * from './DataGridBody';

package/esm/DataGrid/DataGridBody/index.js

@@ -0,0 +1 @@
+export * from './DataGridBody';

package/esm/DataGrid/DataGridBody/styled.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+export declare const StyledTableBody: import("@emotion/styled").StyledComponent<{
+    children?: import("react").ReactNode;
+    classes?: Partial<import("@mui/material").TableBodyClasses> | undefined;
+    sx?: import("@mui/system").SxProps<import("@mui/material").Theme> | undefined;
+} & import("@mui/material/OverridableComponent").CommonProps & Omit<Pick<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, "key" | keyof import("react").HTMLAttributes<HTMLTableSectionElement>> & {
+    ref?: ((instance: HTMLTableSectionElement | null) => void) | import("react").RefObject<HTMLTableSectionElement> | null | undefined;
+}, keyof import("@mui/material/OverridableComponent").CommonProps | "children" | "sx"> & {
+    theme?: import("@emotion/react").Theme | undefined;
+} & {
+    empty: boolean;
+    minDisplayRows: number;
+}, {}, {}>;

package/esm/DataGrid/DataGridBody/styled.js

@@ -0,0 +1,14 @@
+var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {
+    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+    return cooked;
+};
+import { styled } from '../../styles';
+import { TableBody } from '../../Table';
+var TABLE_ROW_HEIGHT = 44;
+export var StyledTableBody = styled(TableBody, {
+    shouldForwardProp: function (prop) { return prop !== 'empty' && prop !== 'minDisplayRows'; },
+})(templateObject_1 || (templateObject_1 = __makeTemplateObject(["\n  height: ", ";\n"], ["\n  height: ", ";\n"])), function (_a) {
+    var empty = _a.empty, minDisplayRows = _a.minDisplayRows;
+    return empty ? "".concat(TABLE_ROW_HEIGHT * minDisplayRows, "px") : 'auto';
+});
+var templateObject_1;

package/esm/DataGrid/DataGridBody/types.d.ts

@@ -0,0 +1,11 @@
+import { ChangeEvent } from 'react';
+import { DataGridColumns, DataGridRow } from '../types';
+export declare type DataGridBodyProps<T = DataGridRow> = {
+    columns: DataGridColumns<T>[];
+    keyId: keyof DataGridRow;
+    selectable?: boolean;
+    selectedRows?: Array<T>;
+    rows: T[];
+    onSelectRow: (row: T) => (event: ChangeEvent<HTMLInputElement>) => void;
+    minDisplayRows: number;
+};

package/esm/DataGrid/DataGridBody/types.js

@@ -0,0 +1 @@
+export {};

package/esm/DataGrid/DataGridCell/DataGridCell.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { CellProps } from './types';
+export declare function DataGridCell<T>({ row, cell: { field, renderCell, format, align }, }: CellProps<T>): JSX.Element;

package/esm/DataGrid/DataGridCell/DataGridCell.js

@@ -0,0 +1,25 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { TableCell } from '../../Table';
+import { Typography } from '../../Typography';
+export function DataGridCell(_a) {
+    var row = _a.row, _b = _a.cell, field = _b.field, renderCell = _b.renderCell, format = _b.format, _c = _b.align, align = _c === void 0 ? 'left' : _c;
+    var formattedValue = useMemo(function () {
+        if (format) {
+            return format(row);
+        }
+        return row[field];
+    }, [field, format, row]);
+    return (_jsxs(TableCell, __assign({ align: align }, { children: [renderCell && renderCell(row), !renderCell && _jsx(Typography, { children: formattedValue }, void 0)] }), void 0));
+}

package/esm/DataGrid/DataGridCell/index.d.ts

@@ -0,0 +1 @@
+export * from './DataGridCell';

package/esm/DataGrid/DataGridCell/index.js

@@ -0,0 +1 @@
+export * from './DataGridCell';

package/esm/DataGrid/DataGridCell/types.d.ts

@@ -0,0 +1,5 @@
+import { DataGridColumns } from '../types';
+export declare type CellProps<T> = {
+    row: T;
+    cell: DataGridColumns<T>;
+};

package/esm/DataGrid/DataGridCell/types.js

@@ -0,0 +1 @@
+export {};

package/esm/DataGrid/DataGridHead/DataGridHead.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { DataGridHeadProps } from './types';
+export declare function DataGridHead<T>({ columns, selectable, onSelectAllRows, rowsCount, onSort, sorting, uncheckedRowsCount, }: DataGridHeadProps<T>): JSX.Element;

package/esm/DataGrid/DataGridHead/DataGridHead.js

@@ -0,0 +1,67 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useMemo } from 'react';
+import { TableHead } from '../../Table/TableHead';
+import { TableCell, TableRow } from '../../Table';
+import { Checkbox } from '../../Checkbox';
+import { SortStates } from '../constants';
+import { DataGridHeadColumn } from '../DataGridHeadColumn';
+export function DataGridHead(_a) {
+    var columns = _a.columns, selectable = _a.selectable, onSelectAllRows = _a.onSelectAllRows, rowsCount = _a.rowsCount, onSort = _a.onSort, _b = _a.sorting, sorting = _b === void 0 ? [] : _b, uncheckedRowsCount = _a.uncheckedRowsCount;
+    var checked = useMemo(function () { return !Boolean(uncheckedRowsCount) && rowsCount > 0; }, [uncheckedRowsCount, rowsCount]);
+    var indeterminate = useMemo(function () { return uncheckedRowsCount > 0 && uncheckedRowsCount < rowsCount; }, [uncheckedRowsCount, rowsCount]);
+    var handleSort = useCallback(function (field, sortable) { return function () {
+        if (sortable) {
+            var currentSort = sorting.find(function (_a) {
+                var fieldId = _a.fieldId;
+                return fieldId === field;
+            });
+            // если для выбранного столбца текущая сортировка ASC - меняем на DESC
+            if (currentSort && currentSort.sort === SortStates.ASC) {
+                var newSorting = __spreadArray(__spreadArray([], sorting.filter(function (_a) {
+                    var fieldId = _a.fieldId;
+                    return fieldId !== field;
+                }), true), [
+                    { fieldId: field, sort: SortStates.DESC },
+                ], false);
+                return onSort(newSorting);
+                // если для выбранного столбца текущая сортировка DESC - убираем сортировку
+            }
+            else if (currentSort && currentSort.sort === SortStates.DESC) {
+                var newSorting = sorting.filter(function (_a) {
+                    var fieldId = _a.fieldId;
+                    return fieldId !== field;
+                });
+                return onSort(newSorting);
+            }
+            // если для выбранного столбца нет сортировки - добавляем сортировку ASC
+            onSort(__spreadArray(__spreadArray([], sorting, true), [{ fieldId: field, sort: SortStates.ASC }], false));
+        }
+    }; }, [sorting]);
+    var renderColumns = useMemo(function () {
+        return columns.map(function (_a) {
+            var field = _a.field, label = _a.label, sortable = _a.sortable, align = _a.align, renderCell = _a.renderCell;
+            return (_jsx(DataGridHeadColumn, { sorting: sorting, renderCell: renderCell, field: field, onSort: handleSort, label: label, sortable: sortable, align: align }, void 0));
+        });
+    }, [columns, handleSort, sorting]);
+    return (_jsx(TableHead, { children: _jsxs(TableRow, { children: [selectable && (_jsx(TableCell, __assign({ padding: "checkbox" }, { children: _jsx(Checkbox, { checked: checked, indeterminate: indeterminate, onChange: onSelectAllRows }, void 0) }), void 0)), renderColumns] }, void 0) }, void 0));
+}

package/esm/DataGrid/DataGridHead/index.d.ts

@@ -0,0 +1,2 @@
+export * from './DataGridHead';
+export * from './types';

package/esm/DataGrid/DataGridHead/index.js

@@ -0,0 +1,2 @@
+export * from './DataGridHead';
+export * from './types';

package/esm/DataGrid/DataGridHead/types.d.ts

@@ -0,0 +1,11 @@
+import { ChangeEvent } from 'react';
+import { DataGridColumns, DataGridRow, DataGridSort } from '../types';
+export declare type DataGridHeadProps<T = DataGridRow> = {
+    columns: DataGridColumns<T>[];
+    selectable: boolean;
+    onSelectAllRows: (event: ChangeEvent<HTMLInputElement>) => void;
+    sorting: DataGridSort<T>[];
+    onSort: (sorting: DataGridSort<T>[]) => void;
+    uncheckedRowsCount: number;
+    rowsCount: number;
+};

package/esm/DataGrid/DataGridHead/types.js

@@ -0,0 +1 @@
+export {};

package/esm/DataGrid/DataGridHeadColumn/DataGridHeadColumn.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { DataGridHeadColumnProps } from './types';
+export declare function DataGridHeadColumn<T>({ onSort, field, sortable, align, label, sorting, renderCell, }: DataGridHeadColumnProps<T>): JSX.Element;

package/esm/DataGrid/DataGridHeadColumn/DataGridHeadColumn.js

@@ -0,0 +1,26 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Typography } from '../../Typography/Typography';
+import { SortStates } from '../constants';
+import { StyledTableCell, StyledTableSortLabel } from './styled';
+export function DataGridHeadColumn(_a) {
+    var onSort = _a.onSort, field = _a.field, sortable = _a.sortable, align = _a.align, label = _a.label, sorting = _a.sorting, renderCell = _a.renderCell;
+    var sortParams = sorting.find(function (_a) {
+        var fieldId = _a.fieldId;
+        return field === fieldId;
+    });
+    var hideSortIcon = !Boolean(sortParams);
+    var sortDirection = sortParams ? sortParams.sort : SortStates.ASC;
+    var fitContent = Boolean(renderCell);
+    return (_jsxs(StyledTableCell, __assign({ onClick: onSort(field, sortable), fitContent: fitContent, align: align }, { children: [_jsx(Typography, __assign({ variant: "pointer" }, { children: label }), void 0), sortable && (_jsx(StyledTableSortLabel, { hideSortIcon: hideSortIcon, direction: sortDirection, active: true }, void 0))] }), void 0));
+}

package/esm/DataGrid/DataGridHeadColumn/index.d.ts

@@ -0,0 +1,2 @@
+export * from './DataGridHeadColumn';
+export * from './types';

package/esm/DataGrid/DataGridHeadColumn/index.js

@@ -0,0 +1,2 @@
+export * from './DataGridHeadColumn';
+export * from './types';

package/esm/DataGrid/DataGridHeadColumn/styled.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="react" />
+import { TableCellProps } from '@mui/material';
+export declare const StyledTableSortLabel: import("@emotion/styled").StyledComponent<{
+    active?: boolean | undefined;
+    children?: import("react").ReactNode;
+    classes?: Partial<import("@mui/material").TableSortLabelClasses> | undefined;
+    direction?: "desc" | "asc" | undefined;
+    hideSortIcon?: boolean | undefined;
+    IconComponent?: import("react").JSXElementConstructor<{
+        className: string;
+    }> | undefined;
+    sx?: import("@mui/material").SxProps<import("@mui/material").Theme> | undefined;
+} & Omit<{
+    action?: import("react").Ref<import("@mui/material").ButtonBaseActions> | undefined;
+    centerRipple?: boolean | undefined;
+    children?: import("react").ReactNode;
+    classes?: Partial<import("@mui/material").ButtonBaseClasses> | undefined;
+    disabled?: boolean | undefined;
+    disableRipple?: boolean | undefined;
+    disableTouchRipple?: boolean | undefined;
+    focusRipple?: boolean | undefined;
+    focusVisibleClassName?: string | undefined;
+    LinkComponent?: import("react").ElementType<any> | undefined;
+    onFocusVisible?: import("react").FocusEventHandler<any> | undefined;
+    sx?: import("@mui/material").SxProps<import("@mui/material").Theme> | undefined;
+    tabIndex?: number | undefined;
+    TouchRippleProps?: Partial<import("@mui/material/ButtonBase/TouchRipple").TouchRippleProps> | undefined;
+    touchRippleRef?: import("react").Ref<import("@mui/material/ButtonBase/TouchRipple").TouchRippleActions> | undefined;
+}, "classes"> & import("@mui/material/OverridableComponent").CommonProps & Omit<Pick<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "key" | keyof import("react").HTMLAttributes<HTMLSpanElement>> & {
+    ref?: ((instance: HTMLSpanElement | null) => void) | import("react").RefObject<HTMLSpanElement> | null | undefined;
+}, keyof import("@mui/material/OverridableComponent").CommonProps | "children" | "disabled" | "sx" | "tabIndex" | "direction" | "action" | "active" | "centerRipple" | "disableRipple" | "disableTouchRipple" | "focusRipple" | "focusVisibleClassName" | "LinkComponent" | "onFocusVisible" | "TouchRippleProps" | "touchRippleRef" | "hideSortIcon" | "IconComponent"> & {
+    theme?: import("@emotion/react").Theme | undefined;
+}, {}, {}>;
+export declare const StyledTableCell: import("@emotion/styled").StyledComponent<TableCellProps & {
+    theme?: import("@emotion/react").Theme | undefined;
+} & {
+    fitContent?: boolean | undefined;
+}, {}, {}>;

package/esm/DataGrid/DataGridHeadColumn/styled.js

@@ -0,0 +1,17 @@
+var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {
+    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+    return cooked;
+};
+import { styled } from '../../styles';
+import { TableCell, TableSortLabel } from '../../Table';
+export var StyledTableSortLabel = styled(TableSortLabel)(templateObject_1 || (templateObject_1 = __makeTemplateObject(["\n  visibility: ", ";\n"], ["\n  visibility: ", ";\n"])), function (_a) {
+    var hideSortIcon = _a.hideSortIcon;
+    return hideSortIcon && 'hidden';
+});
+export var StyledTableCell = styled(TableCell, {
+    shouldForwardProp: function (prop) { return prop !== 'fitContent'; },
+})(templateObject_2 || (templateObject_2 = __makeTemplateObject(["\n  width: ", ";\n\n  cursor: pointer;\n\n  user-select: none;\n"], ["\n  width: ", ";\n\n  cursor: pointer;\n\n  user-select: none;\n"])), function (_a) {
+    var fitContent = _a.fitContent;
+    return (fitContent ? '1%' : 'auto');
+});
+var templateObject_1, templateObject_2;

package/esm/DataGrid/DataGridHeadColumn/types.d.ts

@@ -0,0 +1,11 @@
+import { TableCellProps } from '@mui/material';
+import { DataGridSort, RenderCell } from '../types';
+export declare type DataGridHeadColumnProps<T> = {
+    onSort: (field: keyof T, sortable: boolean | undefined) => () => void;
+    sorting: DataGridSort<T>[];
+    renderCell?: RenderCell<T>;
+    label?: string;
+    sortable?: boolean;
+    align?: TableCellProps['align'];
+    field: keyof T;
+};

package/esm/DataGrid/DataGridHeadColumn/types.js

@@ -0,0 +1 @@
+export {};

package/esm/DataGrid/DataGridLoader/DataGridLoader.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { DataGridLoaderProps } from './types';
+declare const DataGridLoader: ({ loading }: DataGridLoaderProps) => JSX.Element;
+export default DataGridLoader;

package/esm/DataGrid/DataGridLoader/DataGridLoader.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Backdrop, LoaderWrapper, StyledDivider, StyledLinearProgress, } from './styled';
+var DataGridLoader = function (_a) {
+    var _b = _a.loading, loading = _b === void 0 ? false : _b;
+    return (_jsxs(LoaderWrapper, { children: [loading && _jsx(Backdrop, {}, void 0), loading ? _jsx(StyledLinearProgress, {}, void 0) : _jsx(StyledDivider, {}, void 0)] }, void 0));
+};
+export default DataGridLoader;

package/esm/DataGrid/DataGridLoader/index.d.ts

@@ -0,0 +1,2 @@
+export * from './styled';
+export * from './types';

package/esm/DataGrid/DataGridLoader/index.js

@@ -0,0 +1,2 @@
+export * from './styled';
+export * from './types';

package/esm/DataGrid/DataGridLoader/styled.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="react" />
+export declare const Backdrop: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const StyledDivider: import("@emotion/styled").StyledComponent<{
+    absolute?: boolean | undefined;
+    children?: import("react").ReactNode;
+    classes?: Partial<import("@mui/material").DividerClasses> | undefined;
+    flexItem?: boolean | undefined;
+    light?: boolean | undefined;
+    orientation?: "horizontal" | "vertical" | undefined;
+    sx?: import("@mui/material").SxProps<import("@mui/material").Theme> | undefined;
+    textAlign?: "left" | "center" | "right" | undefined;
+    variant?: "middle" | "inset" | "fullWidth" | undefined;
+} & import("@mui/material/OverridableComponent").CommonProps & Omit<Pick<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHRElement>, HTMLHRElement>, "key" | keyof import("react").HTMLAttributes<HTMLHRElement>> & {
+    ref?: ((instance: HTMLHRElement | null) => void) | import("react").RefObject<HTMLHRElement> | null | undefined;
+}, keyof import("@mui/material/OverridableComponent").CommonProps | "children" | "sx" | "variant" | "orientation" | "textAlign" | "light" | "absolute" | "flexItem"> & {
+    theme?: import("@emotion/react").Theme | undefined;
+}, {}, {}>;
+export declare const LoaderWrapper: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const StyledLinearProgress: import("@emotion/styled").StyledComponent<import("@mui/material").LinearProgressProps & {
+    theme?: import("@emotion/react").Theme | undefined;
+}, {}, {}>;

package/esm/DataGrid/DataGridLoader/styled.js

@@ -0,0 +1,15 @@
+var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {
+    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+    return cooked;
+};
+import { LinearProgress } from '@mui/material';
+import { Divider } from '../../Divider';
+import { styled } from '../../styles';
+export var Backdrop = styled.div(templateObject_1 || (templateObject_1 = __makeTemplateObject(["\n  position: absolute;\n  top: 0;\n\n  width: 100%;\n  height: 100%;\n\n  background-color: ", ";\n  opacity: 0.6;\n"], ["\n  position: absolute;\n  top: 0;\n\n  width: 100%;\n  height: 100%;\n\n  background-color: ", ";\n  opacity: 0.6;\n"])), function (_a) {
+    var theme = _a.theme;
+    return theme.palette.grey['100'];
+});
+export var StyledDivider = styled(Divider)(templateObject_2 || (templateObject_2 = __makeTemplateObject(["\n  border-width: 1px;\n"], ["\n  border-width: 1px;\n"])));
+export var LoaderWrapper = styled.div(templateObject_3 || (templateObject_3 = __makeTemplateObject(["\n  height: 2px;\n"], ["\n  height: 2px;\n"])));
+export var StyledLinearProgress = styled(LinearProgress)(templateObject_4 || (templateObject_4 = __makeTemplateObject(["\n  height: 2px;\n"], ["\n  height: 2px;\n"])));
+var templateObject_1, templateObject_2, templateObject_3, templateObject_4;

package/esm/DataGrid/DataGridLoader/types.d.ts

@@ -0,0 +1,3 @@
+export declare type DataGridLoaderProps = {
+    loading?: boolean;
+};

package/esm/DataGrid/DataGridLoader/types.js

@@ -0,0 +1 @@
+export {};

package/esm/DataGrid/constants.d.ts

@@ -0,0 +1,4 @@
+export declare enum SortStates {
+    ASC = "asc",
+    DESC = "desc"
+}

package/esm/DataGrid/constants.js

@@ -0,0 +1,5 @@
+export var SortStates;
+(function (SortStates) {
+    SortStates["ASC"] = "asc";
+    SortStates["DESC"] = "desc";
+})(SortStates || (SortStates = {}));

package/esm/DataGrid/index.d.ts

@@ -0,0 +1,2 @@
+export * from './DataGrid';
+export * from './types';

package/esm/DataGrid/index.js

@@ -0,0 +1,2 @@
+export * from './DataGrid';
+export * from './types';

package/esm/DataGrid/styled.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+export declare const DataGridContainer: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const StyledTableContainer: import("@emotion/styled").StyledComponent<{
+    children?: import("react").ReactNode;
+    classes?: Partial<import("@mui/material").TableContainerClasses> | undefined;
+    sx?: import("@mui/material").SxProps<import("@mui/material").Theme> | undefined;
+} & import("@mui/material/OverridableComponent").CommonProps & Omit<Pick<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof import("react").HTMLAttributes<HTMLDivElement>> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, keyof import("@mui/material/OverridableComponent").CommonProps | "children" | "sx"> & {
+    theme?: import("@emotion/react").Theme | undefined;
+} & {
+    maxHeight?: number | undefined;
+}, {}, {}>;

package/esm/DataGrid/styled.js

@@ -0,0 +1,14 @@
+var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {
+    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+    return cooked;
+};
+import { styled } from '../styles';
+import { TableContainer } from '../Table';
+export var DataGridContainer = styled.div(templateObject_1 || (templateObject_1 = __makeTemplateObject(["\n  width: 100%;\n  overflow: hidden;\n"], ["\n  width: 100%;\n  overflow: hidden;\n"])));
+export var StyledTableContainer = styled(TableContainer, {
+    shouldForwardProp: function (prop) { return prop !== 'maxHeight'; },
+})(templateObject_2 || (templateObject_2 = __makeTemplateObject(["\n  position: relative;\n\n  max-height: ", ";\n"], ["\n  position: relative;\n\n  max-height: ", ";\n"])), function (_a) {
+    var maxHeight = _a.maxHeight;
+    return "".concat(maxHeight, "px") || 'auto';
+});
+var templateObject_1, templateObject_2;

package/esm/DataGrid/types.d.ts

@@ -0,0 +1,32 @@
+import { ReactNode } from 'react';
+import { SortStates } from './constants';
+export declare type CellValue = string | number | boolean | Date | null | undefined | object;
+export declare type SortState = `${SortStates}`;
+export declare type RenderCell<T> = (params: T) => ReactNode;
+export declare type DataGridRow = Record<string, any>;
+export declare type DataGridSort<Data extends {}> = {
+    fieldId: keyof Data;
+    sort: SortState;
+};
+export declare type DataGridProps<T = DataGridRow> = {
+    rows: T[];
+    columns: DataGridColumns<T>[];
+    keyId: keyof DataGridRow;
+    selectedRows?: Array<T>;
+    onSelectRow?: (row: T[]) => void;
+    sorting?: DataGridSort<T>[];
+    onSort: (sorting: DataGridSort<T>[]) => void;
+    Footer?: ReactNode;
+    maxHeight?: number;
+    loading?: boolean;
+    minDisplayRows?: number;
+};
+export declare type DataGridColumns<Column extends {}> = {
+    field: keyof Column & string;
+    label?: string;
+    sortable?: boolean;
+    pointer?: boolean;
+    renderCell?: RenderCell<Column>;
+    format?: (data: Column) => CellValue;
+    align?: 'inherit' | 'left' | 'center' | 'right' | 'justify';
+};

package/esm/DataGrid/types.js

@@ -0,0 +1 @@
+export {};

package/esm/DataGridPagination/DataGridPagination.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { DataGridPaginationProps } from './types';
+export declare const DataGridPagination: ({ page, rowsPerPage, totalCount, className, ...props }: DataGridPaginationProps) => JSX.Element;

package/esm/DataGridPagination/DataGridPagination.js

@@ -0,0 +1,34 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { Pagination } from '../Pagination';
+import { PaginationWrapper, Range } from './styled';
+export var DataGridPagination = function (_a) {
+    var page = _a.page, _b = _a.rowsPerPage, rowsPerPage = _b === void 0 ? 10 : _b, totalCount = _a.totalCount, className = _a.className, props = __rest(_a, ["page", "rowsPerPage", "totalCount", "className"]);
+    var count = Math.ceil(totalCount / rowsPerPage);
+    var rangeStart = useMemo(function () { return page * rowsPerPage; }, [page]);
+    var rangeEnd = useMemo(function () { return page * rowsPerPage + rowsPerPage; }, [page]);
+    var formattedRange = "".concat(rangeStart, " \u2014 ").concat(rangeEnd, " \u0438\u0437 ").concat(totalCount, " \u0437\u0430\u043F\u0438\u0441\u0435\u0439");
+    return (_jsxs(PaginationWrapper, __assign({ className: className }, { children: [_jsx(Range, __assign({ variant: "h6" }, { children: formattedRange }), void 0), _jsx(Pagination, __assign({ count: count }, props), void 0)] }), void 0));
+};

package/esm/DataGridPagination/index.d.ts

@@ -0,0 +1,2 @@
+export * from './DataGridPagination';
+export * from './types';

package/esm/DataGridPagination/index.js

@@ -0,0 +1,2 @@
+export * from './DataGridPagination';
+export * from './types';

package/esm/DataGridPagination/styled.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+export declare const PaginationWrapper: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const Range: import("@emotion/styled").StyledComponent<Omit<import("@mui/material").TypographyProps<"span", {}>, "variant"> & {
+    variant?: "link" | "small" | "code" | "pointer" | import("@mui/material").TypographyVariant | "h7" | "h8" | "h9" | "ui" | undefined;
+} & {
+    theme?: import("@emotion/react").Theme | undefined;
+}, {}, {}>;

package/esm/DataGridPagination/styled.js

@@ -0,0 +1,15 @@
+var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {
+    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+    return cooked;
+};
+import { styled } from '../styles';
+import { Typography } from '../Typography';
+export var PaginationWrapper = styled.div(templateObject_1 || (templateObject_1 = __makeTemplateObject(["\n  display: flex;\n  align-items: center;\n  justify-content: space-between;\n  padding: ", ";\n"], ["\n  display: flex;\n  align-items: center;\n  justify-content: space-between;\n  padding: ", ";\n"])), function (_a) {
+    var theme = _a.theme;
+    return theme.spacing(2, 0);
+});
+export var Range = styled(Typography)(templateObject_2 || (templateObject_2 = __makeTemplateObject(["\n  color: ", ";\n"], ["\n  color: ", ";\n"])), function (_a) {
+    var theme = _a.theme;
+    return theme.palette.grey['700'];
+});
+var templateObject_1, templateObject_2;

package/esm/DataGridPagination/types.d.ts

@@ -0,0 +1,6 @@
+import { PaginationProps } from '../Pagination';
+export declare type DataGridPaginationProps = Omit<PaginationProps, 'count'> & {
+    totalCount: number;
+    rowsPerPage?: number;
+    page: number;
+};

package/esm/DataGridPagination/types.js

@@ -0,0 +1 @@
+export {};

package/esm/Pagination/Pagination.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { PaginationProps } from './types';
+export declare const Pagination: ({ ...props }: PaginationProps) => JSX.Element;