@astral/ui 4.114.0 → 4.115.1

package/components/DataGrid/tests/selection/testDataGridSelection.js

@@ -0,0 +1,562 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+import { screen, userEvents, within } from '@ui/dev/tests';
+import { act } from 'react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { tooltipClassnames } from '../../../Tooltip';
+import { DISABLE_ROW_ATTR } from '../../Row/constants';
+const COLUMNS = [
+    { field: 'name', label: 'Наименование' },
+];
+const COLUMNS_WITH_ACTION = [
+    { field: 'name', label: 'Наименование' },
+    {
+        label: 'Действия',
+        renderCell: ({ name }) => _jsxs("button", { type: "button", children: ["\u041E\u0442\u043A\u0440\u044B\u0442\u044C ", name] }),
+    },
+];
+const FIRST_PAGE_ROWS = [
+    { id: '1', name: 'Договор №1' },
+    { id: '2', name: 'Договор №2' },
+];
+const SECOND_PAGE_ROWS = [
+    { id: '3', name: 'Договор №3' },
+    { id: '4', name: 'Договор №4' },
+];
+const NUMERIC_ID_ROWS = [{ id: 1, name: 'Договор №1' }];
+const SELECTION_DISABLED = {
+    mode: 'selection',
+    reason: 'Документ отправляется',
+};
+const ROW_DISABLED = {
+    mode: 'row',
+    reason: 'Нет доступа',
+};
+const ROW_EXCEPT_LAST_CELL_DISABLED = {
+    mode: 'row-except-last-cell',
+    reason: 'Нет доступа',
+};
+const SELECTION_DISABLED_WITHOUT_REASON = {
+    mode: 'selection',
+    reason: '',
+};
+const ROW_DISABLED_WITHOUT_REASON = {
+    mode: 'row',
+    reason: '',
+};
+const INERT_BY_MODE_CASES = [
+    { mode: 'row', isInertCell: true, isInertLastCell: true },
+    { mode: 'row-except-last-cell', isInertCell: true, isInertLastCell: false },
+    { mode: 'selection', isInertCell: false, isInertLastCell: false },
+];
+const NESTED_ROWS = [
+    {
+        id: '1',
+        name: 'Пакет документов',
+        children: [{ id: '1-1', name: 'Вложенный договор' }],
+    },
+];
+const getSelectAllCheckbox = () => within(screen.getByRole('heading')).getByRole('checkbox');
+// closest берёт ближайшую строку, поэтому для вложенной строки не находится родительская
+const getRowCheckbox = (name) => {
+    const row = screen.getByText(name).closest('li');
+    if (!row) {
+        throw new Error(`Строка «${name}» не найдена`);
+    }
+    return within(row).getByRole('checkbox');
+};
+// Заблокированная ячейка недоступна через атрибут inert
+const checkIsInert = (element) => Boolean(element.closest('[inert]'));
+const getActionButton = (name) => screen.getByRole('button', { name: `Открыть ${name}` });
+const getRowContent = (name) => {
+    const rowContent = screen.getByText(name).closest(`[${DISABLE_ROW_ATTR}]`);
+    if (!(rowContent instanceof HTMLElement)) {
+        throw new Error(`Содержимое строки «${name}» не найдено`);
+    }
+    return rowContent;
+};
+export const testDataGridSelection = ({ render, renderGrid, }) => {
+    const setup = (props = {}) => {
+        const onSelectRowSpy = vi.fn();
+        const renderUi = (nextProps) => renderGrid({
+            rows: FIRST_PAGE_ROWS,
+            columns: COLUMNS,
+            onSelectRow: onSelectRowSpy,
+            onRetry: () => { },
+            ...nextProps,
+        });
+        const view = render(renderUi(props));
+        const rerenderGrid = (nextProps) => view.rerender(renderUi(nextProps));
+        return { onSelectRowSpy, rerenderGrid };
+    };
+    it('Выбор строк предыдущей страницы сохраняется при выборе строки на новой странице', async () => {
+        const { onSelectRowSpy } = setup({
+            rows: SECOND_PAGE_ROWS,
+            selectedRows: [FIRST_PAGE_ROWS[0]],
+        });
+        await userEvents.click(getRowCheckbox('Договор №3'));
+        expect(onSelectRowSpy).toHaveBeenCalledWith([
+            FIRST_PAGE_ROWS[0],
+            SECOND_PAGE_ROWS[0],
+        ]);
+    });
+    it('Строки отмечены выбранными при возврате на страницу с выбранными строками', () => {
+        const selectedRows = [FIRST_PAGE_ROWS[0]];
+        const { rerenderGrid } = setup({
+            rows: SECOND_PAGE_ROWS,
+            selectedRows,
+        });
+        rerenderGrid({ rows: FIRST_PAGE_ROWS, selectedRows });
+        expect(getRowCheckbox('Договор №1')).toBeChecked();
+    });
+    it('Строка выбрана при числовом keyId', () => {
+        setup({ rows: NUMERIC_ID_ROWS, selectedRows: NUMERIC_ID_ROWS });
+        expect(getRowCheckbox('Договор №1')).toBeChecked();
+    });
+    it('«Выбрать все» не отмечен при selectedRows только из строк вне выдачи', () => {
+        setup({ selectedRows: SECOND_PAGE_ROWS });
+        expect(getSelectAllCheckbox()).not.toBeChecked();
+    });
+    describe('onSelectRow не вызывается', () => {
+        it('При новом массиве selectedRows', () => {
+            const { rerenderGrid, onSelectRowSpy } = setup({
+                selectedRows: [FIRST_PAGE_ROWS[0]],
+            });
+            rerenderGrid({ selectedRows: [FIRST_PAGE_ROWS[1]] });
+            expect(onSelectRowSpy).not.toHaveBeenCalled();
+        });
+        it('При новом массиве rows с теми же строками', () => {
+            const { rerenderGrid, onSelectRowSpy } = setup({
+                selectedRows: [FIRST_PAGE_ROWS[0]],
+            });
+            rerenderGrid({
+                rows: [...FIRST_PAGE_ROWS],
+                selectedRows: [FIRST_PAGE_ROWS[0]],
+            });
+            expect(onSelectRowSpy).not.toHaveBeenCalled();
+        });
+        it('При новой функции getRowDisabled', () => {
+            const selectedRows = [FIRST_PAGE_ROWS[0]];
+            const { rerenderGrid, onSelectRowSpy } = setup({
+                selectedRows,
+                getRowDisabled: () => undefined,
+            });
+            rerenderGrid({
+                selectedRows,
+                getRowDisabled: () => SELECTION_DISABLED,
+            });
+            expect(onSelectRowSpy).not.toHaveBeenCalled();
+        });
+    });
+    describe('Выбрать все', () => {
+        it('Выбор строк других страниц сохраняется', async () => {
+            const { onSelectRowSpy } = setup({
+                rows: SECOND_PAGE_ROWS,
+                selectedRows: [FIRST_PAGE_ROWS[0]],
+            });
+            await userEvents.click(getSelectAllCheckbox());
+            expect(onSelectRowSpy).toHaveBeenCalledWith([
+                FIRST_PAGE_ROWS[0],
+                ...SECOND_PAGE_ROWS,
+            ]);
+        });
+        it.each([
+            { condition: 'mode=selection', rowDisabled: SELECTION_DISABLED },
+            { condition: 'mode=row', rowDisabled: ROW_DISABLED },
+            {
+                condition: 'mode=row-except-last-cell',
+                rowDisabled: ROW_EXCEPT_LAST_CELL_DISABLED,
+            },
+            {
+                condition: 'options.isDisabled=true',
+                options: { isDisabled: true },
+            },
+            {
+                condition: 'isNotSelectable=true',
+                options: { isNotSelectable: true },
+            },
+        ])('Строка с $condition не выбирается', async ({ rowDisabled, options }) => {
+            const rows = [
+                FIRST_PAGE_ROWS[0],
+                { ...FIRST_PAGE_ROWS[1], options },
+            ];
+            const { onSelectRowSpy } = setup({
+                rows,
+                selectedRows: [],
+                getRowDisabled: rowDisabled
+                    ? (row) => (row.id === '2' ? rowDisabled : undefined)
+                    : undefined,
+            });
+            await userEvents.click(getSelectAllCheckbox());
+            expect(onSelectRowSpy).toHaveBeenCalledWith([FIRST_PAGE_ROWS[0]]);
+        });
+        it('Чекбокс отмечен, если выбраны все доступные строки', () => {
+            setup({
+                selectedRows: [FIRST_PAGE_ROWS[0]],
+                getRowDisabled: (row) => row.id === '2' ? SELECTION_DISABLED : undefined,
+            });
+            expect(getSelectAllCheckbox()).toBeChecked();
+        });
+        it('Чекбокс в неопределённом состоянии при выборе части доступных строк', () => {
+            setup({ selectedRows: [FIRST_PAGE_ROWS[0]] });
+            expect(getSelectAllCheckbox()).toHaveAttribute('aria-checked', 'mixed');
+        });
+        it('Чекбокс не отмечен, если выбрана только строка с mode=selection', () => {
+            setup({
+                selectedRows: [FIRST_PAGE_ROWS[1]],
+                getRowDisabled: (row) => row.id === '2' ? SELECTION_DISABLED : undefined,
+            });
+            expect(getSelectAllCheckbox()).toHaveAttribute('aria-checked', 'false');
+        });
+        it('Выбранная строка с mode=selection остаётся выбранной', async () => {
+            const { onSelectRowSpy } = setup({
+                selectedRows: [FIRST_PAGE_ROWS[1]],
+                getRowDisabled: (row) => row.id === '2' ? SELECTION_DISABLED : undefined,
+            });
+            await userEvents.click(getSelectAllCheckbox());
+            expect(onSelectRowSpy).toHaveBeenCalledWith([
+                FIRST_PAGE_ROWS[1],
+                FIRST_PAGE_ROWS[0],
+            ]);
+        });
+    });
+    describe('Снятие «Выбрать все»', () => {
+        it('Выбор строк других страниц сохраняется', async () => {
+            const { onSelectRowSpy } = setup({
+                selectedRows: [SECOND_PAGE_ROWS[0], ...FIRST_PAGE_ROWS],
+            });
+            await userEvents.click(getSelectAllCheckbox());
+            expect(onSelectRowSpy).toHaveBeenCalledWith([SECOND_PAGE_ROWS[0]]);
+        });
+        it('Выбор строки с mode=selection снимается', async () => {
+            const { onSelectRowSpy } = setup({
+                selectedRows: FIRST_PAGE_ROWS,
+                getRowDisabled: (row) => row.id === '2' ? SELECTION_DISABLED : undefined,
+            });
+            await userEvents.click(getSelectAllCheckbox());
+            expect(onSelectRowSpy).toHaveBeenCalledWith([]);
+        });
+    });
+    describe('Выбранная строка с mode=selection', () => {
+        const setupSelectedDisabledRow = () => setup({
+            selectedRows: [FIRST_PAGE_ROWS[1]],
+            getRowDisabled: (row) => row.id === '2' ? SELECTION_DISABLED : undefined,
+        });
+        it('Чекбокс строки отмечен', () => {
+            setupSelectedDisabledRow();
+            expect(getRowCheckbox('Договор №2')).toBeChecked();
+        });
+        it('Чекбокс строки заблокирован', () => {
+            setupSelectedDisabledRow();
+            expect(getRowCheckbox('Договор №2')).toBeDisabled();
+        });
+    });
+    describe('Блокировка через getRowDisabled', () => {
+        it('Чекбокс строки заблокирован при mode=selection', () => {
+            setup({
+                getRowDisabled: (row) => row.id === '1' ? SELECTION_DISABLED : undefined,
+            });
+            expect(getRowCheckbox('Договор №1')).toBeDisabled();
+        });
+        it('Чекбокс строки заблокирован при mode=row', () => {
+            setup({
+                getRowDisabled: (row) => (row.id === '1' ? ROW_DISABLED : undefined),
+            });
+            expect(getRowCheckbox('Договор №1')).toBeDisabled();
+        });
+        it('onSelectRow не вызывается при клике по checkbox с mode=selection', async () => {
+            const { onSelectRowSpy } = setup({
+                getRowDisabled: (row) => row.id === '1' ? SELECTION_DISABLED : undefined,
+            });
+            await userEvents.click(getRowCheckbox('Договор №1'));
+            expect(onSelectRowSpy).not.toHaveBeenCalled();
+        });
+        it('onRowClick вызывается при клике по строке с mode=selection', async () => {
+            const onRowClickSpy = vi.fn();
+            setup({
+                onRowClick: onRowClickSpy,
+                getRowDisabled: (row) => row.id === '1' ? SELECTION_DISABLED : undefined,
+            });
+            await userEvents.click(screen.getByText('Договор №1'));
+            expect(onRowClickSpy).toHaveBeenCalledWith(FIRST_PAGE_ROWS[0]);
+        });
+        it('onRowClick не вызывается при клике по строке с mode=row', async () => {
+            const onRowClickSpy = vi.fn();
+            setup({
+                onRowClick: onRowClickSpy,
+                getRowDisabled: (row) => (row.id === '1' ? ROW_DISABLED : undefined),
+            });
+            await userEvents.click(screen.getByText('Договор №1'));
+            expect(onRowClickSpy).not.toHaveBeenCalled();
+        });
+        it('onRowClick вызывается при mode=selection и options.isDisabled=true', async () => {
+            const onRowClickSpy = vi.fn();
+            const row = {
+                ...FIRST_PAGE_ROWS[0],
+                options: { isDisabled: true },
+            };
+            setup({
+                rows: [row],
+                onRowClick: onRowClickSpy,
+                getRowDisabled: () => SELECTION_DISABLED,
+            });
+            await userEvents.click(screen.getByText('Договор №1'));
+            expect(onRowClickSpy).toHaveBeenCalledWith(row);
+        });
+        it.each(INERT_BY_MODE_CASES)('Ячейки строки недоступны=$isInertCell при mode=$mode', ({ mode, isInertCell }) => {
+            setup({
+                columns: COLUMNS_WITH_ACTION,
+                getRowDisabled: (row) => row.id === '1' ? { mode, reason: 'Нет доступа' } : undefined,
+            });
+            expect(checkIsInert(screen.getByText('Договор №1'))).toBe(isInertCell);
+        });
+        it.each(INERT_BY_MODE_CASES)('Последняя ячейка недоступна=$isInertLastCell при mode=$mode', ({ mode, isInertLastCell }) => {
+            setup({
+                columns: COLUMNS_WITH_ACTION,
+                getRowDisabled: (row) => row.id === '1' ? { mode, reason: 'Нет доступа' } : undefined,
+            });
+            expect(checkIsInert(getActionButton('Договор №1'))).toBe(isInertLastCell);
+        });
+        it('Ячейки соседней строки доступны при mode=row', () => {
+            setup({
+                columns: COLUMNS_WITH_ACTION,
+                getRowDisabled: (row) => (row.id === '1' ? ROW_DISABLED : undefined),
+            });
+            expect(checkIsInert(screen.getByText('Договор №2'))).toBe(false);
+        });
+        it('Tooltip строки показывает причину при mode=row', async () => {
+            setup({
+                getRowDisabled: (row) => (row.id === '1' ? ROW_DISABLED : undefined),
+            });
+            await userEvents.hover(getRowContent('Договор №1'));
+            expect(await screen.findByRole('tooltip')).toHaveTextContent(ROW_DISABLED.reason);
+        });
+        it('Чекбокс строки с options.isDisabled=true заблокирован, если getRowDisabled её не блокирует', () => {
+            setup({
+                rows: [{ ...FIRST_PAGE_ROWS[0], options: { isDisabled: true } }],
+                getRowDisabled: () => undefined,
+            });
+            expect(getRowCheckbox('Договор №1')).toBeDisabled();
+        });
+    });
+    describe('Блокировка через options без getRowDisabled', () => {
+        it('Чекбокс строки заблокирован при options.isDisabled=true', () => {
+            setup({
+                rows: [{ ...FIRST_PAGE_ROWS[0], options: { isDisabled: true } }],
+            });
+            expect(getRowCheckbox('Договор №1')).toBeDisabled();
+        });
+        it('Ячейки строки, кроме последней, недоступны при options.isDisabledLastCell=false', () => {
+            setup({
+                columns: COLUMNS_WITH_ACTION,
+                rows: [
+                    {
+                        ...FIRST_PAGE_ROWS[0],
+                        options: { isDisabled: true, isDisabledLastCell: false },
+                    },
+                ],
+            });
+            expect(checkIsInert(screen.getByText('Договор №1'))).toBe(true);
+        });
+        it('Tooltip строки показывает options.disabledReason', async () => {
+            setup({
+                rows: [
+                    {
+                        ...FIRST_PAGE_ROWS[0],
+                        options: { isDisabled: true, disabledReason: 'Нет доступа' },
+                    },
+                ],
+            });
+            await userEvents.hover(getRowContent('Договор №1'));
+            expect(await screen.findByRole('tooltip')).toHaveTextContent('Нет доступа');
+        });
+        it('onSelectRow не вызывается при клике по checkbox строки с options.isDisabled=true', async () => {
+            const { onSelectRowSpy } = setup({
+                rows: [{ ...FIRST_PAGE_ROWS[0], options: { isDisabled: true } }],
+            });
+            await userEvents.click(getRowCheckbox('Договор №1'));
+            expect(onSelectRowSpy).not.toHaveBeenCalled();
+        });
+    });
+    describe('Блокировка без причины', () => {
+        const WARN_MESSAGE_PREFIX = 'UIKIT. DataGrid: getRowDisabled вернул блокировку без reason для строк: ';
+        let consoleWarnSpy;
+        beforeEach(() => {
+            consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        });
+        afterEach(() => {
+            consoleWarnSpy.mockRestore();
+        });
+        it('Выводится одно предупреждение со всеми строками без причины', () => {
+            setup({ getRowDisabled: () => SELECTION_DISABLED_WITHOUT_REASON });
+            expect(consoleWarnSpy.mock.calls).toEqual([
+                [`${WARN_MESSAGE_PREFIX}1, 2`],
+            ]);
+        });
+        it('Не выводится повторно при новой функции getRowDisabled с тем же результатом', () => {
+            const { rerenderGrid } = setup({
+                getRowDisabled: () => ROW_DISABLED_WITHOUT_REASON,
+            });
+            rerenderGrid({ getRowDisabled: () => ROW_DISABLED_WITHOUT_REASON });
+            expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
+        });
+        it('Выводится только для строк без причины, появившихся позже', () => {
+            const getRowDisabled = () => SELECTION_DISABLED_WITHOUT_REASON;
+            const { rerenderGrid } = setup({ getRowDisabled });
+            rerenderGrid({
+                rows: [...FIRST_PAGE_ROWS, ...SECOND_PAGE_ROWS],
+                getRowDisabled,
+            });
+            expect(consoleWarnSpy.mock.calls).toEqual([
+                [`${WARN_MESSAGE_PREFIX}1, 2`],
+                [`${WARN_MESSAGE_PREFIX}3, 4`],
+            ]);
+        });
+        it('Не выводится для options.isDisabled=true без disabledReason', () => {
+            setup({
+                rows: [{ ...FIRST_PAGE_ROWS[0], options: { isDisabled: true } }],
+            });
+            expect(consoleWarnSpy).not.toHaveBeenCalled();
+        });
+        it('Не выводится при mode=selection с reason', () => {
+            setup({ getRowDisabled: () => SELECTION_DISABLED });
+            expect(consoleWarnSpy).not.toHaveBeenCalled();
+        });
+        it('Tooltip не отображается при наведении на строку с mode=row без причины', async () => {
+            setup({
+                getRowDisabled: (row) => row.id === '1' ? ROW_DISABLED_WITHOUT_REASON : undefined,
+            });
+            await userEvents.hover(screen.getByText('Договор №1'));
+            expect(screen.queryByRole('tooltip')).not.toBeInTheDocument();
+        });
+    });
+    describe('Tooltip причины блокировки выбора', () => {
+        const user = userEvents.setup({
+            advanceTimers: vi.advanceTimersByTime.bind(vi),
+        });
+        const TOOLTIP_CONTAINER_SELECTOR = `.${tooltipClassnames.contentWrapper}`;
+        const getCheckboxTooltipContainer = (name) => {
+            const container = getRowCheckbox(name).closest(TOOLTIP_CONTAINER_SELECTOR);
+            if (!container) {
+                throw new Error(`Контейнер tooltip checkbox строки «${name}» не найден`);
+            }
+            return container;
+        };
+        const advanceTime = (ms) => act(() => {
+            vi.advanceTimersByTime(ms);
+        });
+        const setupSelectionDisabledRow = () => setup({
+            getRowDisabled: (row) => row.id === '1' ? SELECTION_DISABLED : undefined,
+        });
+        // shouldAdvanceTime: асинхронная обёртка RTL ждёт setTimeout и без него зависает
+        beforeEach(() => {
+            vi.useFakeTimers({ shouldAdvanceTime: true });
+        });
+        afterEach(() => {
+            vi.useRealTimers();
+        });
+        it('Отображается через 300ms после наведения на checkbox с mode=selection', async () => {
+            setupSelectionDisabledRow();
+            await user.hover(getCheckboxTooltipContainer('Договор №1'));
+            advanceTime(300);
+            expect(screen.getByRole('tooltip')).toHaveTextContent(SELECTION_DISABLED.reason);
+        });
+        it('Не отображается раньше 300ms после наведения', async () => {
+            setupSelectionDisabledRow();
+            await user.hover(getCheckboxTooltipContainer('Договор №1'));
+            advanceTime(250);
+            expect(screen.queryByRole('tooltip')).not.toBeInTheDocument();
+        });
+        it('Не отображается, если курсор ушёл с checkbox раньше 300ms', async () => {
+            setupSelectionDisabledRow();
+            await user.hover(getCheckboxTooltipContainer('Договор №1'));
+            advanceTime(150);
+            await user.unhover(getCheckboxTooltipContainer('Договор №1'));
+            advanceTime(300);
+            expect(screen.queryByRole('tooltip')).not.toBeInTheDocument();
+        });
+        it('Checkbox строки с mode=row не показывает собственную причину', () => {
+            setup({
+                getRowDisabled: (row) => (row.id === '1' ? ROW_DISABLED : undefined),
+            });
+            expect(getRowCheckbox('Договор №1').closest(TOOLTIP_CONTAINER_SELECTOR)).not.toBeInTheDocument();
+        });
+    });
+    describe('Вложенные строки', () => {
+        it('Чекбокс вложенной строки заблокирован при mode=selection для неё', () => {
+            setup({
+                rows: NESTED_ROWS,
+                tree: { isInitialExpanded: true },
+                getRowDisabled: (row) => row.id === '1-1' ? SELECTION_DISABLED : undefined,
+            });
+            expect(getRowCheckbox('Вложенный договор')).toBeDisabled();
+        });
+        it('Чекбокс вложенной строки доступен при mode=row у родителя', () => {
+            setup({
+                rows: NESTED_ROWS,
+                tree: { isInitialExpanded: true },
+                getRowDisabled: (row) => (row.id === '1' ? ROW_DISABLED : undefined),
+            });
+            expect(getRowCheckbox('Вложенный договор')).toBeEnabled();
+        });
+        it('Чекбокс вложенной строки заблокирован при variant=subrows и mode=selection', () => {
+            setup({
+                rows: NESTED_ROWS,
+                variant: 'subrows',
+                getRowDisabled: (row) => row.id === '1-1' ? SELECTION_DISABLED : undefined,
+            });
+            expect(getRowCheckbox('Вложенный договор')).toBeDisabled();
+        });
+        describe('mode=row у вложенной строки', () => {
+            const setupNestedRowDisabled = () => setup({
+                rows: NESTED_ROWS,
+                tree: { isInitialExpanded: true },
+                getRowDisabled: (row) => row.id === '1-1' ? ROW_DISABLED : undefined,
+            });
+            it('Ячейки вложенной строки недоступны', () => {
+                setupNestedRowDisabled();
+                expect(checkIsInert(screen.getByText('Вложенный договор'))).toBe(true);
+            });
+            it('Ячейки родительской строки доступны', () => {
+                setupNestedRowDisabled();
+                expect(checkIsInert(screen.getByText('Пакет документов'))).toBe(false);
+            });
+        });
+        describe('options.isDisabled=true у вложенной строки', () => {
+            const NESTED_ROWS_WITH_DISABLED_CHILD = [
+                {
+                    ...NESTED_ROWS[0],
+                    children: [
+                        {
+                            id: '1-1',
+                            name: 'Вложенный договор',
+                            options: { isDisabled: true },
+                        },
+                    ],
+                },
+            ];
+            it('Чекбокс вложенной строки заблокирован без getRowDisabled', () => {
+                setup({
+                    rows: NESTED_ROWS_WITH_DISABLED_CHILD,
+                    tree: { isInitialExpanded: true },
+                });
+                expect(getRowCheckbox('Вложенный договор')).toBeDisabled();
+            });
+            it('Чекбокс вложенной строки заблокирован, если getRowDisabled её не блокирует', () => {
+                setup({
+                    rows: NESTED_ROWS_WITH_DISABLED_CHILD,
+                    tree: { isInitialExpanded: true },
+                    getRowDisabled: () => undefined,
+                });
+                expect(getRowCheckbox('Вложенный договор')).toBeDisabled();
+            });
+            it('Ячейки вложенной строки доступны при mode=selection из getRowDisabled', () => {
+                setup({
+                    rows: NESTED_ROWS_WITH_DISABLED_CHILD,
+                    tree: { isInitialExpanded: true },
+                    getRowDisabled: (row) => row.id === '1-1' ? SELECTION_DISABLED : undefined,
+                });
+                expect(checkIsInert(screen.getByText('Вложенный договор'))).toBe(false);
+            });
+        });
+    });
+};

