@astral/ui 4.113.2 → 4.114.0

package/components/ActionGroup/ActionGroup.js

@@ -5,7 +5,7 @@ import { SecondaryActions } from './SecondaryActions';
 import { SecondaryVisibleActions } from './SecondaryVisibleActions';
 import { Wrapper } from './styles';
 export const ActionGroup = (props) => {
-    const { main, secondary, secondaryVisible, className, size = 'medium', } = props;
+    const { main, secondary, secondaryVisible, secondaryPopoverProps, className, size = 'medium', } = props;
     const { disabledAction } = useActionsState({ main, secondary });
-    return (_jsxs(Wrapper, { className: className, children: [secondary && (_jsx(SecondaryActions, { isDisabled: disabledAction, actions: secondary, size: size })), secondaryVisible && (_jsx(SecondaryVisibleActions, { actions: secondaryVisible, size: size })), main && (_jsx(MainActions, { isDisabled: disabledAction, actions: main, size: size }))] }));
+    return (_jsxs(Wrapper, { className: className, children: [secondary && (_jsx(SecondaryActions, { isDisabled: disabledAction, actions: secondary, size: size, popoverProps: secondaryPopoverProps })), secondaryVisible && (_jsx(SecondaryVisibleActions, { actions: secondaryVisible, size: size })), main && (_jsx(MainActions, { isDisabled: disabledAction, actions: main, size: size }))] }));
 };

package/components/ActionGroup/SecondaryActions/SecondaryActions.d.ts

@@ -1,3 +1,3 @@
 import { type ElementType } from 'react';
 import type { SecondaryActionProps } from '../types';
-export declare const SecondaryActions: <TSecondaryActionComponent extends ElementType = ElementType>({ actions, isDisabled, className, size, }: SecondaryActionProps<TSecondaryActionComponent>) => import("react/jsx-runtime").JSX.Element | null;
+export declare const SecondaryActions: <TSecondaryActionComponent extends ElementType = ElementType>({ actions, isDisabled, className, size, popoverProps, }: SecondaryActionProps<TSecondaryActionComponent>) => import("react/jsx-runtime").JSX.Element | null;

package/components/ActionGroup/SecondaryActions/SecondaryActions.js

@@ -5,10 +5,10 @@ import { IconDropdownButton } from '../../IconDropdownButton';
 import { ListItemButton } from '../../ListItemButton';
 import { ListItemText } from '../../ListItemText';
 const TOOLTIP_PLACEMENT = 'right';
