@astral/ui 4.114.0 → 4.115.1

package/components/DataGrid/useLogic/useLogic.js

@@ -1,14 +1,14 @@
 import { useCallback, useContext, useEffect, useMemo, useRef, } from 'react';
 import { ConfigContext } from '../../ConfigProvider';
 import { useFirstMountState } from '../../useFirstMountState';
-import { prop } from '../../utils/prop';
 import { uniqueBy } from '../../utils/uniqueBy';
 import { dataGridClassnames, EXPANDED_LEVEL_BY_DEFAULT, INITIAL_OPENED_NESTED_CHILDREN_COUNT_ON_MOBILE_BY_DEFAULT, } from '../constants';
 import { Variant } from '../enums';
-import { checkIsMassActionsOpen, getDataGridCssVars, getFlattenColumns, getGridTemplateColumns, isGroupColumns, } from '../utils';
+import { useWarnRowsWithoutDisabledReason } from '../hooks';
+import { checkIsMassActionsOpen, getDataGridCssVars, getFlattenColumns, getGridTemplateColumns, isGroupColumns, resolveRowsDisabled, } from '../utils';
 import { useDataGridMobileLogic, usePinnedColumns } from './hooks';
 import { getIsAllowHorizontalScroll } from './utils';
-export const useLogic = ({ keyId, columns, rows = [], variant, tree, subrows, selectedRows = [], isLoading, isDisabled, mobileDisplayVariant = variant === 'subrows' ? 'cards' : 'list', onSelectRow, isError, onRetry, errorMsg, isHideSelectAll, isHideHeaderIfNoData = false, sorting, className, onSort, maxHeight, gridViewMode: gridViewModeProp = 'standard', massActions, }) => {
+export const useLogic = ({ keyId, columns, rows = [], variant, tree, subrows, selectedRows = [], isLoading, isDisabled, getRowDisabled, mobileDisplayVariant = variant === 'subrows' ? 'cards' : 'list', onSelectRow, isError, onRetry, errorMsg, isHideSelectAll, isHideHeaderIfNoData = false, sorting, className, onSort, maxHeight, gridViewMode: gridViewModeProp = 'standard', massActions, }) => {
     const isFirstRender = useFirstMountState();
     const isSelectable = Boolean(onSelectRow);
     const isDataGridDisabled = isLoading || isDisabled;
@@ -57,22 +57,24 @@ export const useLogic = ({ keyId, columns, rows = [], variant, tree, subrows, se
         }
         return config;
     }, [variant, subrows, tree, isMobile]);
-    const availableRows = rows.filter((row) => !(row.options?.isDisabled || row.options?.isNotSelectable));
+    // Блокировки строк: getRowDisabled вызывается один раз на строку
+    const { rowsDisabled, idsWithoutReason } = useMemo(() => resolveRowsDisabled(renderRows, keyId, getRowDisabled), [renderRows, keyId, getRowDisabled]);
+    useWarnRowsWithoutDisabledReason(idsWithoutReason);
+    const selectedIds = useMemo(() => new Set(selectedRows.map((row) => row[keyId])), [selectedRows, keyId]);
+    const availableRows = useMemo(() => renderRows.filter((row) => !row.options?.isNotSelectable && !rowsDisabled.get(row[keyId])), [renderRows, rowsDisabled, keyId]);
     const gridColumns = useMemo(() => getGridTemplateColumns(getFlattenColumns(columns)), [columns]);
     const isAllowHorizontalScroll = getIsAllowHorizontalScroll(getFlattenColumns(columns));
-    const uncheckedRowsCount = useMemo(() => {
-        return availableRows.filter((row) => !selectedRows.find((selectedRow) => selectedRow[keyId] === row[keyId])).length;
-    }, [availableRows, selectedRows, keyId]);
+    const uncheckedRowsCount = useMemo(() => availableRows.filter((row) => !selectedIds.has(row[keyId])).length, [availableRows, selectedIds, keyId]);
     const handleSelectAllRows = (event) => {
         if (!onSelectRow) {
             return;
         }
         if (event.target.checked) {
-            const mergedSelectedRows = uniqueBy([...selectedRows, ...availableRows], prop(keyId));
+            const mergedSelectedRows = uniqueBy([...selectedRowsRef.current, ...availableRows], (row) => row[keyId]);
             return onSelectRow(mergedSelectedRows);
         }
-        const filteredRows = selectedRows.filter((selectedRow) => !rows.find((row) => row[keyId] === selectedRow[keyId]));
-        onSelectRow(filteredRows);
+        const renderRowsIds = new Set(renderRows.map((row) => row[keyId]));
+        onSelectRow(selectedRowsRef.current.filter((selectedRow) => !renderRowsIds.has(selectedRow[keyId])));
     };
     const handleSelectRow = useCallback((row) => (event) => {
         if (!onSelectRow) {
@@ -141,6 +143,9 @@ export const useLogic = ({ keyId, columns, rows = [], variant, tree, subrows, se
         },
         bodyProps: {
             isSelectable,
+            selectedIds,
+            rowsDisabled,
+            getRowDisabled,
             onSelectRow: handleSelectRow,
         },
         mobileDisplayVariant,

package/components/DataGrid/utils/getRowDisabledState/getRowDisabledState.d.ts

@@ -0,0 +1,31 @@
+import type { DataGridRowDisabled } from '../../types';
+type GetRowDisabledStateParams = {
+    /**
+     * Итоговая блокировка строки, рассчитанная resolveRowDisabled
+     */
+    rowDisabled?: DataGridRowDisabled;
+    /**
+     * Если true, в строке выполняется блокирующее действие DataGridActionCell
+     */
+    hasBlockingAction?: boolean;
+    /**
+     * Причина блокировки от блокирующего действия
+     */
+    blockingActionReason?: string;
+    /**
+     * Значение options.isDisabledLastCell. Влияет только на блокировку от DataGridActionCell:
+     * options.isDisabled уже преобразован в mode в resolveRowDisabled
+     */
+    isDisabledLastCellOption?: boolean;
+};
+/**
+ * Вычисляет доступность строки и её checkbox по режиму блокировки и блокирующему действию
+ */
+export declare const getRowDisabledState: ({ rowDisabled, hasBlockingAction, blockingActionReason, isDisabledLastCellOption, }: GetRowDisabledStateParams) => {
+    isDisabled: boolean;
+    isDisabledLastCell: boolean;
+    disabledReason: string | undefined;
+    isCheckboxDisabled: boolean;
+    checkboxDisabledReason: string | undefined;
+};
+export {};

package/components/DataGrid/utils/getRowDisabledState/getRowDisabledState.js

@@ -0,0 +1,20 @@
+/**
+ * Вычисляет доступность строки и её checkbox по режиму блокировки и блокирующему действию
+ */
+export const getRowDisabledState = ({ rowDisabled, hasBlockingAction = false, blockingActionReason, isDisabledLastCellOption = true, }) => {
+    const mode = rowDisabled?.mode;
+    const isSelectionDisabled = mode === 'selection';
+    const isDisabled = hasBlockingAction || mode === 'row' || mode === 'row-except-last-cell';
+    const disabledReason = rowDisabled?.reason || blockingActionReason;
+    return {
+        isDisabled,
+        // Без режима сохраняется прежнее поведение: isDisabledLastCell действует и при блокирующем действии
+        isDisabledLastCell: mode
+            ? mode !== 'row-except-last-cell'
+            : isDisabledLastCellOption,
+        disabledReason,
+        isCheckboxDisabled: isDisabled || isSelectionDisabled,
+        // У полностью заблокированной строки причину показывает tooltip строки
+        checkboxDisabledReason: isSelectionDisabled ? disabledReason : undefined,
+    };
+};

package/components/DataGrid/utils/getRowDisabledState/index.d.ts

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

package/components/DataGrid/utils/getRowDisabledState/index.js

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

package/components/DataGrid/utils/index.d.ts

@@ -3,3 +3,6 @@ export { getGridTemplateColumns } from './getGridTemplateColumns';
 export { isGroupColumns } from './isGroupColumns';
 export { getFlattenColumns } from './getFlattenColumns';
 export { checkIsMassActionsOpen } from './checkIsMassActionsOpen';
+export { getRowDisabledState } from './getRowDisabledState';
+export { resolveRowDisabled } from './resolveRowDisabled';
+export { resolveRowsDisabled } from './resolveRowsDisabled';

package/components/DataGrid/utils/index.js

@@ -3,3 +3,6 @@ export { getGridTemplateColumns } from './getGridTemplateColumns';
 export { isGroupColumns } from './isGroupColumns';
 export { getFlattenColumns } from './getFlattenColumns';
 export { checkIsMassActionsOpen } from './checkIsMassActionsOpen';
+export { getRowDisabledState } from './getRowDisabledState';
+export { resolveRowDisabled } from './resolveRowDisabled';
+export { resolveRowsDisabled } from './resolveRowsDisabled';

package/components/DataGrid/utils/resolveRowDisabled/index.d.ts

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

package/components/DataGrid/utils/resolveRowDisabled/index.js

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

package/components/DataGrid/utils/resolveRowDisabled/resolveRowDisabled.d.ts

@@ -0,0 +1,5 @@
+import type { DataGridProps, DataGridRowDisabled, DataGridRowWithOptions } from '../../types';
+/**
+ * Возвращает блокировку строки: результат getRowDisabled, а если его нет — блокировку из deprecated-полей options (isDisabled, isDisabledLastCell, disabledReason)
+ */
+export declare const resolveRowDisabled: <TData extends Record<string, unknown>>(row: DataGridRowWithOptions<TData>, getRowDisabled?: ((row: TData) => DataGridRowDisabled | undefined) | undefined) => DataGridRowDisabled | undefined;

package/components/DataGrid/utils/resolveRowDisabled/resolveRowDisabled.js

@@ -0,0 +1,17 @@
+/**
+ * Возвращает блокировку строки: результат getRowDisabled, а если его нет — блокировку из deprecated-полей options (isDisabled, isDisabledLastCell, disabledReason)
+ */
+export const resolveRowDisabled = (row, getRowDisabled) => {
+    const rowDisabled = getRowDisabled?.(row);
+    if (rowDisabled) {
+        return rowDisabled;
+    }
+    const { isDisabled, isDisabledLastCell = true, disabledReason = '', } = row.options ?? {};
+    if (!isDisabled) {
+        return undefined;
+    }
+    return {
+        mode: isDisabledLastCell ? 'row' : 'row-except-last-cell',
+        reason: disabledReason,
+    };
+};

package/components/DataGrid/utils/resolveRowsDisabled/index.d.ts

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

package/components/DataGrid/utils/resolveRowsDisabled/index.js

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

package/components/DataGrid/utils/resolveRowsDisabled/resolveRowsDisabled.d.ts

@@ -0,0 +1,16 @@
+import type { DataGridProps, DataGridRowDisabled, DataGridRowWithOptions } from '../../types';
+type ResolveRowsDisabledResult = {
+    /**
+     * Блокировки строк по row[keyId]
+     */
+    rowsDisabled: Map<unknown, DataGridRowDisabled | undefined>;
+    /**
+     * Идентификаторы строк, для которых getRowDisabled вернул блокировку без причины
+     */
+    idsWithoutReason: unknown[];
+};
+/**
+ * Вычисляет блокировки строк
+ */
+export declare const resolveRowsDisabled: <TData extends Record<string, unknown>>(rows: DataGridRowWithOptions<TData>[], keyId: keyof TData, getRowDisabled?: ((row: TData) => DataGridRowDisabled | undefined) | undefined) => ResolveRowsDisabledResult;
+export {};

package/components/DataGrid/utils/resolveRowsDisabled/resolveRowsDisabled.js

@@ -0,0 +1,17 @@
+import { resolveRowDisabled } from '../resolveRowDisabled';
+/**
+ * Вычисляет блокировки строк
+ */
+export const resolveRowsDisabled = (rows, keyId, getRowDisabled) => {
+    const rowsDisabled = new Map();
+    const idsWithoutReason = [];
+    rows.forEach((row) => {
+        const rowId = row[keyId];
+        const rowDisabled = getRowDisabled?.(row);
+        if (rowDisabled && !rowDisabled.reason) {
+            idsWithoutReason.push(rowId);
+        }
+        rowsDisabled.set(rowId, rowDisabled ?? resolveRowDisabled(row));
+    });
+    return { rowsDisabled, idsWithoutReason };
+};

package/components/DataGridActionCell/hooks/useBlockingActions/useBlockingActions.js

@@ -5,16 +5,16 @@ import { ActionCellContext, } from '../../ActionCellContext';
  * хук позволяющий подписаться на событие блокировки действий
  */
 export const useBlockingActions = (actions) => {
-    const { addDisabledRow, removeDisabledRow } = useContext(RowContext);
+    const { addBlockingAction, removeBlockingAction } = useContext(RowContext);
     const { addDisabledCell, removeDisabledCell, isDisabled, onActionClick } = useContext(ActionCellContext);
     const blockingAction = [...(actions || [])].find((action) => action.isBlockingOperation && action.loading);
     useEffect(() => {
         if (blockingAction) {
-            addDisabledRow(blockingAction?.loadingNote);
+            addBlockingAction(blockingAction?.loadingNote);
             addDisabledCell(blockingAction?.loadingNote);
             return;
         }
-        removeDisabledRow();
+        removeBlockingAction();
         removeDisabledCell();
     }, [blockingAction]);
     return {

package/components/DataGridCollapsibleRow/useLogic/useLogic.d.ts

@@ -12,8 +12,9 @@ export declare const useLogic: ({ initialOpen, onOpen, onClose }: UseLogicParams
         keyId: unknown;
         columns: import("../..").DataGridColumns<Record<string, unknown>>[];
         rowId: string;
-        isDisabled: boolean;
-        disabledReason: string | undefined;
+        hasBlockingAction: boolean;
+        blockingActionReason: string | undefined;
+        rowDisabled: import("../..").DataGridRowDisabled | undefined;
         onSelectRow: (row: Record<string, unknown>) => (event: import("react").ChangeEvent<HTMLInputElement, Element>) => void;
         onRowEnter: ((rowId: string) => void) | undefined;
         onRowLeave: ((rowId: string, event: PointerEvent) => void) | undefined;

package/components/DataGridCollapsibleRow/useLogic/useLogic.js

@@ -5,7 +5,7 @@ import { RowContext } from '../../DataGrid/Row/RowContext';
 import { STORAGE_KEY_PREFIX } from '../constants';
 export const useLogic = ({ initialOpen, onOpen, onClose }) => {
     const { keyId, columns, gridColumns, activeRowId, emptyCellValue, onRowClick, mobileDisplayVariant, } = useContext(DataGridContext);
-    const { row, onSelectRow, isDisabled, disabledReason, onRowEnter, onRowLeave, registerRowElement, unregisterRowElement, isSelectable, itemProps, isSelected, } = useContext(RowContext);
+    const { row, onSelectRow, hasBlockingAction, blockingActionReason, onRowEnter, onRowLeave, registerRowElement, unregisterRowElement, isSelectable, itemProps, isSelected, rowDisabled, } = useContext(RowContext);
     const rowId = row[keyId];
     /**
      * Используется локальное хранилище DataGridStorageContext. Для сохранения состояния раскрытия строки на время жизни DataGrid.
@@ -46,8 +46,9 @@ export const useLogic = ({ initialOpen, onOpen, onClose }) => {
             keyId,
             columns,
             rowId,
-            isDisabled,
-            disabledReason,
+            hasBlockingAction,
+            blockingActionReason,
+            rowDisabled,
             onSelectRow,
             onRowEnter,
             onRowLeave,

package/components/DataGridInfinite/DataGridInfinite.js

@@ -49,13 +49,13 @@ const dataGridInfiniteCva = cva(dataGridClassnames.root, {
 });
 export const DataGridInfinite = (props) => {
     const { imagesMap, emptySymbol } = useContext(ConfigContext);
-    const { isNoData, isDataGridDisabled, treeRenderConfig, virtuosoProps, headProps, rowProps, scrollToTopButtonProps, isHideHead, containerCssVars, isMobile, mobileSkeletonProps, hasGroupedColumns, gridViewMode, gridColumns, handleSelectRow, mobileDisplayVariant, isSelfContained, isNotRenderHeader, initialTopMostItemIndex, hasMassActions, isMassActionsOpen, footerContext, } = useLogic(props);
+    const { isNoData, isDataGridDisabled, treeRenderConfig, virtuosoProps, headProps, rowProps, scrollToTopButtonProps, isHideHead, containerCssVars, isMobile, mobileSkeletonProps, hasGroupedColumns, gridViewMode, gridColumns, handleSelectRow, mobileDisplayVariant, isSelfContained, isNotRenderHeader, initialTopMostItemIndex, hasMassActions, isMassActionsOpen, virtuosoContext, } = useLogic(props);
     const { columns, rows = [], selectedRows = [], onSelectRow, sorting, isLoading, isDisabled, keyId, emptyCellValue = emptySymbol, variant = Variant.Tree, subrows, className, isError, errorMsg, noDataPlaceholder, onRowClick, onSort, onRetry, headPreAddon, activeRowId, isTabularNums, renderRow, renderLink, massActions, } = props;
     const { moreButtonColumnPosition = 1, isVisibleCollapseButton = true } = subrows || {};
     const { isInitialExpanded = false, expandedLevel = EXPANDED_LEVEL_BY_DEFAULT, initialVisibleChildrenCount = INITIAL_OPENED_NESTED_CHILDREN_COUNT_BY_DEFAULT, } = treeRenderConfig || {};
     const { isSelectable } = rowProps;
     const TableContainer = isDisabled ? DisabledDataGridWrapper : DataGridWrapper;
-    return (_jsx(DataGridInfiniteContextProvider, { renderRow: renderRow, onSelectRow: handleSelectRow, variant: variant, isInitialExpanded: isInitialExpanded, expandedLevel: expandedLevel, initialVisibleChildrenCount: initialVisibleChildrenCount, isSelectable: isSelectable, selectedRows: selectedRows, moreButtonColumnPosition: moreButtonColumnPosition, isVisibleCollapseButton: isVisibleCollapseButton, children: _jsx(DataGridContextProvider, { gridColumns: gridColumns, emptyCellValue: emptyCellValue, activeRowId: activeRowId, columns: columns, keyId: keyId, isTabularNums: isTabularNums, onRowClick: onRowClick, mobileDisplayVariant: mobileDisplayVariant, renderLink: renderLink, selectedRows: selectedRows, onSelectRow: onSelectRow, isMassActionsOpen: isMassActionsOpen, children: _jsxs(StyledContainer, { style: containerCssVars, className: cn(dataGridInfiniteCva({
+    return (_jsx(DataGridInfiniteContextProvider, { renderRow: renderRow, onSelectRow: handleSelectRow, variant: variant, isInitialExpanded: isInitialExpanded, expandedLevel: expandedLevel, initialVisibleChildrenCount: initialVisibleChildrenCount, isSelectable: isSelectable, moreButtonColumnPosition: moreButtonColumnPosition, isVisibleCollapseButton: isVisibleCollapseButton, children: _jsx(DataGridContextProvider, { gridColumns: gridColumns, emptyCellValue: emptyCellValue, activeRowId: activeRowId, columns: columns, keyId: keyId, isTabularNums: isTabularNums, onRowClick: onRowClick, mobileDisplayVariant: mobileDisplayVariant, renderLink: renderLink, selectedRows: selectedRows, onSelectRow: onSelectRow, isMassActionsOpen: isMassActionsOpen, children: _jsxs(StyledContainer, { style: containerCssVars, className: cn(dataGridInfiniteCva({
                     hasGroupedColumns,
                     gridViewMode,
                     mobileDisplayVariant,
@@ -69,7 +69,7 @@ export const DataGridInfinite = (props) => {
                                     onRetry,
                                 }, children: _jsx(Virtuoso, { ...virtuosoProps, ...(initialTopMostItemIndex && {
                                         initialTopMostItemIndex,
-                                    }), style: { height: '100%' }, overscan: OVERSCAN_COUNT, data: rows, context: footerContext, components: {
+                                    }), style: { height: '100%' }, overscan: OVERSCAN_COUNT, data: rows, context: virtuosoContext, components: {
                                         // biome-ignore lint/suspicious/noTsIgnore: Требует HTMLDivElement, а для элемента списка используем HTMLUListElement (https://github.com/petyosi/react-virtuoso/issues/864)
                                         // @ts-ignore
                                         List,
@@ -80,7 +80,7 @@ export const DataGridInfinite = (props) => {
                                             if (isNotRenderHeader) {
                                                 return null;
                                             }
-                                            return (_jsxs(HeaderRow, { children: [isLoading && _jsx(Loader, {}), isError && _jsx(ErrorMessage, { onRetry: onRetry })] }));
+                                            return (_jsxs(HeaderRow, { className: dataGridInfiniteClassnames.header, children: [isLoading && _jsx(Loader, {}), isError && _jsx(ErrorMessage, { onRetry: onRetry })] }));
                                         },
                                     } }) }), massActions && (_jsx(MassActionsAnchor, { children: massActions })), _jsx(StyledScrollToTopButton, { ...scrollToTopButtonProps, className: dataGridInfiniteClassnames.scrollToTopButton }), isDisabled && _jsx(Backdrop, {})] })] }) }) }));
 };

package/components/DataGridInfinite/DataGridInfiniteContext/DataGridInfiniteContext.d.ts

@@ -9,7 +9,6 @@ export type DataGridInfiniteContextProps = {
     moreButtonColumnPosition?: number;
     isVisibleCollapseButton?: boolean;
     isSelectable?: boolean;
-    selectedRows?: Record<string, unknown>[];
 };
 /**
  * Контекст общих параметров для компонента `Item` внутри `DataGridInfinite`.
@@ -19,5 +18,6 @@ export type DataGridInfiniteContextProps = {
  * лишние перерисовки виртуализированного списка.
  *
  * Поскольку `Virtuoso` сам управляет параметрами `Item`, общие настройки передаются через контекст.
+ * Состояние строк передаётся отдельно, см. `DataGridInfiniteItemContext` в `Row/types.ts`.
  */
 export declare const DataGridInfiniteContext: import("react").Context<DataGridInfiniteContextProps>;

package/components/DataGridInfinite/DataGridInfiniteContext/DataGridInfiniteContext.js

@@ -7,6 +7,7 @@ import { createContext } from 'react';
  * лишние перерисовки виртуализированного списка.
  *
  * Поскольку `Virtuoso` сам управляет параметрами `Item`, общие настройки передаются через контекст.
+ * Состояние строк передаётся отдельно, см. `DataGridInfiniteItemContext` в `Row/types.ts`.
  */
 export const DataGridInfiniteContext = createContext({
     renderRow: () => null,
@@ -17,5 +18,4 @@ export const DataGridInfiniteContext = createContext({
     initialVisibleChildrenCount: 0,
     moreButtonColumnPosition: 0,
     isVisibleCollapseButton: true,
-    selectedRows: [],
 });

package/components/DataGridInfinite/Footer/Footer.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Loader } from '../../Loader';
 import { dataGridInfiniteClassnames } from '../constants';
 import { EndData } from '../EndData';
@@ -21,5 +21,5 @@ export const Footer = ({ context }) => {
         }
         return null;
     };
-    return (_jsxs(_Fragment, { children: [renderStatus(), hasMassActions && (_jsx(MassActionsSpacer, { className: dataGridInfiniteClassnames.massActionsSpacer }))] }));
+    return (_jsxs("div", { className: dataGridInfiniteClassnames.footer, children: [renderStatus(), hasMassActions && (_jsx(MassActionsSpacer, { className: dataGridInfiniteClassnames.massActionsSpacer }))] }));
 };

package/components/DataGridInfinite/Row/Row.js

@@ -5,6 +5,6 @@ import { RowContextProvider } from '../../DataGrid/Row/RowContext';
 import { useLogic } from './useLogic';
 const INITIAL_LEVEL = 0;
 export const Row = ({ children, ...props }) => {
-    const { item, memoizedItemProps, onSelectRow, renderRow, flattenColumns, gridColumns, options, keyId, variant, isSelectable, isSelected, nestedChildren, isInitialExpanded, expandedLevel, initialVisibleChildrenCount, moreButtonColumnPosition, isVisibleCollapseButton, emptyCellValue, activeRowId, onRowClick, } = useLogic(props);
-    return (_jsx(RowContextProvider, { row: item, itemProps: memoizedItemProps, onSelectRow: onSelectRow, isSelectable: isSelectable, isSelected: isSelected, children: renderRow ? (_jsx(CustomRowWrapper, { index: memoizedItemProps['data-index'], renderRow: renderRow, row: item })) : (_jsx(RowComponent, { ...memoizedItemProps, row: item, columns: flattenColumns, gridColumns: gridColumns, options: options, keyId: keyId, variant: variant, isSelectable: isSelectable, isSelected: isSelected, level: INITIAL_LEVEL, nestedChildren: nestedChildren, isInitialExpanded: isInitialExpanded || false, expandedLevel: expandedLevel || 1, initialVisibleChildrenCount: initialVisibleChildrenCount || 2, activeRowId: activeRowId, moreButtonColumnPosition: moreButtonColumnPosition || 1, isVisibleCollapseButton: isVisibleCollapseButton || true, emptyCellValue: emptyCellValue, onRowClick: onRowClick, onSelectRow: onSelectRow })) }));
+    const { item, memoizedItemProps, onSelectRow, renderRow, flattenColumns, gridColumns, options, keyId, variant, isSelectable, isSelected, disabledMode, disabledReason, getRowDisabled, nestedChildren, isInitialExpanded, expandedLevel, initialVisibleChildrenCount, moreButtonColumnPosition, isVisibleCollapseButton, emptyCellValue, activeRowId, onRowClick, } = useLogic(props);
+    return (_jsx(RowContextProvider, { row: item, itemProps: memoizedItemProps, onSelectRow: onSelectRow, isSelectable: isSelectable, isSelected: isSelected, disabledMode: disabledMode, disabledReason: disabledReason, children: renderRow ? (_jsx(CustomRowWrapper, { index: memoizedItemProps['data-index'], renderRow: renderRow, row: item })) : (_jsx(RowComponent, { ...memoizedItemProps, row: item, columns: flattenColumns, gridColumns: gridColumns, options: options, keyId: keyId, variant: variant, isSelectable: isSelectable, isSelected: isSelected, getRowDisabled: getRowDisabled, level: INITIAL_LEVEL, nestedChildren: nestedChildren, isInitialExpanded: isInitialExpanded || false, expandedLevel: expandedLevel || 1, initialVisibleChildrenCount: initialVisibleChildrenCount || 2, activeRowId: activeRowId, moreButtonColumnPosition: moreButtonColumnPosition || 1, isVisibleCollapseButton: isVisibleCollapseButton || true, emptyCellValue: emptyCellValue, onRowClick: onRowClick, onSelectRow: onSelectRow })) }));
 };

package/components/DataGridInfinite/Row/index.d.ts

@@ -1 +1,2 @@
 export * from './Row';
+export type { DataGridInfiniteItemContext } from './types';

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

@@ -1,2 +1,17 @@
-import type { ItemProps as VirtuosoItemProps } from 'react-virtuoso';
-export type RowProps = VirtuosoItemProps<Record<string, unknown>>;
+import type { ContextProp, ItemProps as VirtuosoItemProps } from 'react-virtuoso';
+import { type DataGridProps, type DataGridRowDisabled } from '../../DataGrid/types';
+type ContextGetRowDisabled = DataGridProps<Record<string, unknown>>['getRowDisabled'];
+/**
+ * Состояние строк.
+ *
+ * Передаётся через `context` `Virtuoso`, а не через React-контекст: `Virtuoso` отдаёт `Item` новые данные
+ * на рендер позже родителя. Состояние из React-контекста приходило бы раньше данных, и строка
+ * перерисовывалась бы дважды — сначала со старыми данными и новым состоянием, затем с новыми данными.
+ */
+export type DataGridInfiniteItemContext = {
+    selectedIds: Set<unknown>;
+    rowsDisabled: Map<unknown, DataGridRowDisabled | undefined>;
+    getRowDisabled?: ContextGetRowDisabled;
+};
+export type RowProps = VirtuosoItemProps<Record<string, unknown>> & ContextProp<DataGridInfiniteItemContext>;
+export {};

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

@@ -1,7 +1,7 @@
 /// <reference types="react" />
 import { type RowProps } from '../types';
 type UseLogicParams = Omit<RowProps, 'children'>;
-export declare const useLogic: ({ item, ...itemProps }: UseLogicParams) => {
+export declare const useLogic: ({ item, context, ...itemProps }: UseLogicParams) => {
     item: Record<string, unknown>;
     renderRow: (row: Record<string, unknown>, index: number) => import("react").ReactNode;
     isSelected: boolean;
@@ -21,7 +21,9 @@ export declare const useLogic: ({ item, ...itemProps }: UseLogicParams) => {
     moreButtonColumnPosition: number | undefined;
     isVisibleCollapseButton: boolean | undefined;
     isSelectable: boolean | undefined;
-    selectedRows: Record<string, unknown>[] | undefined;
+    disabledMode: "row" | "selection" | "row-except-last-cell" | undefined;
+    disabledReason: string | undefined;
+    getRowDisabled: ((row: Record<string, unknown>) => import("../../..").DataGridRowDisabled | undefined) | undefined;
     memoizedItemProps: {
         style?: import("react").CSSProperties | undefined;
         'data-index': number;

package/components/DataGridInfinite/Row/useLogic/useLogic.js

@@ -2,13 +2,18 @@ import { useContext, useMemo } from 'react';
 import { DataGridContext } from '../../../DataGrid/DataGridContext';
 import { getFlattenColumns } from '../../../DataGrid/utils';
 import { DataGridInfiniteContext } from '../../DataGridInfiniteContext';
-export const useLogic = ({ item, ...itemProps }) => {
-    const { renderRow, onSelectRow, variant, isInitialExpanded, expandedLevel, initialVisibleChildrenCount, moreButtonColumnPosition, isVisibleCollapseButton, isSelectable, selectedRows, } = useContext(DataGridInfiniteContext);
+export const useLogic = ({ item, context, ...itemProps }) => {
+    const { renderRow, onSelectRow, variant, isInitialExpanded, expandedLevel, initialVisibleChildrenCount, moreButtonColumnPosition, isVisibleCollapseButton, isSelectable, } = useContext(DataGridInfiniteContext);
+    // Состояние строки приходит от Virtuoso вместе с item, см. DataGridInfiniteItemContext
+    const { selectedIds, rowsDisabled, getRowDisabled } = context;
     const { activeRowId, columns, emptyCellValue, onRowClick, keyId, gridColumns, } = useContext(DataGridContext);
     const memoizedItemProps = useMemo(() => itemProps, [itemProps.style]);
     const flattenColumns = useMemo(() => getFlattenColumns(columns), [columns]);
     const { children: nestedChildren, options } = item;
-    const isSelected = Boolean(selectedRows?.find((selectedRow) => selectedRow[keyId] === item[keyId]));
+    const rowId = item[keyId];
+    const isSelected = selectedIds.has(rowId);
+    const rowDisabled = rowsDisabled.get(rowId);
+    const hasNestedChildren = Array.isArray(nestedChildren) && nestedChildren.length > 0;
     return {
         item,
         renderRow,
@@ -29,7 +34,10 @@ export const useLogic = ({ item, ...itemProps }) => {
         moreButtonColumnPosition,
         isVisibleCollapseButton,
         isSelectable,
-        selectedRows,
+        disabledMode: rowDisabled?.mode,
+        disabledReason: rowDisabled?.reason,
+        // Функция нужна только для расчёта блокировки вложенных строк, остальным не передаём, чтобы не сбрасывать memo
+        getRowDisabled: hasNestedChildren ? getRowDisabled : undefined,
         memoizedItemProps,
     };
 };

package/components/DataGridInfinite/constants.d.ts

@@ -6,4 +6,6 @@ export declare const dataGridInfiniteClassnames: {
     scrollToTopButton: string;
     visibleScrollToTopButton: string;
     massActionsSpacer: string;
+    header: string;
+    footer: string;
 };

package/components/DataGridInfinite/constants.js

@@ -7,4 +7,6 @@ export const dataGridInfiniteClassnames = {
     scrollToTopButton: createUIKitClassname('data-grid-infinite__scroll-to-top-button'),
     visibleScrollToTopButton: createUIKitClassname('data-grid-infinite__scroll-to-top-button_visible'),
     massActionsSpacer: createUIKitClassname('data-grid-infinite__mass-actions-spacer'),
+    header: createUIKitClassname('data-grid-infinite__header'),
+    footer: createUIKitClassname('data-grid-infinite__footer'),
 };

package/components/DataGridInfinite/faker.d.ts

@@ -7,11 +7,7 @@ type DataType = {
     actions?: object;
 };
 export declare const makeRandomDate: () => string;
-export declare const makeDataList: (length?: number, options?: {
-    isDisabled?: boolean;
-    isDisabledLastCell?: boolean;
-    disabledReason?: string;
-}) => DataType[];
+export declare const makeDataList: (length?: number) => DataType[];
 export declare const makeDataListWithTree: (length?: number, options?: {
     isNotSelectable?: boolean;
     childrenCount?: number;

package/components/DataGridInfinite/faker.js

@@ -11,13 +11,12 @@ export const makeRandomDate = () => {
     });
     return randomDate.toISOString();
 };
-export const makeDataList = (length = 10, options) => {
+export const makeDataList = (length = 10) => {
     return Array.from({ length }).map((_, i) => ({
         id: i.toString(),
         documentName: `Договор №${i + 1}`,
         recipient: RECIPIENTS[faker.number.int({ min: 0, max: RECIPIENTS.length })],
         createDate: makeRandomDate(),
-        options: Math.random() < 0.4 ? options : {},
     }));
 };
 export const makeDataListWithTree = (length = 10, options) => {

package/components/DataGridInfinite/useLogic/useLogic.d.ts

@@ -3,10 +3,11 @@ import type { ListRange } from 'react-virtuoso';
 import { type DataGridRow } from '../../DataGrid';
 import { type CellValue } from '../../DataGrid/types';
 import { type FooterContext } from '../Footer';
+import { type DataGridInfiniteItemContext } from '../Row';
 import { type DataGridInfiniteProps, type DataGridInfiniteVirtuosoHandle } from '../types';
 type UseLogicParams<TData extends Record<string, CellValue> = DataGridRow, TSortField extends keyof TData = keyof TData> = DataGridInfiniteProps<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, maxHeight, isLoading, isError, isDisabled, isEndReached, endOfScrollMsg, onRetry, onEndReached, onStartReached, isStartReached, onSelectRow, isHideSelectAll, initialVisibleItemIndex, isHideHeaderIfNoData, gridViewMode: gridViewModeProp, massActions, mobileDisplayVariant, virtuosoRef, }: UseLogicParams<TData, TSortField>) => {
-    footerContext: FooterContext;
+export declare const useLogic: <TData extends Record<string, unknown> = DataGridRow, TSortField extends keyof TData = keyof TData>({ keyId, columns, rows, variant, tree, subrows, selectedRows, maxHeight, isLoading, isError, isDisabled, getRowDisabled, isEndReached, endOfScrollMsg, onRetry, onEndReached, onStartReached, isStartReached, onSelectRow, isHideSelectAll, initialVisibleItemIndex, isHideHeaderIfNoData, gridViewMode: gridViewModeProp, massActions, mobileDisplayVariant, virtuosoRef, }: UseLogicParams<TData, TSortField>) => {
+    virtuosoContext: DataGridInfiniteItemContext & FooterContext;
     hasMassActions: boolean;
     isMassActionsOpen: boolean;
     containerCssVars: import("react").CSSProperties;

package/components/DataGridInfinite/useLogic/useLogic.js

@@ -1,13 +1,13 @@
 import { useCallback, useEffect, useMemo, useRef, useState, } from 'react';
 import { EXPANDED_LEVEL_BY_DEFAULT, INITIAL_OPENED_NESTED_CHILDREN_COUNT_ON_MOBILE_BY_DEFAULT, } from '../../DataGrid/constants';
 import { Variant } from '../../DataGrid/enums';
+import { useWarnRowsWithoutDisabledReason } from '../../DataGrid/hooks';
 import { useDataGridMobileLogic } from '../../DataGrid/useLogic/hooks';
-import { checkIsMassActionsOpen, getDataGridCssVars, getFlattenColumns, getGridTemplateColumns, isGroupColumns, } from '../../DataGrid/utils';
+import { checkIsMassActionsOpen, getDataGridCssVars, getFlattenColumns, getGridTemplateColumns, isGroupColumns, resolveRowsDisabled, } from '../../DataGrid/utils';
 import { useViewportType } from '../../useViewportType';
-import { prop } from '../../utils/prop';
 import { uniqueBy } from '../../utils/uniqueBy';
 import { dataGridInfiniteClassnames, VIRTUOSO_CONTAINER_ID, } from '../constants';
-export const useLogic = ({ keyId, columns, rows, variant, tree, subrows, selectedRows = [], maxHeight, isLoading, isError, isDisabled, isEndReached, endOfScrollMsg, onRetry, onEndReached, onStartReached, isStartReached, onSelectRow, isHideSelectAll, initialVisibleItemIndex, isHideHeaderIfNoData = false, gridViewMode: gridViewModeProp = 'standard', massActions, mobileDisplayVariant = variant === 'subrows' ? 'cards' : 'list', virtuosoRef, }) => {
+export const useLogic = ({ keyId, columns, rows, variant, tree, subrows, selectedRows = [], maxHeight, isLoading, isError, isDisabled, getRowDisabled, isEndReached, endOfScrollMsg, onRetry, onEndReached, onStartReached, isStartReached, onSelectRow, isHideSelectAll, initialVisibleItemIndex, isHideHeaderIfNoData = false, gridViewMode: gridViewModeProp = 'standard', massActions, mobileDisplayVariant = variant === 'subrows' ? 'cards' : 'list', virtuosoRef, }) => {
     const virtuoso = useRef(null);
     const handleVirtuosoRef = useCallback((node) => {
         virtuoso.current = node;
@@ -66,7 +66,16 @@ export const useLogic = ({ keyId, columns, rows, variant, tree, subrows, selecte
         }
         return config;
     }, [variant, subrows, tree, isMobile]);
-    const availableRows = rows.filter((row) => !(row.options?.isDisabled || row.options?.isNotSelectable));
+    // Блокировки строк: getRowDisabled вызывается один раз на строку
+    const { rowsDisabled, idsWithoutReason } = useMemo(() => resolveRowsDisabled(rows, keyId, getRowDisabled), [rows, keyId, getRowDisabled]);
+    useWarnRowsWithoutDisabledReason(idsWithoutReason);
+    const selectedIds = useMemo(() => new Set(selectedRows.map((row) => row[keyId])), [selectedRows, keyId]);
+    const itemContext = useMemo(() => ({
+        selectedIds,
+        rowsDisabled,
+        getRowDisabled: getRowDisabled,
+    }), [selectedIds, rowsDisabled, getRowDisabled]);
+    const availableRows = useMemo(() => rows.filter((row) => !row.options?.isNotSelectable && !rowsDisabled.get(row[keyId])), [rows, rowsDisabled, keyId]);
     const flattenColumns = useMemo(() => getFlattenColumns(columns), [columns]);
     const hasGroupedColumns = columns.some(isGroupColumns);
     const gridViewMode = hasGroupedColumns ? 'full' : gridViewModeProp;
@@ -81,9 +90,7 @@ export const useLogic = ({ keyId, columns, rows, variant, tree, subrows, selecte
             onStartReached();
         }
     }, [isStartReached, onStartReached]);
-    const uncheckedRowsCount = useMemo(() => {
-        return availableRows.filter((row) => !selectedRows.find((selectedRow) => selectedRow[keyId] === row[keyId])).length;
-    }, [availableRows, selectedRows, keyId]);
+    const uncheckedRowsCount = useMemo(() => availableRows.filter((row) => !selectedIds.has(row[keyId])).length, [availableRows, selectedIds, keyId]);
     const handleRangeChanged = useCallback((range) => {
         if (scrollToTopButtonRef.current) {
             scrollToTopButtonRef.current.classList.toggle(dataGridInfiniteClassnames.visibleScrollToTopButton, range.startIndex > baseIndex.current + 2);
@@ -94,11 +101,11 @@ export const useLogic = ({ keyId, columns, rows, variant, tree, subrows, selecte
             return;
         }
         if (event.target.checked) {
-            const mergedSelectedRows = uniqueBy([...selectedRows, ...availableRows], prop(keyId));
+            const mergedSelectedRows = uniqueBy([...selectedRowsRef.current, ...availableRows], (row) => row[keyId]);
             return onSelectRow(mergedSelectedRows);
         }
-        const filteredRows = selectedRows.filter((selectedRow) => !rows.find((row) => row[keyId] === selectedRow[keyId]));
-        onSelectRow(filteredRows);
+        const rowsIds = new Set(rows.map((row) => row[keyId]));
+        onSelectRow(selectedRowsRef.current.filter((selectedRow) => !rowsIds.has(selectedRow[keyId])));
     };
     const handleSelectRow = useCallback((row) => (event) => {
         if (!onSelectRow) {
@@ -115,8 +122,12 @@ export const useLogic = ({ keyId, columns, rows, variant, tree, subrows, selecte
     const recalculateVerticalScroll = (listHeight) => {
         const container = document.getElementById(VIRTUOSO_CONTAINER_ID);
         if (container) {
-            const massActionsSpacerHeight = container.querySelector(`.${dataGridInfiniteClassnames.massActionsSpacer}`)?.clientHeight ?? 0;
-            setHasVerticalScroll(listHeight - massActionsSpacerHeight > container.clientHeight);
+            // listHeight включает header и footer
+            const getHeight = (className) => container.querySelector(`.${className}`)?.clientHeight ?? 0;
+            const rowsHeight = listHeight -
+                getHeight(dataGridInfiniteClassnames.header) -
+                getHeight(dataGridInfiniteClassnames.footer);
+            setHasVerticalScroll(rowsHeight > container.clientHeight);
         }
     };
     const isHideHead = isHideHeaderIfNoData && rows.length === 0;
@@ -152,8 +163,9 @@ export const useLogic = ({ keyId, columns, rows, variant, tree, subrows, selecte
         onRetry,
         hasMassActions,
     ]);
+    const virtuosoContext = useMemo(() => ({ ...itemContext, ...footerContext }), [itemContext, footerContext]);
     return {
-        footerContext,
+        virtuosoContext,
         hasMassActions,
         isMassActionsOpen,
         containerCssVars,