package/components/DataGrid/types.d.ts

@@ -154,6 +154,23 @@ export type DataGridProps<TData extends Record<string, CellValue> = DataGridRow,
      * Обработчик выбора строки
      */
     onSelectRow?: (row: TData[]) => void;
+    /**
+     * Возвращает блокировку строки { mode, reason }
+     * @example
+     * const getRowDisabled = useCallback(
+     *   (row: Document): DataGridRowDisabled | undefined => {
+     *     if (row.status === 'Отправлен') {
+     *       return { mode: 'selection', reason: 'Документ уже отправлен получателю' };
+     *     }
+     *
+     *     return undefined;
+     *   },
+     *   [],
+     * );
+     *
+     * <DataGrid getRowDisabled={getRowDisabled} />
+     */
+    getRowDisabled?: (row: TData) => DataGridRowDisabled | undefined;
     /**
      * @example <DataGrid onSort={({fieldId: 'test', sort: 'asc'}) => console.log('sorted')} />
      * Обработчик сортировки
@@ -318,14 +335,29 @@ export type DataGridRowOptionColumns<TData extends Record<string, CellValue>> =
      */
     renderCell?: RenderCell<TData>;
 };
+/**
+ * Состояние блокировки строки
+ */
+export type DataGridRowDisabled = {
+    /**
+     * Тип блокировки
+     */
+    mode: 'selection' | 'row' | 'row-except-last-cell';
+    /**
+     * Причина блокировки
+     */
+    reason: string;
+};
 export type DataGridRowOptions<TData extends Record<string, CellValue>> = {
     /**
      * Если true, строка будет недоступна для взаимодействия
+     * @deprecated Используйте `getRowDisabled` с `mode: 'row'`.
      */
     isDisabled?: boolean;
     /**
-     * Если true, последняя ячейка не будет блокироваться при `isDisabled=true`
+     * Если false, последняя ячейка не блокируется при `isDisabled=true`
      * @default 'true'
+     * @deprecated Используйте `getRowDisabled` с `mode: 'row-except-last-cell'`.
      */
     isDisabledLastCell?: boolean;
     /**
@@ -334,6 +366,7 @@ export type DataGridRowOptions<TData extends Record<string, CellValue>> = {
     isNotSelectable?: boolean;
     /**
      * Причина блокировки строки
+     * @deprecated Используйте `reason` в `getRowDisabled`.
      */
     disabledReason?: string;
     /**

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

@@ -1,7 +1,7 @@
 import { type ChangeEvent } from 'react';
-import type { CellValue, DataGridProps, DataGridRow } from '../types';
+import type { CellValue, DataGridProps, DataGridRow, DataGridRowWithOptions } from '../types';
 type UseLogicParams<TData extends Record<string, CellValue> = DataGridRow, TSortField extends keyof TData = keyof TData> = DataGridProps<TData, TSortField>;
-export declare const useLogic: <TData extends Record<string, unknown> = DataGridRow, TSortField extends keyof TData = keyof TData>({ keyId, columns, rows, variant, tree, subrows, selectedRows, isLoading, isDisabled, mobileDisplayVariant, onSelectRow, isError, onRetry, errorMsg, isHideSelectAll, isHideHeaderIfNoData, sorting, className, onSort, maxHeight, gridViewMode: gridViewModeProp, massActions, }: UseLogicParams<TData, TSortField>) => {
+export declare const useLogic: <TData extends Record<string, unknown> = DataGridRow, TSortField extends keyof TData = keyof TData>({ keyId, columns, rows, variant, tree, subrows, selectedRows, isLoading, isDisabled, getRowDisabled, mobileDisplayVariant, onSelectRow, isError, onRetry, errorMsg, isHideSelectAll, isHideHeaderIfNoData, sorting, className, onSort, maxHeight, gridViewMode: gridViewModeProp, massActions, }: UseLogicParams<TData, TSortField>) => {
     hasMassActions: boolean;
     isMassActionsOpen: boolean;
     dataGridClassName: string | undefined;
@@ -12,7 +12,7 @@ export declare const useLogic: <TData extends Record<string, unknown> = DataGrid
         expandedLevel?: number | undefined;
         initialVisibleChildrenCount?: number | undefined;
     } | undefined;
-    renderRows: TData[];
+    renderRows: DataGridRowWithOptions<TData>[];
     isAllowHorizontalScroll: boolean;
     isHideHead: boolean;
     hasPinnedColumns: boolean;
@@ -59,6 +59,9 @@ export declare const useLogic: <TData extends Record<string, unknown> = DataGrid
     };
     bodyProps: {
         isSelectable: boolean;
+        selectedIds: Set<TData[keyof TData]>;
+        rowsDisabled: Map<unknown, import("../types").DataGridRowDisabled | undefined>;
+        getRowDisabled: ((row: TData) => import("../types").DataGridRowDisabled | undefined) | undefined;
         onSelectRow: (row: TData) => (event: ChangeEvent<HTMLInputElement>) => void;
     };
     mobileDisplayVariant: "list" | "cards";