-export const SecondaryActions = ({ actions, isDisabled, className, size, }) => {
+export const SecondaryActions = ({ actions, isDisabled, className, size, popoverProps, }) => {
     if (!actions.length) {
         return null;
     }
-    return (_jsx(IconDropdownButton, { disabled: isDisabled, icon: _jsx(DotsOutlineMd, {}), variant: "outlined", color: "grey", size: size, className: className, children: actions.map(({ text, ...secondaryProps }) => (_createElement(ListItemButton, { tooltipPlacement: TOOLTIP_PLACEMENT, ...secondaryProps, key: text },
+    return (_jsx(IconDropdownButton, { disabled: isDisabled, icon: _jsx(DotsOutlineMd, {}), variant: "outlined", color: "grey", size: size, className: className, popoverProps: popoverProps, children: actions.map(({ text, ...secondaryProps }) => (_createElement(ListItemButton, { tooltipPlacement: TOOLTIP_PLACEMENT, ...secondaryProps, key: text },
             _jsx(ListItemText, { primary: text })))) }));
 };

package/components/ActionGroup/types.d.ts

@@ -1,6 +1,7 @@
 import type { ComponentProps, ElementType, ReactElement, ReactNode } from 'react';
 import type { ButtonProps, ButtonSize } from '../Button';
 import type { DropdownButtonProps } from '../DropdownButton';
+import type { IconDropdownButtonProps } from '../IconDropdownButton';
 import type { ListItemButtonProps } from '../ListItemButton';
 import type { MenuItemProps } from '../MenuItem';
 import type { TooltipProps } from '../Tooltip';
@@ -143,6 +144,10 @@ export type SecondaryActionProps<TSecondaryActionComponent extends ElementType>
      */
     className?: string;
     size?: ButtonSize;
+    /**
+     * Пропсы Popover меню второстепенных действий
+     */
+    popoverProps?: IconDropdownButtonProps['popoverProps'];
 };
 /** Модель второстепенного видимого экшена */
 export type SecondaryVisibleAction = Omit<ButtonProps, 'children'> & {
@@ -177,6 +182,10 @@ export type ActionGroupProps<TMainActionComponent extends ElementType = ElementT
      * Второстепенные действия, спрятанные за троеточием
      */
     secondary?: SecondaryAction<TSecondaryActionComponent>[];
+    /**
+     * Пропсы Popover меню второстепенных действий
+     */
+    secondaryPopoverProps?: IconDropdownButtonProps['popoverProps'];
     /**
      * Видимые второстепенные действия
      */

package/components/DataGrid/DataGrid.js

@@ -15,7 +15,7 @@ import { Loader } from './Loader';
 import { MobileSkeleton } from './MobileSkeleton';
 import { NoData } from './NoData';
 import { PinnedSections } from './PinnedSections';
-import { Container, DataGridWrapper, DisabledDataGridWrapper } from './styles';
+import { Container, DataGridWrapper, DisabledDataGridWrapper, MassActionsAnchor, } from './styles';
 import { useLogic } from './useLogic';
 const pinnedSectionsCva = cva(dataGridClassnames.pinnedSections, {
     variants: {
@@ -26,6 +26,12 @@ const pinnedSectionsCva = cva(dataGridClassnames.pinnedSections, {
 });
 const dataGridCva = cva(dataGridClassnames.root, {
     variants: {
+        hasMassActions: {
+            true: dataGridClassnames.hasMassActions,
+        },
+        isMassActionsOpen: {
+            true: dataGridClassnames.massActionsOpen,
+        },
         hasPinnedColumns: {
             true: dataGridClassnames.hasPinnedSections,
         },
@@ -56,9 +62,9 @@ const bodyCva = cva(dataGridClassnames.body, {
     },
 });
 export const DataGrid = (props) => {
-    const { dataGridClassName, isDataGridDisabled, treeRenderConfig, headColumns, headProps, bodyProps, gridColumns, loaderProps, renderRows, isAllowHorizontalScroll, isHideHead, hasPinnedColumns, contentStateProps, rowHoverProps, containerRef, sections, isNoData, isMobile, mobileSkeletonProps, isLoading, containerCssVars, hasGroupedColumns, gridViewMode, mobileDisplayVariant, isSelfContained, } = useLogic(props);
+    const { dataGridClassName, isDataGridDisabled, treeRenderConfig, headColumns, headProps, bodyProps, gridColumns, loaderProps, renderRows, isAllowHorizontalScroll, isHideHead, hasPinnedColumns, contentStateProps, rowHoverProps, containerRef, sections, isNoData, isMobile, mobileSkeletonProps, isLoading, containerCssVars, hasGroupedColumns, gridViewMode, mobileDisplayVariant, isSelfContained, isMassActionsOpen, hasMassActions, } = useLogic(props);
     const { emptySymbol } = useContext(ConfigContext);
-    const { columns, selectedRows = [], minDisplayRows = MIN_DISPLAY_ROWS_BY_DEFAULT, variant = Variant.Tree, footer, noDataPlaceholder, subrows, keyId, activeRowId, emptyCellValue = emptySymbol, onRowClick, noDataOptions, headPreAddon, isTabularNums, renderRow, renderLink, } = props;
+    const { columns, selectedRows = [], onSelectRow, minDisplayRows = MIN_DISPLAY_ROWS_BY_DEFAULT, variant = Variant.Tree, footer, massActions, noDataPlaceholder, subrows, keyId, activeRowId, emptyCellValue = emptySymbol, onRowClick, noDataOptions, headPreAddon, isTabularNums, renderRow, renderLink, } = 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 Wrapper = isDataGridDisabled
@@ -98,12 +104,14 @@ export const DataGrid = (props) => {
                     isDisabled: isDataGridDisabled,
                 }), isDisabled: isDataGridDisabled, headProps: headProps, gridColumns: gridColumns, bodyProps: commonBodyProps, isNoData: isNoData }) }));
     };
-    return (_jsx(DataGridContextProvider, { isLoading: isLoading, isTabularNums: isTabularNums, gridColumns: gridColumns, emptyCellValue: emptyCellValue, activeRowId: activeRowId, keyId: keyId, columns: columns, onRowClick: onRowClick, mobileDisplayVariant: mobileDisplayVariant, renderLink: renderLink, children: _jsxs(Container, { ref: containerRef, style: containerCssVars, className: cn(dataGridClassName, dataGridCva({
+    return (_jsx(DataGridContextProvider, { isLoading: isLoading, isTabularNums: isTabularNums, gridColumns: gridColumns, emptyCellValue: emptyCellValue, activeRowId: activeRowId, keyId: keyId, columns: columns, onRowClick: onRowClick, mobileDisplayVariant: mobileDisplayVariant, renderLink: renderLink, selectedRows: selectedRows, onSelectRow: onSelectRow, isMassActionsOpen: isMassActionsOpen, children: _jsxs(Container, { ref: containerRef, style: containerCssVars, className: cn(dataGridClassName, dataGridCva({
                 isAllowHorizontalScroll,
                 hasPinnedColumns,
                 gridViewMode,
                 hasGroupedColumns,
                 mobileDisplayVariant,
                 isSelfContained,
-            })), children: [renderTableContent(), _jsx(Loader, { ...loaderProps }), footer && footer] }) }));
+                hasMassActions,
+                isMassActionsOpen,
+            })), children: [renderTableContent(), _jsx(Loader, { ...loaderProps }), massActions && _jsx(MassActionsAnchor, { children: massActions }), footer && footer] }) }));
 };

package/components/DataGrid/DataGridContext/DataGridProvider/DataGridProvider.d.ts

@@ -1,7 +1,8 @@
 import { type ReactNode } from 'react';
+import { type DataGridSelectionContextProps } from '../../DataGridSelectionContext';
 import { type DataGridContextProps } from '../DataGridContext';
-type DataGridContextProviderProps = Pick<DataGridContextProps, 'isLoading' | 'isTabularNums' | 'gridColumns' | 'emptyCellValue' | 'activeRowId' | 'keyId' | 'columns' | 'onRowClick' | 'mobileDisplayVariant' | 'renderLink'> & {
+type DataGridContextProviderProps = Pick<DataGridContextProps, 'isLoading' | 'isTabularNums' | 'gridColumns' | 'emptyCellValue' | 'activeRowId' | 'keyId' | 'columns' | 'onRowClick' | 'mobileDisplayVariant' | 'renderLink'> & Partial<DataGridSelectionContextProps> & {
     children: ReactNode;
 };
-export declare const DataGridContextProvider: ({ isLoading, isTabularNums, gridColumns, emptyCellValue, activeRowId, children, keyId, columns, onRowClick, mobileDisplayVariant, renderLink, }: DataGridContextProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const DataGridContextProvider: ({ isLoading, isTabularNums, gridColumns, emptyCellValue, activeRowId, children, keyId, columns, onRowClick, mobileDisplayVariant, renderLink, selectedRows, onSelectRow, isMassActionsOpen, }: DataGridContextProviderProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/components/DataGrid/DataGridContext/DataGridProvider/DataGridProvider.js

@@ -1,8 +1,9 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useMemo } from 'react';
+import { DataGridSelectionProvider, } from '../../DataGridSelectionContext';
 import { DataGridStorageProvider } from '../../DataGridStorageContext';
 import { DataGridContext } from '../DataGridContext';
-export const DataGridContextProvider = ({ isLoading, isTabularNums, gridColumns, emptyCellValue, activeRowId, children, keyId, columns, onRowClick, mobileDisplayVariant, renderLink, }) => {
+export const DataGridContextProvider = ({ isLoading, isTabularNums, gridColumns, emptyCellValue, activeRowId, children, keyId, columns, onRowClick, mobileDisplayVariant, renderLink, selectedRows, onSelectRow, isMassActionsOpen, }) => {
     const contextValue = useMemo(() => ({
         isLoading,
         isTabularNums,
@@ -26,5 +27,5 @@ export const DataGridContextProvider = ({ isLoading, isTabularNums, gridColumns,
         mobileDisplayVariant,
         renderLink,
     ]);
-    return (_jsx(DataGridContext.Provider, { value: contextValue, children: _jsx(DataGridStorageProvider, { children: children }) }));
+    return (_jsx(DataGridContext.Provider, { value: contextValue, children: _jsx(DataGridSelectionProvider, { selectedRows: selectedRows, onSelectRow: onSelectRow, isMassActionsOpen: isMassActionsOpen, children: _jsx(DataGridStorageProvider, { children: children }) }) }));
 };

package/components/DataGrid/DataGridSelectionContext/DataGridSelectionContext.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="react" />
+import { type ContextOnChangeSelectedRows, type ContextSelectedRows } from '../types';
+export type DataGridSelectionContextProps = {
+    /**
+     * Выбранные строки таблицы
+     */
+    selectedRows: ContextSelectedRows;
+    /**
+     * Обработчик изменения выбора, переданный в таблицу.
+     */
+    onSelectRow?: ContextOnChangeSelectedRows;
+    /**
+     * Флаг отображения панели массовых действий
+     */
+    isMassActionsOpen: boolean;
+};
+/**
+ * Контекст выбранных строк таблицы для панели массовых действий.
+ *
+ * Вынесен из `DataGridContext`, чтобы изменение выбора не вызывало ре-рендер всех строк и ячеек:
+ * контекст читает только панель массовых действий.
+ *
+ * Провайдер подключается внутри `DataGridContextProvider`.
+ */
+export declare const DataGridSelectionContext: import("react").Context<DataGridSelectionContextProps>;

package/components/DataGrid/DataGridSelectionContext/DataGridSelectionContext.js

@@ -0,0 +1,13 @@
+import { createContext } from 'react';
+/**
+ * Контекст выбранных строк таблицы для панели массовых действий.
+ *
+ * Вынесен из `DataGridContext`, чтобы изменение выбора не вызывало ре-рендер всех строк и ячеек:
+ * контекст читает только панель массовых действий.
+ *
+ * Провайдер подключается внутри `DataGridContextProvider`.
+ */
+export const DataGridSelectionContext = createContext({
+    selectedRows: [],
+    isMassActionsOpen: false,
+});

package/components/DataGrid/DataGridSelectionContext/DataGridSelectionProvider/DataGridSelectionProvider.d.ts

@@ -0,0 +1,7 @@
+import { type ReactNode } from 'react';
+import { type DataGridSelectionContextProps } from '../DataGridSelectionContext';
+type DataGridSelectionProviderProps = Partial<DataGridSelectionContextProps> & {
+    children: ReactNode;
+};
+export declare const DataGridSelectionProvider: ({ selectedRows, onSelectRow, isMassActionsOpen, children, }: DataGridSelectionProviderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/components/DataGrid/DataGridSelectionContext/DataGridSelectionProvider/DataGridSelectionProvider.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { DataGridSelectionContext, } from '../DataGridSelectionContext';
+const EMPTY_SELECTED_ROWS = [];
+export const DataGridSelectionProvider = ({ selectedRows = EMPTY_SELECTED_ROWS, onSelectRow, isMassActionsOpen = false, children, }) => {
+    const contextValue = useMemo(() => ({ selectedRows, onSelectRow, isMassActionsOpen }), [selectedRows, onSelectRow, isMassActionsOpen]);
+    return (_jsx(DataGridSelectionContext.Provider, { value: contextValue, children: children }));
+};

package/components/DataGrid/DataGridSelectionContext/DataGridSelectionProvider/index.d.ts

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

package/components/DataGrid/DataGridSelectionContext/DataGridSelectionProvider/index.js

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

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

@@ -0,0 +1,2 @@
+export * from './DataGridSelectionContext';
+export * from './DataGridSelectionProvider';

package/components/DataGrid/DataGridSelectionContext/index.js

@@ -0,0 +1,2 @@
+export * from './DataGridSelectionContext';
+export * from './DataGridSelectionProvider';

package/components/DataGrid/constants.d.ts

@@ -21,6 +21,8 @@ export declare const dataGridClassnames: {
     rightPinnedSection: string;
     overflowed: string;
     wrapper: string;
+    hasMassActions: string;
+    massActionsOpen: string;
     isAllowHorizontalScroll: string;
     hasGroupedColumns: string;
     gridViewFull: string;

package/components/DataGrid/constants.js

@@ -22,6 +22,8 @@ export const dataGridClassnames = {
     rightPinnedSection: createUIKitClassname('data-grid__right-pinned-section'),
     overflowed: createUIKitClassname('data-grid_overflowed'),
     wrapper: createUIKitClassname('data-grid__wrapper'),
+    hasMassActions: createUIKitClassname('data-grid_has-mass-actions'),
+    massActionsOpen: createUIKitClassname('data-grid_mass-actions-open'),
     isAllowHorizontalScroll: createUIKitClassname('data-grid_is-allow-horizontal-scroll'),
     hasGroupedColumns: createUIKitClassname('data-grid_has-grouped-columns'),
     gridViewFull: createUIKitClassname('data-grid_grid-view-full'),

package/components/DataGrid/styles.d.ts

@@ -13,3 +13,7 @@ export declare const DisabledDataGridWrapper: import("../styled").StyledComponen
 } & import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
     theme?: import("@emotion/react").Theme | undefined;
 }, {}, {}>;
+export declare const MassActionsAnchor: import("../styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements> | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

package/components/DataGrid/styles.js

@@ -7,6 +7,9 @@ import { dataGridRowClassnames } from './Row/constants';
 export const Container = styled.div `
   --max-height: initial;
 
+  /* Место под открытой панелью массовых действий: высота панели + отступ */
+  --mass-actions-reserved-space: 96px;
+
   position: relative;
 
   overflow: hidden;
@@ -152,6 +155,24 @@ export const Container = styled.div `
       }
     }
   }
+
+  &.${dataGridClassnames.hasMassActions} {
+    /* Резерв места под панель массовых действий убирается одновременно с анимацией её скрытия, чтобы строки не прыгали */
+    & .${dataGridClassnames.wrapper} .${dataGridClassnames.body},
+    & .${dataGridClassnames.pinnedSections} {
+      transition: padding-bottom
+        ${({ theme }) => theme.transitions.duration.leavingScreen}ms
+        ${({ theme }) => theme.transitions.easing.easeIn};
+    }
+
+    /* Пока панель массовых действий открыта, последние строки не должны перекрываться ею */
+    &.${dataGridClassnames.massActionsOpen} {
+      & .${dataGridClassnames.wrapper} .${dataGridClassnames.body},
+      & .${dataGridClassnames.pinnedSections} {
+        padding-bottom: var(--mass-actions-reserved-space);
+      }
+    }
+  }
 `;
 export const DataGridWrapper = styled.div `
   position: relative;
@@ -177,3 +198,8 @@ export const DisabledDataGridWrapper = styled(DataGridWrapper) `
     opacity: 0.7;
   }
 `;
+export const MassActionsAnchor = styled.div `
+  position: relative;
+
+  height: 0;
+`;

package/components/DataGrid/types.d.ts

@@ -46,6 +46,11 @@ export type DataGridProps<TData extends Record<string, CellValue> = DataGridRow,
      * Компонент кастомного футера (например Pagination)
      */
     footer?: ReactNode;
+    /**
+     * Панель массовых действий над выбранными строками
+     * @example <DataGrid massActions={<DataGridMassActions />} />
+     */
+    massActions?: ReactNode;
     /**
      *  Используется для отображения placeholder при отсутствии данных в таблице
      */
@@ -367,4 +372,6 @@ export type DataGridRowWithOptions<TData extends DataGridRow> = TData & {
     children?: DataGridRowWithOptions<TData>[];
 };
 export type ContextOnRowClick = (row: Record<string, unknown>) => void;
+export type ContextSelectedRows = Record<string, unknown>[];
+export type ContextOnChangeSelectedRows = (rows: ContextSelectedRows) => void;
 export type RenderRow = (row: Record<string, unknown>, index: number) => ReactNode;

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

@@ -1,7 +1,9 @@
 import { type ChangeEvent } from 'react';
 import type { CellValue, DataGridProps, DataGridRow } 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, }: 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, mobileDisplayVariant, onSelectRow, isError, onRetry, errorMsg, isHideSelectAll, isHideHeaderIfNoData, sorting, className, onSort, maxHeight, gridViewMode: gridViewModeProp, massActions, }: UseLogicParams<TData, TSortField>) => {
+    hasMassActions: boolean;
+    isMassActionsOpen: boolean;
     dataGridClassName: string | undefined;
     containerCssVars: import("react").CSSProperties;
     isDataGridDisabled: boolean | undefined;

package/components/DataGrid/useLogic/useLogic.js

@@ -5,10 +5,10 @@ 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 { getDataGridCssVars, getFlattenColumns, getGridTemplateColumns, isGroupColumns, } from '../utils';
+import { checkIsMassActionsOpen, getDataGridCssVars, getFlattenColumns, getGridTemplateColumns, isGroupColumns, } 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', }) => {
+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, }) => {
     const isFirstRender = useFirstMountState();
     const isSelectable = Boolean(onSelectRow);
     const isDataGridDisabled = isLoading || isDisabled;
@@ -102,7 +102,15 @@ export const useLogic = ({ keyId, columns, rows = [], variant, tree, subrows, se
         };
     }, [isLoading, isError, isNoData, errorMsg, onRetry, imagesMap]);
     const containerCssVars = getDataGridCssVars(maxHeight);
+    const hasMassActions = Boolean(massActions);
+    const isMassActionsOpen = checkIsMassActionsOpen({
+        hasMassActions,
+        selectedRowsCount: selectedRows.length,
+        isMobile,
+    });
     return {
+        hasMassActions,
+        isMassActionsOpen,
         dataGridClassName: className,
         containerCssVars,
         isDataGridDisabled,

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

@@ -0,0 +1,10 @@
+type CheckIsMassActionsOpenParams = {
+    hasMassActions: boolean;
+    selectedRowsCount: number;
+    isMobile: boolean;
+};
+/**
+ * Панель массовых действий открыта, если она передана, выбрана хотя бы одна строка и это не мобильное разрешение
+ */
+export declare const checkIsMassActionsOpen: ({ hasMassActions, selectedRowsCount, isMobile, }: CheckIsMassActionsOpenParams) => boolean;
+export {};

package/components/DataGrid/utils/checkIsMassActionsOpen/checkIsMassActionsOpen.js

@@ -0,0 +1,4 @@
+/**
+ * Панель массовых действий открыта, если она передана, выбрана хотя бы одна строка и это не мобильное разрешение
+ */
+export const checkIsMassActionsOpen = ({ hasMassActions, selectedRowsCount, isMobile, }) => hasMassActions && selectedRowsCount > 0 && !isMobile;

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

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

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

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

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

@@ -2,3 +2,4 @@ export { getDataGridCssVars } from './getDataGridCssVars';
 export { getGridTemplateColumns } from './getGridTemplateColumns';
 export { isGroupColumns } from './isGroupColumns';
 export { getFlattenColumns } from './getFlattenColumns';
+export { checkIsMassActionsOpen } from './checkIsMassActionsOpen';

package/components/DataGrid/utils/index.js

@@ -2,3 +2,4 @@ export { getDataGridCssVars } from './getDataGridCssVars';
 export { getGridTemplateColumns } from './getGridTemplateColumns';
 export { isGroupColumns } from './isGroupColumns';
 export { getFlattenColumns } from './getFlattenColumns';
+export { checkIsMassActionsOpen } from './checkIsMassActionsOpen';

package/components/DataGridInfinite/DataGridInfinite.js

@@ -9,21 +9,28 @@ import { dataGridClassnames, EXPANDED_LEVEL_BY_DEFAULT, INITIAL_OPENED_NESTED_CH
 import { DataGridContextProvider } from '../DataGrid/DataGridContext';
 import { Variant } from '../DataGrid/enums';
 import { Head } from '../DataGrid/Head';
+import { MassActionsAnchor } from '../DataGrid/styles';
 import { Loader } from '../Loader';
 import { cn } from '../utils/cn';
 import { cva } from '../utils/cva';
 import { getInertProps } from '../utils/getInertProps';
 import { dataGridInfiniteClassnames, OVERSCAN_COUNT } from './constants';
 import { DataGridInfiniteContextProvider } from './DataGridInfiniteContext';
-import { EndData } from './EndData';
 import { ErrorMessage } from './ErrorMessage';
+import { Footer } from './Footer';
 import { List } from './List';
 import { NoData } from './NoData';
 import { Row } from './Row';
-import { Backdrop, DataGridWrapper, DisabledDataGridWrapper, FooterRow, HeaderRow, StyledContainer, StyledScrollToTopButton, } from './styles';
+import { Backdrop, DataGridWrapper, DisabledDataGridWrapper, HeaderRow, StyledContainer, StyledScrollToTopButton, } from './styles';
 import { useLogic } from './useLogic';
 const dataGridInfiniteCva = cva(dataGridClassnames.root, {
     variants: {
+        hasMassActions: {
+            true: dataGridClassnames.hasMassActions,
+        },
+        isMassActionsOpen: {
+            true: dataGridClassnames.massActionsOpen,
+        },
         hasGroupedColumns: {
             true: dataGridClassnames.hasGroupedColumns,
         },
@@ -42,17 +49,19 @@ const dataGridInfiniteCva = cva(dataGridClassnames.root, {
 });
 export const DataGridInfinite = (props) => {
     const { imagesMap, emptySymbol } = useContext(ConfigContext);
-    const { isNoData, isDataGridDisabled, treeRenderConfig, virtuosoProps, headProps, rowProps, scrollToTopButtonProps, isEndReached, isHideHead, containerCssVars, isMobile, mobileSkeletonProps, hasGroupedColumns, gridViewMode, gridColumns, handleSelectRow, mobileDisplayVariant, isSelfContained, isNotRenderHeader, initialTopMostItemIndex, } = useLogic(props);
-    const { columns, rows = [], selectedRows = [], sorting, isLoading, isDisabled, keyId, emptyCellValue = emptySymbol, variant = Variant.Tree, subrows, className, isError, endOfScrollMsg, errorMsg, noDataPlaceholder, onRowClick, onSort, onRetry, headPreAddon, activeRowId, isTabularNums, renderRow, renderLink, } = props;
+    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 { 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, 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, 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({
                     hasGroupedColumns,
                     gridViewMode,
                     mobileDisplayVariant,
                     isSelfContained,
+                    hasMassActions,
+                    isMassActionsOpen,
                 }), className), children: [headPreAddon, _jsxs(TableContainer, { ...getInertProps(isDataGridDisabled), children: [!isHideHead && (_jsx(Head, { ...headProps, onSort: onSort, sorting: sorting, columns: columns })), _jsx(ContentState, { isLoading: isLoading && !isNoData, loadingTitle: "\u0417\u0430\u0433\u0440\u0443\u0437\u043A\u0430 \u0434\u0430\u043D\u043D\u044B\u0445", isError: isError && !isNoData, loadingContent: isMobile && _jsx(MobileSkeleton, { ...mobileSkeletonProps }), errorState: {
                                     imgAlt: 'Что-то пошло не так',
                                     errorList: [errorMsg || ''],
@@ -60,23 +69,18 @@ export const DataGridInfinite = (props) => {
                                     onRetry,
                                 }, children: _jsx(Virtuoso, { ...virtuosoProps, ...(initialTopMostItemIndex && {
                                         initialTopMostItemIndex,
-                                    }), style: { height: '100%' }, overscan: OVERSCAN_COUNT, data: rows, components: {
+                                    }), style: { height: '100%' }, overscan: OVERSCAN_COUNT, data: rows, context: footerContext, components: {
                                         // biome-ignore lint/suspicious/noTsIgnore: Требует HTMLDivElement, а для элемента списка используем HTMLUListElement (https://github.com/petyosi/react-virtuoso/issues/864)
                                         // @ts-ignore
                                         List,
                                         Item: Row,
                                         EmptyPlaceholder: () => (_jsx(_Fragment, { children: noDataPlaceholder || _jsx(NoData, {}) })),
-                                        Footer: () => {
-                                            if (!isLoading && !isError && !isEndReached) {
-                                                return null;
-                                            }
-                                            return (_jsxs(FooterRow, { children: [isLoading && _jsx(Loader, {}), isError && _jsx(ErrorMessage, { onRetry: onRetry }), isEndReached && (_jsx(EndData, { endOfScrollMsg: endOfScrollMsg }))] }));
-                                        },
+                                        Footer,
                                         Header: () => {
                                             if (isNotRenderHeader) {
                                                 return null;
                                             }
                                             return (_jsxs(HeaderRow, { children: [isLoading && _jsx(Loader, {}), isError && _jsx(ErrorMessage, { onRetry: onRetry })] }));
                                         },
-                                    } }) }), _jsx(StyledScrollToTopButton, { ...scrollToTopButtonProps, className: dataGridInfiniteClassnames.scrollToTopButton }), isDisabled && _jsx(Backdrop, {})] })] }) }) }));
+                                    } }) }), massActions && (_jsx(MassActionsAnchor, { children: massActions })), _jsx(StyledScrollToTopButton, { ...scrollToTopButtonProps, className: dataGridInfiniteClassnames.scrollToTopButton }), isDisabled && _jsx(Backdrop, {})] })] }) }) }));
 };

