@astral/ui 4.114.0 → 4.115.1

package/components/DataGrid/Body/Body.d.ts

@@ -1,2 +1,2 @@
 import type { BodyProps } from './types';
-export declare const Body: <TData extends Record<string, unknown>>({ rows, selectedRows, minDisplayRows, keyId, noDataPlaceholder, className, renderRow, columns, isSelectable, onSelectRow, onRowEnter, onRowLeave, registerRowElement, unregisterRowElement, ...rowProps }: BodyProps<TData>) => import("react/jsx-runtime").JSX.Element;
+export declare const Body: <TData extends Record<string, unknown>>({ rows, selectedIds, rowsDisabled, getRowDisabled, minDisplayRows, keyId, noDataPlaceholder, className, renderRow, columns, isSelectable, onSelectRow, onRowEnter, onRowLeave, registerRowElement, unregisterRowElement, ...rowProps }: BodyProps<TData>) => import("react/jsx-runtime").JSX.Element;

package/components/DataGrid/Body/Body.js

@@ -15,13 +15,17 @@ const bodyCva = cva(bodyClassnames.root, {
         },
     },
 });
-export const Body = ({ rows, selectedRows = [], minDisplayRows, keyId, noDataPlaceholder, className, renderRow, columns, isSelectable, onSelectRow, onRowEnter, onRowLeave, registerRowElement, unregisterRowElement, ...rowProps }) => {
+export const Body = ({ rows, selectedIds, rowsDisabled, getRowDisabled, minDisplayRows, keyId, noDataPlaceholder, className, renderRow, columns, isSelectable, onSelectRow, onRowEnter, onRowLeave, registerRowElement, unregisterRowElement, ...rowProps }) => {
     const { disableMinHeight, bodyCssVars } = useLogic({ minDisplayRows });
     const renderedRows = rows.map((row, index) => {
         const rowId = row[keyId];
-        const isSelected = Boolean(selectedRows?.find((selectedRow) => selectedRow[keyId] === rowId));
+        const isSelected = selectedIds.has(rowId);
+        const rowDisabled = rowsDisabled.get(rowId);
         const { children, options } = row;
-        return (_jsx(RowContextProvider, { row: row, onSelectRow: onSelectRow, onRowEnter: onRowEnter, onRowLeave: onRowLeave, registerRowElement: registerRowElement, unregisterRowElement: unregisterRowElement, isSelectable: isSelectable, isSelected: isSelected, children: renderRow ? (_jsx(CustomRowWrapper, { index: index, renderRow: renderRow, row: row })) : (_jsx(Row, { row: row, options: options, keyId: keyId, level: INITIAL_LEVEL, nestedChildren: children, isSelected: isSelected, columns: columns, isSelectable: isSelectable, onSelectRow: onSelectRow, onRowEnter: onRowEnter, onRowLeave: onRowLeave, registerRowElement: registerRowElement, unregisterRowElement: unregisterRowElement, ...rowProps }, rowId)) }, rowId));
+        const hasNestedChildren = Array.isArray(children) && children.length > 0;
+        return (_jsx(RowContextProvider, { row: row, onSelectRow: onSelectRow, onRowEnter: onRowEnter, onRowLeave: onRowLeave, registerRowElement: registerRowElement, unregisterRowElement: unregisterRowElement, isSelectable: isSelectable, isSelected: isSelected, disabledMode: rowDisabled?.mode, disabledReason: rowDisabled?.reason, children: renderRow ? (_jsx(CustomRowWrapper, { index: index, renderRow: renderRow, row: row })) : (_jsx(Row, { row: row, options: options, keyId: keyId, level: INITIAL_LEVEL, nestedChildren: children, isSelected: isSelected, 
+                // Функция нужна только для расчёта блокировки вложенных строк, остальным не передаём, чтобы не сбрасывать memo
+                getRowDisabled: hasNestedChildren ? getRowDisabled : undefined, columns: columns, isSelectable: isSelectable, onSelectRow: onSelectRow, onRowEnter: onRowEnter, onRowLeave: onRowLeave, registerRowElement: registerRowElement, unregisterRowElement: unregisterRowElement, ...rowProps }, rowId)) }, rowId));
     });
     return (_jsx(Wrapper, { className: cn(className, bodyCva({ disableMinHeight })), style: bodyCssVars, children: rows.length ? renderedRows : noDataPlaceholder }));
 };

package/components/DataGrid/Body/types.d.ts

@@ -1,6 +1,6 @@
 import { type ChangeEvent, type ReactNode } from 'react';
 import { type Variant } from '../enums';
-import { type CellValue, type DataGridColumns, type DataGridRowOptions } from '../types';
+import { type CellValue, type DataGridColumns, type DataGridProps, type DataGridRowDisabled, type DataGridRowOptions } from '../types';
 export type BodyProps<TData extends Record<string, CellValue>> = {
     /**
      * Конфигурация колонок для таблицы
@@ -46,9 +46,17 @@ export type BodyProps<TData extends Record<string, CellValue>> = {
      */
     isSelectable?: boolean;
     /**
-     * Массив выбранных строк
+     * Идентификаторы выбранных строк
      */
-    selectedRows?: TData[];
+    selectedIds: Set<unknown>;
+    /**
+     * Блокировки строк по идентификатору
+     */
+    rowsDisabled: Map<unknown, DataGridRowDisabled | undefined>;
+    /**
+     * Функция блокировки для вложенных строк
+     */
+    getRowDisabled?: DataGridProps<TData>['getRowDisabled'];
     /**
      * Массив данных для отображения
      */

package/components/DataGrid/DataGrid.js

@@ -79,7 +79,6 @@ export const DataGrid = (props) => {
     const commonBodyProps = {
         ...bodyProps,
         keyId,
-        selectedRows,
         minDisplayRows,
         rows: renderRows,
         variant,

package/components/DataGrid/PinnedSections/PinnedSections.js

@@ -4,8 +4,8 @@ import { Section } from './Section';
 import { PinnedColumnsContainer } from './styles';
 import { useLogic } from './useLogic';
 export const PinnedSections = ({ gridColumns, className, isDisabled, headProps, bodyProps, sections, isNoData, }) => {
-    const { pinnedContainerStyles, sectionOffsets } = useLogic({ sections });
+    const { pinnedContainerStyles, sectionOffsets, totalColumnsCount } = useLogic({ sections });
     return (_jsx(PinnedColumnsContainer, { "$gridColumns": gridColumns, className: className, ...getInertProps(isDisabled), style: pinnedContainerStyles, children: sections.map(({ columns, position }) => {
-            return (_jsx(Section, { columns: columns, position: position, sectionOffset: sectionOffsets[position], bodyProps: bodyProps, headProps: headProps, isNoData: isNoData }, position));
+            return (_jsx(Section, { columns: columns, position: position, sectionOffset: sectionOffsets[position], bodyProps: { ...bodyProps, totalColumnsCount }, headProps: headProps, isNoData: isNoData }, position));
         }) }));
 };

package/components/DataGrid/PinnedSections/useLogic/useLogic.d.ts

@@ -5,5 +5,6 @@ type UseLogicParams<TData extends Record<string, CellValue> = DataGridRow> = Pic
 export declare const useLogic: <TData extends Record<string, unknown> = DataGridRow>({ sections, }: UseLogicParams<TData>) => {
     pinnedContainerStyles: CSSProperties;
     sectionOffsets: Record<string, number>;
+    totalColumnsCount: number;
 };
 export {};

package/components/DataGrid/PinnedSections/useLogic/useLogic.js

@@ -11,14 +11,15 @@ export const useLogic = ({ sections, }) => {
             ? getFlattenColumns(rightColumns).length
             : 0,
     };
-    const sectionOffsets = useMemo(() => {
+    // Строка в секции видит только свои колонки, поэтому для поиска последней ячейки таблицы ей передаётся общее число колонок всех секций
+    const { sectionOffsets, totalColumnsCount } = useMemo(() => {
         const offsets = {};
         let currentOffset = 0;
         sections.forEach((section) => {
             offsets[section.position] = currentOffset;
             currentOffset += getFlattenColumns(section.columns).length;
         });
-        return offsets;
+        return { sectionOffsets: offsets, totalColumnsCount: currentOffset };
     }, [sections]);
-    return { pinnedContainerStyles, sectionOffsets };
+    return { pinnedContainerStyles, sectionOffsets, totalColumnsCount };
 };

package/components/DataGrid/Row/Row.js

@@ -1,12 +1,12 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { Fragment, memo, useCallback } from 'react';
 import { BottomDrawer } from '../../BottomDrawer';
-import { Checkbox } from '../../Checkbox';
 import { Tooltip } from '../../Tooltip';
 import { cn } from '../../utils/cn';
 import { cva } from '../../utils/cva';
 import { getInertProps } from '../../utils/getInertProps';
 import { dataGridCellClassnames } from '../Cell';
+import { RowCheckbox } from '../RowCheckbox';
 import { isGroupColumns } from '../utils';
 import { DISABLE_ROW_ATTR, dataGridGroupedColumnLabelClassnames, dataGridRowCellClassnames, dataGridRowClassnames, dataGridRowContentClassnames, } from './constants';
 import { NestedChildren } from './NestedChildren';
@@ -57,17 +57,17 @@ const singleCellCva = cva(dataGridRowCellClassnames.single, {
  * который позволяет полностью контролировать рендер каждой строки.
  */
 const RowInner = (props) => {
-    const { isOpen, isShowConnector, childrenColumns, rowId, handleToggle, checkboxProps, rowProps, isHovered, tooltipProps, nestedChildrenProps, disabled, isRenderCollapseButton, rowRef, rowStyles, drawerProps, disabledReasonText, isActive, isSelectable, mobileDisplayVariant, rootRowElement, rootRowRef, } = useLogic(props);
-    const { className, row, options, variant, gridColumns, isInitialExpanded, expandedLevel, level, nestedChildren, initialVisibleChildrenCount, moreButtonColumnPosition, isVisibleCollapseButton, columns, emptyCellValue, activeRowId, keyId, onSelectRow, onRowClick, sectionOffset, totalColumnsCount, registerRowElement, unregisterRowElement, onRowEnter, onRowLeave, style, 
+    const { isOpen, isShowConnector, childrenColumns, rowId, handleToggle, checkboxProps, rowProps, isHovered, tooltipProps, nestedChildrenProps, isDisabled, isDisabledLastCell, isRenderCollapseButton, rowRef, rowStyles, drawerProps, disabledReason, isActive, isSelectable, mobileDisplayVariant, rootRowElement, rootRowRef, } = useLogic(props);
+    const { className, row, options, variant, gridColumns, isInitialExpanded, expandedLevel, level, nestedChildren, initialVisibleChildrenCount, moreButtonColumnPosition, isVisibleCollapseButton, columns, emptyCellValue, activeRowId, keyId, onSelectRow, onRowClick, sectionOffset, totalColumnsCount, registerRowElement, unregisterRowElement, onRowEnter, onRowLeave, style, getRowDisabled, isNested, 
     // В этот rest-оператор попадают специфичные пропсы (атрибуты) virtuoso
     // Необходимы для DataGridInfinite
     ...selfProps } = props;
-    const { isDisabledLastCell = true, isNotSelectable, href, target, } = options || {};
+    const { isNotSelectable, href, target } = options || {};
     const renderStartAdornment = () => {
         if (!isRenderCollapseButton && (!isSelectable || isNotSelectable)) {
             return null;
         }
-        return (_jsxs(_Fragment, { children: [isRenderCollapseButton && (_jsx(CollapseCell, { children: _jsx(CollapseButton, { variant: "text", onClick: handleToggle, children: _jsx(ChevronIcon, { "$isActive": isOpen }) }) })), isSelectable && !isNotSelectable && (_jsx(CheckboxCell, { ...getInertProps(disabled), onClick: (event) => event.stopPropagation(), className: dataGridRowClassnames.checkbox, children: _jsx(Checkbox, { ...checkboxProps }) }))] }));
+        return (_jsxs(_Fragment, { children: [isRenderCollapseButton && (_jsx(CollapseCell, { children: _jsx(CollapseButton, { variant: "text", onClick: handleToggle, children: _jsx(ChevronIcon, { "$isActive": isOpen }) }) })), isSelectable && !isNotSelectable && (_jsx(CheckboxCell, { ...getInertProps(isDisabled), onClick: (event) => event.stopPropagation(), className: dataGridRowClassnames.checkbox, children: _jsx(RowCheckbox, { ...checkboxProps }) }))] }));
     };
     const renderCells = useCallback(() => {
         const lastCellGlobalIndex = (totalColumnsCount ?? columns.length) - 1;
@@ -77,7 +77,7 @@ const RowInner = (props) => {
         return columns?.map((cell, index) => {
             const cellId = `${rowId}-${index}`;
             const globalIndex = (sectionOffset ?? 0) + index;
-            const isDisabledCell = checkIsDisabled(disabled, availableCellsByIndex, globalIndex);
+            const isDisabledCell = checkIsDisabled(isDisabled, availableCellsByIndex, globalIndex);
             const isFirstCell = globalIndex === 0;
             if (isGroupColumns(cell)) {
                 const { label, children, hideTitleOnMobile, isHideOnMobile } = cell;
@@ -95,13 +95,16 @@ const RowInner = (props) => {
         row,
         isOpen,
         columns,
-        disabled,
+        isDisabled,
+        isDisabledLastCell,
         checkboxProps.checked,
+        checkboxProps.disabled,
+        checkboxProps.disabledReason,
         totalColumnsCount,
         sectionOffset,
         rootRowElement,
     ]);
-    const renderRow = useCallback(({ key, ...nestedRowProps }) => (_jsx(RowInner, { keyId: keyId, ...nestedRowProps, variant: variant, isSelectable: isSelectable, gridColumns: gridColumns, isInitialExpanded: isInitialExpanded, expandedLevel: expandedLevel, initialVisibleChildrenCount: initialVisibleChildrenCount, moreButtonColumnPosition: moreButtonColumnPosition, isVisibleCollapseButton: isVisibleCollapseButton, activeRowId: activeRowId, columns: childrenColumns, onSelectRow: onSelectRow, onRowClick: onRowClick, totalColumnsCount: totalColumnsCount, registerRowElement: registerRowElement, unregisterRowElement: unregisterRowElement, onRowEnter: onRowEnter, onRowLeave: onRowLeave, sectionOffset: sectionOffset }, key)), [
+    const renderRow = useCallback(({ key, ...nestedRowProps }) => (_jsx(RowInner, { keyId: keyId, ...nestedRowProps, variant: variant, isSelectable: isSelectable, gridColumns: gridColumns, isInitialExpanded: isInitialExpanded, expandedLevel: expandedLevel, initialVisibleChildrenCount: initialVisibleChildrenCount, moreButtonColumnPosition: moreButtonColumnPosition, isVisibleCollapseButton: isVisibleCollapseButton, activeRowId: activeRowId, columns: childrenColumns, onSelectRow: onSelectRow, onRowClick: onRowClick, totalColumnsCount: totalColumnsCount, registerRowElement: registerRowElement, unregisterRowElement: unregisterRowElement, onRowEnter: onRowEnter, onRowLeave: onRowLeave, sectionOffset: sectionOffset, getRowDisabled: getRowDisabled, isNested: true }, key)), [
         keyId,
         variant,
         isSelectable,
@@ -120,11 +123,12 @@ const RowInner = (props) => {
         unregisterRowElement,
         onRowEnter,
         onRowLeave,
+        getRowDisabled,
     ]);
     return (_jsxs(Wrapper, { className: cn(className, rootCva({
             isShowConnector,
             mobileDisplayVariant,
             hasNestedChildren: Boolean(nestedChildren?.length),
-        })), style: rowStyles, ...selfProps, ref: rootRowRef, children: [_jsx(Tooltip, { followCursor: true, arrow: false, ...tooltipProps, children: _jsx(ContentWrapper, { "data-row-id": rowId, ref: rowRef, onPointerEnter: () => onRowEnter?.(rowId), onPointerLeave: (event) => onRowLeave?.(rowId, event.nativeEvent), className: rowContentCva({ isHovered, isActive }), "$gridColumns": gridColumns, [DISABLE_ROW_ATTR]: disabled, ...rowProps, children: renderCells() }) }), _jsx(NestedChildren, { ...nestedChildrenProps, data: nestedChildren, keyId: keyId, level: level, variant: variant, gridColumns: gridColumns, initialVisibleChildrenCount: initialVisibleChildrenCount, moreButtonColumnPosition: moreButtonColumnPosition, renderRow: renderRow }), _jsx(BottomDrawer, { ...drawerProps, children: _jsx(BottomDrawerContent, { children: disabledReasonText }) })] }, `row-${rowId}`));
+        })), style: rowStyles, ...selfProps, ref: rootRowRef, children: [_jsx(Tooltip, { followCursor: true, arrow: false, ...tooltipProps, children: _jsx(ContentWrapper, { "data-row-id": rowId, ref: rowRef, onPointerEnter: () => onRowEnter?.(rowId), onPointerLeave: (event) => onRowLeave?.(rowId, event.nativeEvent), className: rowContentCva({ isHovered, isActive }), "$gridColumns": gridColumns, [DISABLE_ROW_ATTR]: isDisabled, ...rowProps, children: renderCells() }) }), _jsx(NestedChildren, { ...nestedChildrenProps, data: nestedChildren, keyId: keyId, level: level, variant: variant, gridColumns: gridColumns, initialVisibleChildrenCount: initialVisibleChildrenCount, moreButtonColumnPosition: moreButtonColumnPosition, renderRow: renderRow }), _jsx(BottomDrawer, { ...drawerProps, children: _jsx(BottomDrawerContent, { children: disabledReason }) })] }, `row-${rowId}`));
 };
 export const Row = memo(RowInner);

package/components/DataGrid/Row/RowContext/RowContext.d.ts

@@ -1,10 +1,17 @@
 import { type ChangeEvent } from 'react';
+import { type DataGridRowDisabled } from '../../types';
 export type RowContextProps = {
-    isDisabled: boolean;
+    /**
+     * Если true, в строке выполняется блокирующее действие DataGridActionCell
+     */
+    hasBlockingAction: boolean;
+    /**
+     * Причина блокировки от блокирующего действия
+     */
+    blockingActionReason?: string;
+    addBlockingAction: (reason?: string) => void;
+    removeBlockingAction: () => void;
     isSelectable?: boolean;
-    disabledReason?: string;
-    addDisabledRow: (disabledReason?: string) => void;
-    removeDisabledRow: () => void;
     row: Record<string, unknown>;
     onSelectRow: (row: Record<string, unknown>) => (event: ChangeEvent<HTMLInputElement>) => void;
     onRowEnter?: (rowId: string) => void;
@@ -13,5 +20,9 @@ export type RowContextProps = {
     unregisterRowElement?: (rowId: string, el: HTMLElement) => void;
     itemProps?: object;
     isSelected?: boolean;
+    /**
+     * Итоговая блокировка строки, рассчитанная resolveRowDisabled
+     */
+    rowDisabled?: DataGridRowDisabled;
 };
 export declare const RowContext: import("react").Context<RowContextProps>;

package/components/DataGrid/Row/RowContext/RowContext.js

@@ -1,9 +1,9 @@
 import { createContext } from 'react';
 export const RowContext = createContext({
-    isDisabled: false,
+    hasBlockingAction: false,
     isSelectable: false,
-    addDisabledRow: () => undefined,
-    removeDisabledRow: () => undefined,
+    addBlockingAction: () => undefined,
+    removeBlockingAction: () => undefined,
     row: {},
     onSelectRow: () => () => undefined,
     onRowEnter: () => undefined,

package/components/DataGrid/Row/RowContext/RowProvider/RowProvider.d.ts

@@ -1,7 +1,16 @@
 import { type ReactNode } from 'react';
+import { type DataGridRowDisabled } from '../../../types';
 import { type RowContextProps } from '../RowContext';
 type RowContextProviderProps = Pick<RowContextProps, 'row' | 'itemProps' | 'onSelectRow' | 'onRowEnter' | 'onRowLeave' | 'registerRowElement' | 'unregisterRowElement' | 'isSelectable' | 'isSelected'> & {
+    /**
+     * Режим блокировки строки
+     */
+    disabledMode?: DataGridRowDisabled['mode'];
+    /**
+     * Причина блокировки строки
+     */
+    disabledReason?: string;
     children: ReactNode;
 };
-export declare const RowContextProvider: ({ row, itemProps, onSelectRow, onRowEnter, onRowLeave, registerRowElement, unregisterRowElement, children, isSelectable, isSelected, }: RowContextProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const RowContextProvider: ({ row, itemProps, onSelectRow, onRowEnter, onRowLeave, registerRowElement, unregisterRowElement, children, isSelectable, isSelected, disabledMode, disabledReason, }: RowContextProviderProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/components/DataGrid/Row/RowContext/RowProvider/RowProvider.js

@@ -1,23 +1,27 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useCallback, useMemo, useState } from 'react';
 import { RowContext } from '../RowContext';
-export const RowContextProvider = ({ row, itemProps, onSelectRow, onRowEnter, onRowLeave, registerRowElement, unregisterRowElement, children, isSelectable, isSelected, }) => {
-    const [isDisabled, setDisabled] = useState(false);
-    const [disabledReason, setDisabledReason] = useState();
-    const addDisabledRow = useCallback((reason) => {
-        setDisabled(true);
-        setDisabledReason(reason);
+export const RowContextProvider = ({ row, itemProps, onSelectRow, onRowEnter, onRowLeave, registerRowElement, unregisterRowElement, children, isSelectable, isSelected, disabledMode, disabledReason, }) => {
+    const [hasBlockingAction, setHasBlockingAction] = useState(false);
+    const [blockingActionReason, setBlockingActionReason] = useState();
+    const addBlockingAction = useCallback((reason) => {
+        setHasBlockingAction(true);
+        setBlockingActionReason(reason);
     }, []);
-    const removeDisabledRow = useCallback(() => {
-        setDisabled(false);
-        setDisabledReason(undefined);
+    const removeBlockingAction = useCallback(() => {
+        setHasBlockingAction(false);
+        setBlockingActionReason(undefined);
     }, []);
+    // Блокировка приходит примитивами, чтобы новый объект с тем же содержимым не обновлял контекст
+    const rowDisabled = useMemo(() => disabledMode
+        ? { mode: disabledMode, reason: disabledReason ?? '' }
+        : undefined, [disabledMode, disabledReason]);
     const contextValue = useMemo(() => ({
-        isDisabled,
+        hasBlockingAction,
+        blockingActionReason,
+        addBlockingAction,
+        removeBlockingAction,
         isSelectable,
-        disabledReason,
-        addDisabledRow,
-        removeDisabledRow,
         row,
         itemProps,
         onSelectRow,
@@ -26,12 +30,13 @@ export const RowContextProvider = ({ row, itemProps, onSelectRow, onRowEnter, on
         registerRowElement,
         unregisterRowElement,
         isSelected,
+        rowDisabled,
     }), [
-        isDisabled,
+        hasBlockingAction,
+        blockingActionReason,
+        addBlockingAction,
+        removeBlockingAction,
         isSelectable,
-        disabledReason,
-        addDisabledRow,
-        removeDisabledRow,
         row,
         itemProps,
         onSelectRow,
@@ -40,6 +45,7 @@ export const RowContextProvider = ({ row, itemProps, onSelectRow, onRowEnter, on
         registerRowElement,
         unregisterRowElement,
         isSelected,
+        rowDisabled,
     ]);
     return (_jsx(RowContext.Provider, { value: contextValue, children: children }));
 };

package/components/DataGrid/Row/types.d.ts

@@ -1,6 +1,6 @@
 import { type ChangeEvent, type CSSProperties, type ReactNode } from 'react';
 import { type Variant } from '../enums';
-import { type CellValue, type DataGridColumns, type DataGridRowOptions } from '../types';
+import { type CellValue, type DataGridColumns, type DataGridProps, type DataGridRowOptions } from '../types';
 export type RowProps<TData extends Record<string, CellValue>> = {
     /**
      * Название класса, применяется к корневому компоненту
@@ -71,9 +71,13 @@ export type RowProps<TData extends Record<string, CellValue>> = {
      */
     isSelected?: boolean;
     /**
-     * Массив выбранных строк
+     * Если true, строка вложенная и сама вычисляет блокировку
      */
-    selectedRows?: TData[];
+    isNested?: boolean;
+    /**
+     * Функция блокировки для вложенных строк. Передаётся только строкам с дочерними элементами
+     */
+    getRowDisabled?: DataGridProps<TData>['getRowDisabled'];
     /**
      * Заглушка для пустых ячеек (если отсутствует field и filter и renderCell)
      * @default '-'

package/components/DataGrid/Row/useLogic/useLogic.d.ts

@@ -2,8 +2,8 @@ import { type MouseEvent, type SyntheticEvent } from 'react';
 import type { CellValue } from '../../types';
 import type { RowProps } from '../types';
 type UseLogicParams<TData extends Record<string, CellValue>> = RowProps<TData>;
-export declare const useLogic: <TData extends Record<string, unknown>>({ keyId, columns, row, nestedChildren, level, variant, options, isInitialExpanded, expandedLevel, isSelectable, isSelected, onSelectRow, onRowClick, isVisibleCollapseButton, registerRowElement, unregisterRowElement, style, activeRowId, }: UseLogicParams<TData>) => {
-    disabledReasonText: string | undefined;
+export declare const useLogic: <TData extends Record<string, unknown>>({ keyId, columns, row, nestedChildren, level, variant, options, isInitialExpanded, expandedLevel, isSelectable, isSelected, getRowDisabled, isNested, onSelectRow, onRowClick, isVisibleCollapseButton, registerRowElement, unregisterRowElement, style, activeRowId, }: UseLogicParams<TData>) => {
+    disabledReason: string | undefined;
     rowStyles: {
         accentColor?: import("csstype").Property.AccentColor | undefined;
         alignContent?: import("csstype").Property.AlignContent | undefined;
@@ -869,7 +869,8 @@ export declare const useLogic: <TData extends Record<string, unknown>>({ keyId,
     childrenColumns: any[];
     rowId: string;
     rowRef: (element: HTMLElement | null) => void;
-    disabled: boolean | undefined;
+    isDisabled: boolean;
+    isDisabledLastCell: boolean;
     isSelectable: boolean | undefined;
     isRenderCollapseButton: boolean;
     handleToggle: (event: MouseEvent<HTMLButtonElement>) => void;
@@ -895,7 +896,8 @@ export declare const useLogic: <TData extends Record<string, unknown>>({ keyId,
     };
     checkboxProps: {
         checked: boolean | undefined;
-        disabled: boolean | undefined;
+        disabled: boolean;
+        disabledReason: string | undefined;
         onChange: (event: import("react").ChangeEvent<HTMLInputElement, Element>) => void;
     };
     nestedChildrenProps: {

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

@@ -1,11 +1,12 @@
 import { useCallback, useContext, useMemo, useRef, useState, } from 'react';
 import { DataGridContext } from '../../DataGridContext';
 import { Variant } from '../../enums';
+import { getRowDisabledState, resolveRowDisabled } from '../../utils';
 import { DISABLE_ROW_ATTR } from '../constants';
 import { RowContext } from '../RowContext';
 import { useMobileLogic } from './hooks';
 import { mergeColumnsOptions } from './utils';
-export const useLogic = ({ keyId, columns, row, nestedChildren, level, variant, options, isInitialExpanded = false, expandedLevel, isSelectable, isSelected, onSelectRow, onRowClick, isVisibleCollapseButton, registerRowElement, unregisterRowElement, style, activeRowId, }) => {
+export const useLogic = ({ keyId, columns, row, nestedChildren, level, variant, options, isInitialExpanded = false, expandedLevel, isSelectable, isSelected, getRowDisabled, isNested = false, onSelectRow, onRowClick, isVisibleCollapseButton, registerRowElement, unregisterRowElement, style, activeRowId, }) => {
     const { isDrawerOpen, handleOpenDrawer, handleCloseDrawer } = useMobileLogic();
     const [rootRowElement, setRootRowElement] = useState(null);
     const rootRowRef = useCallback((element) => {
@@ -15,7 +16,7 @@ export const useLogic = ({ keyId, columns, row, nestedChildren, level, variant,
     }, []);
     const isDefaultExpanded = Boolean(isInitialExpanded && level <= expandedLevel - 1 && nestedChildren?.length);
     const { mobileDisplayVariant } = useContext(DataGridContext);
-    const { isDisabled, disabledReason } = useContext(RowContext);
+    const { hasBlockingAction, blockingActionReason, rowDisabled: contextRowDisabled, } = useContext(RowContext);
     const [isOpen, setIsOpen] = useState(isDefaultExpanded);
     const savedElementRef = useRef(null);
     const rowRef = (element) => {
@@ -30,10 +31,17 @@ export const useLogic = ({ keyId, columns, row, nestedChildren, level, variant,
     };
     const [isVisibleTooltip, setVisibleTooltip] = useState(false);
     const rowId = row[keyId];
-    const { isDisabled: isExternalDisabled, disabledReason: externalDisabledReason, href, } = options || {};
-    const disabled = isDisabled || isExternalDisabled;
+    const { href } = options || {};
+    // Блокировку строки из rows таблица передаёт через контекст, вложенная строка считает её сама и не наследует блокировку родителя
+    const rowDisabled = useMemo(() => isNested ? resolveRowDisabled(row, getRowDisabled) : contextRowDisabled, [isNested, row, getRowDisabled, contextRowDisabled]);
+    const { isDisabled, isDisabledLastCell, disabledReason, isCheckboxDisabled, checkboxDisabledReason, } = getRowDisabledState({
+        rowDisabled,
+        hasBlockingAction,
+        blockingActionReason,
+        isDisabledLastCellOption: options?.isDisabledLastCell,
+    });
     const handleRowClick = () => {
-        if (disabled) {
+        if (isDisabled) {
             handleOpenDrawer();
             return undefined;
         }
@@ -54,7 +62,7 @@ export const useLogic = ({ keyId, columns, row, nestedChildren, level, variant,
     };
     const handleCloseTooltip = () => setVisibleTooltip(false);
     const handleMouseMove = (event) => {
-        if (!disabled) {
+        if (!isDisabled) {
             return;
         }
         const element = event.target;
@@ -68,19 +76,19 @@ export const useLogic = ({ keyId, columns, row, nestedChildren, level, variant,
         '--level': level,
         ...style,
     }), [level, style]);
-    const isHovered = Boolean(!disabled && (onRowClick || href));
+    const isHovered = Boolean(!isDisabled && (onRowClick || href));
     const isActive = activeRowId === rowId;
-    const disabledReasonText = externalDisabledReason || disabledReason;
     const handleCheckboxChange = useMemo(() => onSelectRow(row), [onSelectRow, row]);
     return {
-        disabledReasonText,
+        disabledReason,
         rowStyles,
         isOpen,
         isShowConnector,
         childrenColumns,
         rowId,
         rowRef,
-        disabled,
+        isDisabled,
+        isDisabledLastCell,
         isSelectable,
         isRenderCollapseButton,
         handleToggle,
@@ -100,13 +108,14 @@ export const useLogic = ({ keyId, columns, row, nestedChildren, level, variant,
         },
         tooltipProps: {
             open: isVisibleTooltip,
-            title: disabled ? disabledReasonText : undefined,
+            title: isDisabled ? disabledReason : undefined,
             onOpen: handleOpenTooltip,
             onClose: handleCloseTooltip,
         },
         checkboxProps: {
             checked: isSelected,
-            disabled,
+            disabled: isCheckboxDisabled,
+            disabledReason: checkboxDisabledReason,
             onChange: handleCheckboxChange,
         },
         nestedChildrenProps: {

package/components/DataGrid/RowBase/RowBase.js

@@ -1,7 +1,6 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { memo, useCallback } from 'react';
 import { BottomDrawer } from '../../BottomDrawer';
-import { Checkbox } from '../../Checkbox';
 import { Tooltip } from '../../Tooltip';
 import { cn } from '../../utils/cn';
 import { cva } from '../../utils/cva';
@@ -9,6 +8,7 @@ import { getInertProps } from '../../utils/getInertProps';
 import { Cell } from '../Cell';
 import { DISABLE_ROW_ATTR, dataGridRowClassnames } from '../Row/constants';
 import { checkIsDisabled } from '../Row/utils';
+import { RowCheckbox } from '../RowCheckbox';
 import { isGroupColumns } from '../utils';
 import { dataGridRowBaseClassnames } from './constants';
 import { GroupCell } from './GroupCell';
@@ -40,7 +40,7 @@ export const RowBase = memo((props) => {
         if (!adornment && !shouldRenderCheckbox) {
             return null;
         }
-        return (_jsxs(_Fragment, { children: [adornment, shouldRenderCheckbox && (_jsx(CheckboxCell, { ...getInertProps(isDisabled), onClick: (event) => event.stopPropagation(), className: dataGridRowClassnames.checkbox, children: _jsx(Checkbox, { ...checkboxProps }) }))] }));
+        return (_jsxs(_Fragment, { children: [adornment, shouldRenderCheckbox && (_jsx(CheckboxCell, { ...getInertProps(isDisabled), onClick: (event) => event.stopPropagation(), className: dataGridRowClassnames.checkbox, children: _jsx(RowCheckbox, { ...checkboxProps }) }))] }));
     };
     const renderCells = useCallback(() => {
         const lastCellGlobalIndex = columns.length - 1;
@@ -61,9 +61,12 @@ export const RowBase = memo((props) => {
         row,
         columns,
         isDisabled,
+        isDisabledLastCell,
         sectionOffset,
         renderStartAdornment,
         checkboxProps.checked,
+        checkboxProps.disabled,
+        checkboxProps.disabledReason,
     ]);
     return (_jsxs(Wrapper, { className: cn(className, rootCva({ mobileDisplayVariant })), style: rowBaseVars, ...dataGridInfiniteItemProps, children: [_jsx(Tooltip, { ...tooltipProps, children: _jsx(ContentWrapper, { ref: rowRef, onPointerEnter: () => onRowEnter?.(rowId), onPointerLeave: (event) => onRowLeave?.(rowId, event.nativeEvent), className: contentWrapperCva({ isHovered, isActive }), [DISABLE_ROW_ATTR]: isDisabled, onClick: handleRowClick, children: renderCells() }) }), customContent, _jsx(BottomDrawer, { ...drawerProps, children: _jsx(BottomDrawerContent, { children: drawerContent }) })] }, `row-base-${rowId}`));
 });

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

@@ -1,5 +1,5 @@
 import { type ChangeEvent, type ReactNode } from 'react';
-import type { DataGridColumns, DataGridRowWithOptions } from '../types';
+import type { DataGridColumns, DataGridRowDisabled, DataGridRowWithOptions } from '../types';
 export type RowBaseProps = {
     /**
      * Массив колонок
@@ -42,13 +42,17 @@ export type RowBaseProps = {
      */
     isSelected?: boolean;
     /**
-     * Заблокирована ли строка
+     * Если true, в строке выполняется блокирующее действие DataGridActionCell
      */
-    isDisabled?: boolean;
+    hasBlockingAction?: boolean;
     /**
-     * Причина блокировки строки
+     * Причина блокировки от блокирующего действия
      */
-    disabledReason?: string;
+    blockingActionReason?: string;
+    /**
+     * Итоговая блокировка строки, рассчитанная resolveRowDisabled
+     */
+    rowDisabled?: DataGridRowDisabled;
     /**
      * Обработчик выбора строки
      */

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

@@ -1,7 +1,7 @@
 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) => {
+export declare const useLogic: ({ className, row, keyId, onRowClick, columns, sectionOffset, customContent, renderStartAdornment, isSelected, hasBlockingAction, blockingActionReason, rowDisabled, onSelectRow, onRowEnter, onRowLeave, registerRowElement, unregisterRowElement, gridColumns, activeRowId, emptyCellValue, isSelectable, rowId, mobileDisplayVariant, ...dataGridInfiniteItemProps }: UseLogicParams) => {
     handleRowClick: () => void;
     tooltipProps: {
         open: boolean;
@@ -13,7 +13,8 @@ export declare const useLogic: ({ className, row, keyId, onRowClick, columns, se
     };
     checkboxProps: {
         checked: boolean | undefined;
-        disabled: boolean | undefined;
+        disabled: boolean;
+        disabledReason: string | undefined;
         onChange: (event: import("react").ChangeEvent<HTMLInputElement, Element>) => void;
     };
     drawerProps: {
@@ -34,10 +35,10 @@ export declare const useLogic: ({ className, row, keyId, onRowClick, columns, se
     onRowLeave: ((rowId: string, event: PointerEvent) => void) | undefined;
     rowId: string;
     row: import("../..").DataGridRowWithOptions<Record<string, unknown>>;
-    isDisabled: boolean | undefined;
+    isDisabled: boolean;
     sectionOffset: number | undefined;
     customContent: import("react").ReactNode;
-    isDisabledLastCell: boolean | undefined;
+    isDisabledLastCell: boolean;
     renderStartAdornment: ((isFirstCell: boolean) => import("react").ReactNode) | undefined;
     isSelectable: boolean | undefined;
     isNotSelectable: boolean | undefined;