@astral/ui 4.74.0 → 4.76.0

package/node/components/DataGrid/Row/useLogic/useLogic.js

@@ -9,11 +9,18 @@ const constants_1 = require("../constants");
 const RowContext_1 = require("../RowContext");
 const hooks_1 = require("./hooks");
 const utils_1 = require("./utils");
-const useLogic = ({ keyId, columns, row, nestedChildren, level, variant, options, isInitialExpanded = false, expandedLevel, isSelectable, selectedRows, onSelectRow, onRowClick, isVisibleCollapseButton, registerRowElement, unregisterRowElement, style, activeRowId, }) => {
+const useLogic = ({ keyId, columns, row, nestedChildren, level, variant, options, isInitialExpanded = false, expandedLevel, isSelectable, isSelected, onSelectRow, onRowClick, isVisibleCollapseButton, registerRowElement, unregisterRowElement, style, activeRowId, }) => {
     const { isDrawerOpen, handleOpenDrawer, handleCloseDrawer } = (0, hooks_1.useMobileLogic)();
-    const isDefaultExpanded = isInitialExpanded && level <= expandedLevel - 1 && nestedChildren?.length;
-    const { checkIsOpened, toggleOpenItems } = (0, react_1.useContext)(DataGridContext_1.DataGridContext);
+    const [rootRowElement, setRootRowElement] = (0, react_1.useState)(null);
+    const rootRowRef = (0, react_1.useCallback)((element) => {
+        if (element) {
+            setRootRowElement(element);
+        }
+    }, []);
+    const isDefaultExpanded = Boolean(isInitialExpanded && level <= expandedLevel - 1 && nestedChildren?.length);
+    const { mobileDisplayVariant } = (0, react_1.useContext)(DataGridContext_1.DataGridContext);
     const { isDisabled, disabledReason } = (0, react_1.useContext)(RowContext_1.RowContext);
+    const [isOpen, setIsOpen] = (0, react_1.useState)(isDefaultExpanded);
     const savedElementRef = (0, react_1.useRef)(null);
     const rowRef = (element) => {
         if (element) {
@@ -29,7 +36,6 @@ const useLogic = ({ keyId, columns, row, nestedChildren, level, variant, options
     const rowId = row[keyId];
     const { isDisabled: isExternalDisabled, disabledReason: externalDisabledReason, href, target, } = options || {};
     const disabled = isDisabled || isExternalDisabled;
-    const isOpen = checkIsOpened(rowId);
     const handleRowClick = () => {
         if (disabled) {
             handleOpenDrawer();
@@ -40,20 +46,12 @@ const useLogic = ({ keyId, columns, row, nestedChildren, level, variant, options
         }
         onRowClick?.(row);
     };
-    (0, react_1.useEffect)(() => {
-        // Проверка на isOpen необходима для infinite версии с виртуализацией, когда происходит размонтировании компонента
-        if (isDefaultExpanded && !isOpen) {
-            toggleOpenItems(rowId);
-        }
-    }, []);
-    const isChecked = isSelectable &&
-        Boolean(selectedRows?.find((selectedRow) => selectedRow[keyId] === rowId));
     const isShowConnector = Object.is(variant, enums_1.Variant.Tree);
     const childrenColumns = (0, react_1.useMemo)(() => (0, utils_1.mergeColumnsOptions)(columns, options?.childrenColumns), [columns, options]);
-    const handleToggle = (event) => {
+    const handleToggle = (0, react_1.useCallback)((event) => {
         event.stopPropagation();
-        toggleOpenItems(rowId);
-    };
+        setIsOpen((prev) => !prev);
+    }, []);
     const handleOpenTooltip = (event) => {
         const element = event.target;
         const isDisabledCell = element?.getAttribute(constants_1.DISABLE_ROW_ATTR) === 'true';
@@ -80,6 +78,7 @@ const useLogic = ({ keyId, columns, row, nestedChildren, level, variant, options
     const isHovered = Boolean(!disabled && (onRowClick || href));
     const isActive = activeRowId === rowId;
     const disabledReasonText = externalDisabledReason || disabledReason;
+    const handleCheckboxChange = (0, react_1.useMemo)(() => onSelectRow(row), [onSelectRow, row]);
     return {
         disabledReasonText,
         rowStyles,
@@ -89,10 +88,14 @@ const useLogic = ({ keyId, columns, row, nestedChildren, level, variant, options
         rowId,
         rowRef,
         disabled,
+        isSelectable,
         isRenderCollapseButton,
         handleToggle,
+        rootRowElement,
+        rootRowRef,
         isHovered,
         isActive,
+        mobileDisplayVariant,
         rowProps: {
             onClick: handleRowClick,
             onMouseMove: handleMouseMove,
@@ -109,13 +112,12 @@ const useLogic = ({ keyId, columns, row, nestedChildren, level, variant, options
             onClose: handleCloseTooltip,
         },
         checkboxProps: {
-            checked: isChecked,
+            checked: isSelected,
             disabled,
-            onChange: onSelectRow(row),
+            onChange: handleCheckboxChange,
         },
         nestedChildrenProps: {
             isOpen,
-            rowId,
         },
     };
 };

package/node/components/DataGrid/RowBase/GroupCell/GroupCell.d.ts

@@ -0,0 +1,2 @@
+import { type GroupCellProps } from './types';
+export declare const GroupCell: ({ cell, cellId, isFirstCell, row, emptyCellValue, isDisabled, startAdornment, }: GroupCellProps) => import("react/jsx-runtime").JSX.Element;

package/node/components/DataGrid/RowBase/GroupCell/GroupCell.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupCell = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const class_variance_authority_1 = require("class-variance-authority");
+const Cell_1 = require("../../Cell");
+const constants_1 = require("./constants");
+const styles_1 = require("./styles");
+const groupedColumnLabelCva = (0, class_variance_authority_1.cva)(constants_1.dataGridGroupedColumnLabelClassnames.root, {
+    variants: {
+        hidden: {
+            true: constants_1.dataGridGroupedColumnLabelClassnames.hidden,
+        },
+    },
+});
+const GroupCell = ({ cell, cellId, isFirstCell, row, emptyCellValue, isDisabled, startAdornment, }) => {
+    const { label, children, hideTitleOnMobile, isHideOnMobile } = cell;
+    return ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [(0, jsx_runtime_1.jsx)(styles_1.GroupedColumnLabel, { variant: "caption", color: "grey", colorIntensity: "700", className: groupedColumnLabelCva({
+                    hidden: hideTitleOnMobile || isHideOnMobile,
+                }), children: label }), children.map((child, childIndex) => {
+                const childCellId = `${cellId}-${childIndex}`;
+                const shouldRenderStartAdornment = isFirstCell && childIndex === 0;
+                return ((0, jsx_runtime_1.jsx)(Cell_1.Cell, { row: row, cell: child, isHideOnMobile: isHideOnMobile, emptyCellValue: emptyCellValue, isDisabled: isDisabled, startAdornment: shouldRenderStartAdornment && startAdornment, isHidePersonalData: child.isHidePersonalData, className: Cell_1.dataGridCellClassnames.grouped }, childCellId));
+            })] }));
+};
+exports.GroupCell = GroupCell;

package/node/components/DataGrid/RowBase/GroupCell/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const dataGridGroupedColumnLabelClassnames: {
+    root: string;
+    hidden: string;
+};

package/node/components/DataGrid/RowBase/GroupCell/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataGridGroupedColumnLabelClassnames = void 0;
+const createUIKitClassname_1 = require("../../../utils/createUIKitClassname");
+exports.dataGridGroupedColumnLabelClassnames = {
+    root: (0, createUIKitClassname_1.createUIKitClassname)('data-grid-grouped-column-label'),
+    hidden: (0, createUIKitClassname_1.createUIKitClassname)('data-grid-grouped-column-label_hidden'),
+};

package/node/components/DataGrid/RowBase/GroupCell/index.d.ts

@@ -0,0 +1 @@
+export { GroupCell } from './GroupCell';

package/node/components/DataGrid/RowBase/GroupCell/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupCell = void 0;
+var GroupCell_1 = require("./GroupCell");
+Object.defineProperty(exports, "GroupCell", { enumerable: true, get: function () { return GroupCell_1.GroupCell; } });

package/node/components/DataGrid/RowBase/GroupCell/styles.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+export declare const GroupedColumnLabel: import("@emotion/styled/dist/declarations/src/types").StyledComponent<import("../../../Typography/types").TypographyPropsBase & {
+    color?: import("../../../Typography").TypographyColor | undefined;
+    variant?: import("../../../Typography").TypographyVariant | undefined;
+    colorIntensity?: import("../../../Typography").Intensity | undefined;
+    component?: import("../../../Typography/types").ComponentProp | undefined;
+    isUpperCase?: boolean | undefined;
+    withoutCalt?: boolean | undefined;
+    isTabularNums?: boolean | undefined;
+} & import("react").HTMLAttributes<HTMLParagraphElement> & import("react").RefAttributes<HTMLSpanElement> & {
+    theme?: import("@emotion/react").Theme | undefined;
+}, {}, {}>;

package/node/components/DataGrid/RowBase/GroupCell/styles.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupedColumnLabel = void 0;
+const styled_1 = require("../../../styled");
+const Typography_1 = require("../../../Typography");
+const constants_1 = require("./constants");
+exports.GroupedColumnLabel = (0, styled_1.styled)(Typography_1.Typography) `
+  display: none;
+
+  ${({ theme }) => theme.breakpoints.down('sm')} {
+    display: block;
+
+    margin-top: ${({ theme }) => theme.spacing(3)};
+
+    &.${constants_1.dataGridGroupedColumnLabelClassnames.hidden} {
+      display: none;
+    }
+  }
+`;

package/node/components/DataGrid/RowBase/GroupCell/types.d.ts

@@ -0,0 +1,11 @@
+import { type ReactNode } from 'react';
+import { type DataGridGroupColumn, type DataGridRowWithOptions } from '../../types';
+export type GroupCellProps = {
+    cell: DataGridGroupColumn<Record<string, unknown>>;
+    cellId: string;
+    isFirstCell?: boolean;
+    row: DataGridRowWithOptions<Record<string, unknown>>;
+    emptyCellValue?: ReactNode;
+    isDisabled?: boolean;
+    startAdornment?: ReactNode;
+};

package/node/components/DataGrid/RowBase/GroupCell/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/node/components/DataGrid/RowBase/RowBase.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { RowBaseProps } from './types';
+export declare const RowBase: import("react").MemoExoticComponent<(props: RowBaseProps) => import("react/jsx-runtime").JSX.Element>;

package/node/components/DataGrid/RowBase/RowBase.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RowBase = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const BottomDrawer_1 = require("../../BottomDrawer");
+const Checkbox_1 = require("../../Checkbox");
+const Tooltip_1 = require("../../Tooltip");
+const classNames_1 = require("../../utils/classNames");
+const cva_1 = require("../../utils/cva");
+const getInertProps_1 = require("../../utils/getInertProps");
+const Cell_1 = require("../Cell");
+const constants_1 = require("../Row/constants");
+const utils_1 = require("../Row/utils");
+const utils_2 = require("../utils");
+const constants_2 = require("./constants");
+const GroupCell_1 = require("./GroupCell");
+const styles_1 = require("./styles");
+const useLogic_1 = require("./useLogic");
+const contentWrapperCva = (0, cva_1.cva)(constants_2.dataGridRowBaseClassnames.contentWrapper, {
+    variants: {
+        isHovered: {
+            true: constants_2.dataGridRowBaseClassnames.hovered,
+        },
+        isActive: {
+            true: constants_2.dataGridRowBaseClassnames.active,
+        },
+    },
+});
+const rootCva = (0, cva_1.cva)(constants_2.dataGridRowBaseClassnames.root, {
+    variants: {
+        mobileDisplayVariant: {
+            cards: constants_2.dataGridRowBaseClassnames.mobileVariantCards,
+            list: constants_2.dataGridRowBaseClassnames.mobileVariantList,
+        },
+    },
+});
+exports.RowBase = (0, react_1.memo)((props) => {
+    const { className, tooltipProps, rowBaseVars, isHovered, isActive, drawerProps, emptyCellValue, rowRef, onRowEnter, onRowLeave, rowId, row, isDisabled, sectionOffset, customContent, isDisabledLastCell, renderStartAdornment, checkboxProps, isNotSelectable, isSelectable, columns, dataGridInfiniteItemProps, handleRowClick, drawerContent, mobileDisplayVariant, } = (0, useLogic_1.useLogic)(props);
+    const renderStartAdornmentBase = () => {
+        const adornment = renderStartAdornment?.(true);
+        const shouldRenderCheckbox = isSelectable && !isNotSelectable;
+        if (!adornment && !shouldRenderCheckbox) {
+            return null;
+        }
+        return ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [adornment, shouldRenderCheckbox && ((0, jsx_runtime_1.jsx)(styles_1.CheckboxCell, { ...(0, getInertProps_1.getInertProps)(isDisabled), onClick: (event) => event.stopPropagation(), className: constants_1.dataGridRowClassnames.checkbox, children: (0, jsx_runtime_1.jsx)(Checkbox_1.Checkbox, { ...checkboxProps }) }))] }));
+    };
+    const renderCells = (0, react_1.useCallback)(() => {
+        const lastCellGlobalIndex = columns.length - 1;
+        const availableCellsByIndex = !isDisabledLastCell
+            ? [lastCellGlobalIndex]
+            : undefined;
+        return columns?.map((cell, index) => {
+            const cellId = `row-base-${index}`;
+            const globalIndex = (sectionOffset ?? 0) + index;
+            const isFirstCell = globalIndex === 0;
+            const isDisabledCell = (0, utils_1.checkIsDisabled)(isDisabled, availableCellsByIndex, globalIndex);
+            if ((0, utils_2.isGroupColumns)(cell)) {
+                return ((0, jsx_runtime_1.jsx)(GroupCell_1.GroupCell, { cell: cell, cellId: cellId, isFirstCell: isFirstCell, row: row, emptyCellValue: emptyCellValue, isDisabled: isDisabledCell, startAdornment: isFirstCell && renderStartAdornmentBase() }, cellId));
+            }
+            return ((0, jsx_runtime_1.jsx)(Cell_1.Cell, { row: row, cell: cell, emptyCellValue: emptyCellValue, startAdornment: isFirstCell && renderStartAdornmentBase(), isDisabled: isDisabledCell, isHidePersonalData: cell.isHidePersonalData }, cellId));
+        });
+    }, [
+        row,
+        columns,
+        isDisabled,
+        sectionOffset,
+        renderStartAdornment,
+        checkboxProps.checked,
+    ]);
+    return ((0, jsx_runtime_1.jsxs)(styles_1.Wrapper, { className: (0, classNames_1.classNames)(className, rootCva({ mobileDisplayVariant })), style: rowBaseVars, ...dataGridInfiniteItemProps, children: [(0, jsx_runtime_1.jsx)(Tooltip_1.Tooltip, { ...tooltipProps, children: (0, jsx_runtime_1.jsx)(styles_1.ContentWrapper, { ref: rowRef, onPointerEnter: () => onRowEnter?.(rowId), onPointerLeave: (event) => onRowLeave?.(rowId, event.nativeEvent), className: contentWrapperCva({ isHovered, isActive }), [constants_1.DISABLE_ROW_ATTR]: isDisabled, onClick: handleRowClick, children: renderCells() }) }), customContent, (0, jsx_runtime_1.jsx)(BottomDrawer_1.BottomDrawer, { ...drawerProps, children: (0, jsx_runtime_1.jsx)(styles_1.BottomDrawerContent, { children: drawerContent }) })] }, `row-base-${rowId}`));
+});

package/node/components/DataGrid/RowBase/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const DISABLE_ROW_ATTR = "data-row-disable";
+export declare const dataGridRowBaseClassnames: {
+    root: string;
+    contentWrapper: string;
+    hovered: string;
+    active: string;
+    mobileVariantCards: string;
+    mobileVariantList: string;
+};

package/node/components/DataGrid/RowBase/constants.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataGridRowBaseClassnames = exports.DISABLE_ROW_ATTR = void 0;
+const createUIKitClassname_1 = require("../../utils/createUIKitClassname");
+exports.DISABLE_ROW_ATTR = 'data-row-disable';
+exports.dataGridRowBaseClassnames = {
+    root: (0, createUIKitClassname_1.createUIKitClassname)('data-grid-row-base'),
+    contentWrapper: (0, createUIKitClassname_1.createUIKitClassname)('data-grid-row-base__content-wrapper'),
+    hovered: (0, createUIKitClassname_1.createUIKitClassname)('data-grid-row-base_hovered'),
+    active: (0, createUIKitClassname_1.createUIKitClassname)('data-grid-row-base_active'),
+    mobileVariantCards: (0, createUIKitClassname_1.createUIKitClassname)('data-grid-row-base_mobile-variant-cards'),
+    mobileVariantList: (0, createUIKitClassname_1.createUIKitClassname)('data-grid-row-base_mobile-variant-list'),
+};

package/node/components/DataGrid/RowBase/index.d.ts

@@ -0,0 +1,3 @@
+export { RowBase } from './RowBase';
+export { dataGridRowBaseClassnames } from './constants';
+export type { RowBaseProps } from './types';

package/node/components/DataGrid/RowBase/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataGridRowBaseClassnames = exports.RowBase = void 0;
+var RowBase_1 = require("./RowBase");
+Object.defineProperty(exports, "RowBase", { enumerable: true, get: function () { return RowBase_1.RowBase; } });
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "dataGridRowBaseClassnames", { enumerable: true, get: function () { return constants_1.dataGridRowBaseClassnames; } });

package/node/components/DataGrid/RowBase/styles.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+export declare const CheckboxCell: import("@emotion/styled/dist/declarations/src/types").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements> | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const Wrapper: import("@emotion/styled/dist/declarations/src/types").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements> | undefined;
+}, import("react").DetailedHTMLProps<import("react").LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, {}>;
+export declare const ContentWrapper: import("@emotion/styled/dist/declarations/src/types").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements> | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const BottomDrawerContent: import("@emotion/styled/dist/declarations/src/types").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements> | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

package/node/components/DataGrid/RowBase/styles.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BottomDrawerContent = exports.ContentWrapper = exports.Wrapper = exports.CheckboxCell = void 0;
+const styled_1 = require("../../styled");
+const constants_1 = require("../constants");
+const constants_2 = require("./constants");
+exports.CheckboxCell = styled_1.styled.div `
+  display: flex;
+  align-items: center;
+  align-self: center;
+  justify-content: center;
+
+  width: ${constants_1.ROOT_ACTION_CELL_WIDTH}px;
+`;
+exports.Wrapper = styled_1.styled.li `
+  --row-base-grid-columns: 1fr;
+
+  position: relative;
+
+  ${({ theme }) => theme.breakpoints.down('sm')} {
+    padding-bottom: ${({ theme }) => theme.spacing(3)};
+
+    border-bottom: 1px solid ${({ theme }) => theme.palette.grey[300]};
+
+    &:not(:first-of-type) {
+      padding-top: ${({ theme }) => theme.spacing(5)};
+    }
+
+    &:first-of-type {
+      padding-top: ${({ theme }) => theme.spacing(1)};
+    }
+
+    &.${constants_2.dataGridRowBaseClassnames.mobileVariantCards} {
+      padding: ${({ theme }) => theme.spacing(5, 4, 4)};
+
+      background-color: ${({ theme }) => theme.palette.background.default};
+      border: 1px solid ${({ theme }) => theme.palette.grey[300]};
+      border-bottom: none;
+      border-radius: ${({ theme }) => theme.shape.medium};
+  
+    }
+  }
+`;
+exports.ContentWrapper = styled_1.styled.div `
+  position: relative;
+
+  display: grid;
+  grid-template-columns: var(--row-base-grid-columns);
+
+  background-color: transparent;
+
+  &.${constants_2.dataGridRowBaseClassnames.active} {
+    background-color: ${({ theme }) => theme.palette.primary[100]};
+  }
+
+  &:hover {
+    background-color: ${({ theme }) => theme.palette.background.elementHover};
+
+    &.${constants_2.dataGridRowBaseClassnames.active} {
+      background-color: ${({ theme }) => theme.palette.primary[100]};
+    }
+
+    &.${constants_2.dataGridRowBaseClassnames.hovered} {
+      cursor: pointer;
+    }
+  }
+
+  ${({ theme }) => theme.breakpoints.down('sm')} {
+    grid-template-columns: 1fr;
+
+    &.${constants_2.dataGridRowBaseClassnames.active} {
+      background-color: transparent;
+    }
+
+    &:hover, &.${constants_2.dataGridRowBaseClassnames.hovered} {
+      cursor: initial;
+
+      background-color: transparent;
+
+      &.${constants_2.dataGridRowBaseClassnames.active} {
+        background-color: transparent;
+      }
+    }
+  }
+`;
+exports.BottomDrawerContent = styled_1.styled.div `
+    ${({ theme }) => theme.breakpoints.down('sm')} {
+      padding: ${({ theme }) => theme.spacing(5, 4)};
+    }
+`;

package/node/components/DataGrid/RowBase/types.d.ts

@@ -0,0 +1,92 @@
+import { type ChangeEvent, type ReactNode } from 'react';
+import type { DataGridColumns, DataGridRowWithOptions } from '../types';
+export type RowBaseProps = {
+    /**
+     * Массив колонок
+     */
+    columns: DataGridColumns<Record<string, unknown>>[];
+    /**
+     * Данные строки для отображения
+     */
+    row: DataGridRowWithOptions<Record<string, unknown>>;
+    /**
+     * Функция для рендера стартового элемента
+     */
+    renderStartAdornment?: (isFirstCell: boolean) => ReactNode;
+    /**
+     * Смещение секции для правильного расчета глобального индекса
+     */
+    sectionOffset?: number;
+    /**
+     * Уникальный идентификатор строки
+     */
+    rowId: string;
+    /**
+     * Кастомный контент после ячеек
+     */
+    customContent?: ReactNode;
+    /**
+     * Является ли строка выбираемой
+     */
+    isSelectable?: boolean;
+    /**
+     * Уникальный идентификатор строки
+     */
+    keyId: unknown;
+    /**
+     * Обработчик клика строки таблицы
+     */
+    onRowClick?: (row: Record<string, unknown>) => void;
+    /**
+     * Является ли строка выбранной
+     */
+    isSelected?: boolean;
+    /**
+     * Заблокирована ли строка
+     */
+    isDisabled?: boolean;
+    /**
+     * Причина блокировки строки
+     */
+    disabledReason?: string;
+    /**
+     * Обработчик выбора строки
+     */
+    onSelectRow: (row: Record<string, unknown>) => (event: ChangeEvent<HTMLInputElement>) => void;
+    /**
+     * Обработчик наведения на строку
+     */
+    onRowEnter?: (rowId: string) => void;
+    /**
+     * Обработчик ухода со строки
+     */
+    onRowLeave?: (rowId: string, event: PointerEvent) => void;
+    /**
+     * Регистрация элемента строки
+     */
+    registerRowElement?: (rowId: string, el: HTMLElement) => void;
+    /**
+     * Удаление регистрации элемента строки
+     */
+    unregisterRowElement?: (rowId: string, el: HTMLElement) => void;
+    /**
+     * Шаблон колонок (CSS grid-template-columns)
+     */
+    gridColumns?: string;
+    /**
+     * ID активной строки
+     */
+    activeRowId?: string;
+    /**
+     * Значение для пустой ячейки
+     */
+    emptyCellValue?: ReactNode;
+    /**
+     * Вариант отображения на мобильных устройствах
+     */
+    mobileDisplayVariant?: 'cards' | 'list';
+    /**
+     * Класс применяемый для корневого элемента
+     */
+    className?: string;
+};

package/node/components/DataGrid/RowBase/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/node/components/DataGrid/RowBase/useLogic/index.d.ts

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

package/node/components/DataGrid/RowBase/useLogic/useLogic.d.ts

@@ -0,0 +1,46 @@
+import { type CSSProperties, type SyntheticEvent } from 'react';
+import type { RowBaseProps } from '../types';
+type UseLogicParams = RowBaseProps;
+export declare const useLogic: ({ className, row, keyId, onRowClick, columns, sectionOffset, customContent, renderStartAdornment, isSelected, isDisabled, disabledReason, onSelectRow, onRowEnter, onRowLeave, registerRowElement, unregisterRowElement, gridColumns, activeRowId, emptyCellValue, isSelectable, rowId, mobileDisplayVariant, ...dataGridInfiniteItemProps }: UseLogicParams) => {
+    handleRowClick: () => void;
+    tooltipProps: {
+        open: boolean;
+        title: string | undefined;
+        onOpen: (event: SyntheticEvent<Element, Event>) => void;
+        onClose: () => void;
+        followCursor: boolean;
+        arrow: boolean;
+    };
+    checkboxProps: {
+        checked: boolean | undefined;
+        disabled: boolean | undefined;
+        onChange: (event: import("react").ChangeEvent<HTMLInputElement, Element>) => void;
+    };
+    drawerProps: {
+        open: boolean;
+        onClose: () => void;
+        title: string;
+    };
+    drawerContent: string | undefined;
+    rowBaseVars: CSSProperties;
+    isHovered: boolean;
+    isActive: boolean;
+    columns: import("../..").DataGridColumns<Record<string, unknown>>[];
+    emptyCellValue: import("react").ReactNode;
+    rowRef: (element: HTMLElement | null) => void;
+    onRowEnter: ((rowId: string) => void) | undefined;
+    onRowLeave: ((rowId: string, event: PointerEvent) => void) | undefined;
+    rowId: string;
+    row: import("../..").DataGridRowWithOptions<Record<string, unknown>>;
+    isDisabled: boolean | undefined;
+    sectionOffset: number | undefined;
+    customContent: import("react").ReactNode;
+    isDisabledLastCell: boolean | undefined;
+    renderStartAdornment: ((isFirstCell: boolean) => import("react").ReactNode) | undefined;
+    isSelectable: boolean | undefined;
+    isNotSelectable: boolean | undefined;
+    dataGridInfiniteItemProps: {};
+    mobileDisplayVariant: "list" | "cards" | undefined;
+    className: string | undefined;
+};
+export {};