package/components/DataGridInfinite/Footer/Footer.d.ts

@@ -0,0 +1,6 @@
+import type { ContextProp } from 'react-virtuoso';
+import type { FooterContext } from './types';
+/**
+ * Футер списка для Virtuoso.
+ */
+export declare const Footer: ({ context }: ContextProp<FooterContext>) => import("react/jsx-runtime").JSX.Element;

package/components/DataGridInfinite/Footer/Footer.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Loader } from '../../Loader';
+import { dataGridInfiniteClassnames } from '../constants';
+import { EndData } from '../EndData';
+import { ErrorMessage } from '../ErrorMessage';
+import { FooterRow, MassActionsSpacer } from '../styles';
+/**
+ * Футер списка для Virtuoso.
+ */
+export const Footer = ({ context }) => {
+    const { isLoading, isError, isEndReached, endOfScrollMsg, onRetry, hasMassActions, } = context;
+    const renderStatus = () => {
+        if (isLoading) {
+            return (_jsx(FooterRow, { children: _jsx(Loader, {}) }));
+        }
+        if (isError) {
+            return (_jsx(FooterRow, { children: _jsx(ErrorMessage, { onRetry: onRetry }) }));
+        }
+        if (isEndReached) {
+            return (_jsx(FooterRow, { children: _jsx(EndData, { endOfScrollMsg: endOfScrollMsg }) }));
+        }
+        return null;
+    };
+    return (_jsxs(_Fragment, { children: [renderStatus(), hasMassActions && (_jsx(MassActionsSpacer, { className: dataGridInfiniteClassnames.massActionsSpacer }))] }));
+};

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

@@ -0,0 +1,2 @@
+export * from './Footer';
+export type { FooterContext } from './types';

package/components/DataGridInfinite/Footer/index.js

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

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

@@ -0,0 +1,26 @@
+export type FooterContext = {
+    /**
+     * Флаг состояния загрузки
+     */
+    isLoading?: boolean;
+    /**
+     * Флаг состояния ошибки
+     */
+    isError?: boolean;
+    /**
+     * Флаг достижения конца списка
+     */
+    isEndReached?: boolean;
+    /**
+     * Текст достижения конца списка
+     */
+    endOfScrollMsg?: string;
+    /**
+     * Обработчик повторной загрузки при ошибке
+     */
+    onRetry: () => void;
+    /**
+     * Флаг наличия массовых действий
+     */
+    hasMassActions: boolean;
+};

package/components/DataGridInfinite/Footer/types.js

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

package/components/DataGridInfinite/constants.d.ts

@@ -5,4 +5,5 @@ export declare const VIRTUOSO_LIST_ID = "virtuoso-list";
 export declare const dataGridInfiniteClassnames: {
     scrollToTopButton: string;
     visibleScrollToTopButton: string;
+    massActionsSpacer: string;
 };

package/components/DataGridInfinite/constants.js

@@ -6,4 +6,5 @@ export const VIRTUOSO_LIST_ID = 'virtuoso-list';
 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'),
 };

package/components/DataGridInfinite/styles.d.ts

@@ -30,3 +30,7 @@ export declare const StyledContainer: import("../styled").StyledComponent<{
 } & import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
     theme?: import("@emotion/react").Theme | undefined;
 }, {}, {}>;
+export declare const MassActionsSpacer: import("../styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements> | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

package/components/DataGridInfinite/styles.js

@@ -1,3 +1,4 @@
+import { dataGridClassnames } from '../DataGrid/constants';
 import { Container } from '../DataGrid/styles';
 import { ScrollToTopButton } from '../ScrollToTopButton';
 import { styled } from '../styled';
@@ -52,6 +53,26 @@ export const StyledScrollToTopButton = styled(ScrollToTopButton) `
   }
 `;
 export const StyledContainer = styled(Container) `
+  &.${dataGridClassnames.hasMassActions} {
+    /* Резерв места под панель массовых действий убирается одновременно с анимацией её скрытия, чтобы строки не прыгали */
+    & .${dataGridInfiniteClassnames.massActionsSpacer} {
+      transition: height
+        ${({ theme }) => theme.transitions.duration.leavingScreen}ms
+        ${({ theme }) => theme.transitions.easing.easeIn};
+    }
+
+    &.${dataGridClassnames.massActionsOpen} {
+      & .${dataGridInfiniteClassnames.massActionsSpacer} {
+        height: var(--mass-actions-reserved-space);
+      }
+
+      /* Кнопка «Наверх» скрыта при открытой панели, чтобы не перегружать интерфейс */
+      & .${dataGridInfiniteClassnames.scrollToTopButton} {
+        display: none;
+      }
+    }
+  }
+
   ${({ theme }) => theme.breakpoints.down('mobile')} {
     & .${dataGridInfiniteListClassnames.root} {
       display: flex;
@@ -60,3 +81,6 @@ export const StyledContainer = styled(Container) `
     }
   }
 `;
+export const MassActionsSpacer = styled.div `
+  height: 0;
+`;