ydb-embedded-ui 6.7.0 → 6.9.0

package/dist/src/containers/Nodes/getNodesColumns.js

@@ -1,211 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import DataTable from '@gravity-ui/react-data-table';
-import { CellWithPopover } from '../../components/CellWithPopover/CellWithPopover';
-import { NodeHostWrapper } from '../../components/NodeHostWrapper/NodeHostWrapper';
-import { PoolsGraph } from '../../components/PoolsGraph/PoolsGraph';
-import { ProgressViewer } from '../../components/ProgressViewer/ProgressViewer';
-import { TabletsStatistic } from '../../components/TabletsStatistic';
-import { UsageLabel } from '../../components/UsageLabel/UsageLabel';
-import { getLoadSeverityForNode } from '../../store/reducers/nodes/utils';
-import { EMPTY_DATA_PLACEHOLDER } from '../../utils/constants';
-import { formatBytesToGigabyte, formatStorageValuesToGb, } from '../../utils/dataFormatters/dataFormatters';
-export const NODES_COLUMNS_WIDTH_LS_KEY = 'nodesTableColumnsWidth';
-const NODES_COLUMNS_IDS = {
-    NodeId: 'NodeId',
-    Host: 'Host',
-    DC: 'DC',
-    Rack: 'Rack',
-    Version: 'Version',
-    Uptime: 'Uptime',
-    Memory: 'Memory',
-    CPU: 'CPU',
-    LoadAverage: 'LoadAverage',
-    Tablets: 'Tablets',
-    TopNodesLoadAverage: 'TopNodesLoadAverage',
-    TopNodesMemory: 'TopNodesMemory',
-    SharedCacheUsage: 'SharedCacheUsage',
-    MemoryUsedInAlloc: 'MemoryUsedInAlloc',
-    TotalSessions: 'TotalSessions',
-};
-const nodeIdColumn = {
-    name: NODES_COLUMNS_IDS.NodeId,
-    header: '#',
-    width: 80,
-    render: ({ row }) => row.NodeId,
-    align: DataTable.RIGHT,
-    sortable: false,
-};
-const getHostColumn = (getNodeRef) => ({
-    name: NODES_COLUMNS_IDS.Host,
-    render: ({ row }) => {
-        return _jsx(NodeHostWrapper, { node: row, getNodeRef: getNodeRef });
-    },
-    width: 350,
-    align: DataTable.LEFT,
-    sortable: false,
-});
-const getHostColumnWithUndefinedWidth = (getNodeRef) => {
-    return Object.assign(Object.assign({}, getHostColumn(getNodeRef)), { width: undefined });
-};
-const dataCenterColumn = {
-    name: NODES_COLUMNS_IDS.DC,
-    header: 'DC',
-    align: DataTable.LEFT,
-    render: ({ row }) => row.DC || EMPTY_DATA_PLACEHOLDER,
-    width: 60,
-};
-const rackColumn = {
-    name: NODES_COLUMNS_IDS.Rack,
-    header: 'Rack',
-    align: DataTable.LEFT,
-    render: ({ row }) => (row.Rack ? row.Rack : '—'),
-    width: 80,
-};
-const versionColumn = {
-    name: NODES_COLUMNS_IDS.Version,
-    width: 200,
-    align: DataTable.LEFT,
-    render: ({ row }) => {
-        return _jsx(CellWithPopover, { content: row.Version, children: row.Version });
-    },
-    sortable: false,
-};
-const uptimeColumn = {
-    name: NODES_COLUMNS_IDS.Uptime,
-    header: 'Uptime',
-    sortAccessor: ({ StartTime }) => StartTime && -StartTime,
-    render: ({ row }) => row.Uptime,
-    align: DataTable.RIGHT,
-    width: 110,
-    sortable: false,
-};
-const memoryColumn = {
-    name: NODES_COLUMNS_IDS.Memory,
-    header: 'Memory',
-    sortAccessor: ({ MemoryUsed = 0 }) => Number(MemoryUsed),
-    defaultOrder: DataTable.DESCENDING,
-    render: ({ row }) => {
-        if (row.MemoryUsed) {
-            return formatBytesToGigabyte(row.MemoryUsed);
-        }
-        else {
-            return '—';
-        }
-    },
-    align: DataTable.RIGHT,
-    width: 120,
-};
-const cpuColumn = {
-    name: NODES_COLUMNS_IDS.CPU,
-    header: 'CPU',
-    sortAccessor: ({ PoolStats = [] }) => Math.max(...PoolStats.map(({ Usage }) => Number(Usage))),
-    defaultOrder: DataTable.DESCENDING,
-    render: ({ row }) => (row.PoolStats ? _jsx(PoolsGraph, { pools: row.PoolStats }) : '—'),
-    align: DataTable.LEFT,
-    width: 80,
-    resizeMinWidth: 60,
-    sortable: false,
-};
-const loadAverageColumn = {
-    name: NODES_COLUMNS_IDS.LoadAverage,
-    header: 'Load average',
-    sortAccessor: ({ LoadAverage = [] }) => LoadAverage.slice(0, 1).reduce((acc, item) => acc + item, 0),
-    defaultOrder: DataTable.DESCENDING,
-    render: ({ row }) => row.LoadAverage && row.LoadAverage.length > 0 ? (_jsx(ProgressViewer, { value: row.LoadAverage[0], percents: true, colorizeProgress: true, capacity: 100 })) : ('—'),
-    align: DataTable.LEFT,
-    width: 140,
-    resizeMinWidth: 140,
-    sortable: false,
-};
-const getTabletsColumn = (tabletsPath) => ({
-    name: NODES_COLUMNS_IDS.Tablets,
-    width: 500,
-    resizeMinWidth: 500,
-    render: ({ row }) => {
-        return row.Tablets ? (_jsx(TabletsStatistic, { path: tabletsPath !== null && tabletsPath !== void 0 ? tabletsPath : row.TenantName, nodeIds: [row.NodeId], tablets: row.Tablets })) : ('—');
-    },
-    align: DataTable.LEFT,
-    sortable: false,
-});
-const topNodesLoadAverageColumn = {
-    name: NODES_COLUMNS_IDS.TopNodesLoadAverage,
-    header: 'Load',
-    render: ({ row }) => row.LoadAverage && row.LoadAverage.length > 0 ? (_jsx(UsageLabel, { value: row.LoadAverage[0].toFixed(), theme: getLoadSeverityForNode(row.LoadAverage[0]) })) : ('—'),
-    align: DataTable.LEFT,
-    width: 80,
-    resizeMinWidth: 70,
-    sortable: false,
-};
-const topNodesMemoryColumn = {
-    name: NODES_COLUMNS_IDS.TopNodesMemory,
-    header: 'Process',
-    render: ({ row }) => (_jsx(ProgressViewer, { value: row.MemoryUsed, capacity: row.MemoryLimit, formatValues: formatStorageValuesToGb, colorizeProgress: true })),
-    align: DataTable.LEFT,
-    width: 140,
-    resizeMinWidth: 140,
-    sortable: false,
-};
-const sharedCacheUsageColumn = {
-    name: NODES_COLUMNS_IDS.SharedCacheUsage,
-    header: 'Tablet Cache',
-    render: ({ row }) => (_jsx(ProgressViewer, { value: row.SharedCacheUsed, capacity: row.SharedCacheLimit, formatValues: formatStorageValuesToGb, colorizeProgress: true })),
-    align: DataTable.LEFT,
-    width: 140,
-    resizeMinWidth: 140,
-    sortable: false,
-};
-const memoryUsedInAllocColumn = {
-    name: NODES_COLUMNS_IDS.MemoryUsedInAlloc,
-    header: 'Query Runtime',
-    render: ({ row }) => (_jsx(ProgressViewer, { value: row.MemoryUsedInAlloc, capacity: row.MemoryLimit, formatValues: formatStorageValuesToGb, colorizeProgress: true })),
-    align: DataTable.LEFT,
-    width: 140,
-    resizeMinWidth: 140,
-    sortable: false,
-};
-const sessionsColumn = {
-    name: NODES_COLUMNS_IDS.TotalSessions,
-    header: 'Sessions',
-    render: ({ row }) => { var _a; return (_a = row.TotalSessions) !== null && _a !== void 0 ? _a : '—'; },
-    align: DataTable.RIGHT,
-    width: 100,
-    sortable: false,
-};
-export function getNodesColumns({ tabletsPath, getNodeRef }) {
-    return [
-        nodeIdColumn,
-        getHostColumn(getNodeRef),
-        dataCenterColumn,
-        rackColumn,
-        versionColumn,
-        uptimeColumn,
-        memoryColumn,
-        cpuColumn,
-        loadAverageColumn,
-        getTabletsColumn(tabletsPath),
-    ];
-}
-export function getTopNodesByLoadColumns(getNodeRef) {
-    return [
-        topNodesLoadAverageColumn,
-        nodeIdColumn,
-        getHostColumnWithUndefinedWidth(getNodeRef),
-        versionColumn,
-    ];
-}
-export function getTopNodesByCpuColumns(getNodeRef) {
-    return [cpuColumn, nodeIdColumn, getHostColumnWithUndefinedWidth(getNodeRef)];
-}
-export function getTopNodesByMemoryColumns({ tabletsPath, getNodeRef, }) {
-    return [
-        nodeIdColumn,
-        getHostColumn(getNodeRef),
-        uptimeColumn,
-        topNodesLoadAverageColumn,
-        topNodesMemoryColumn,
-        sharedCacheUsageColumn,
-        memoryUsedInAllocColumn,
-        sessionsColumn,
-        getTabletsColumn(tabletsPath),
-    ];
-}

package/dist/src/containers/Nodes/i18n/index.d.ts

@@ -1,2 +0,0 @@
-declare const _default: (key: "empty.default", params?: import("@gravity-ui/i18n").Params | undefined) => string;
-export default _default;

package/dist/src/containers/PDiskPage/PDiskPage.js

@@ -1,90 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import React from 'react';
-import { ArrowRotateLeft } from '@gravity-ui/icons';
-import { Icon } from '@gravity-ui/uikit';
-import { skipToken } from '@reduxjs/toolkit/query';
-import { Helmet } from 'react-helmet-async';
-import { StringParam, useQueryParams } from 'use-query-params';
-import { ButtonWithConfirmDialog } from '../../components/ButtonWithConfirmDialog/ButtonWithConfirmDialog';
-import { DiskPageTitle } from '../../components/DiskPageTitle/DiskPageTitle';
-import { InfoViewerSkeleton } from '../../components/InfoViewerSkeleton/InfoViewerSkeleton';
-import { PDiskInfo } from '../../components/PDiskInfo/PDiskInfo';
-import { PageMeta } from '../../components/PageMeta/PageMeta';
-import { setHeaderBreadcrumbs } from '../../store/reducers/header/header';
-import { selectNodesMap } from '../../store/reducers/nodesList';
-import { pDiskApi } from '../../store/reducers/pdisk/pdisk';
-import { valueIsDefined } from '../../utils';
-import { DEFAULT_POLLING_INTERVAL } from '../../utils/constants';
-import { getSeverityColor } from '../../utils/disks/helpers';
-import { useTypedDispatch, useTypedSelector } from '../../utils/hooks';
-import { PDiskGroups } from './PDiskGroups';
-import { pDiskPageKeyset } from './i18n';
-import { pdiskPageCn } from './shared';
-import './PDiskPage.scss';
-export function PDiskPage() {
-    var _a;
-    const dispatch = useTypedDispatch();
-    const nodesMap = useTypedSelector(selectNodesMap);
-    const { isUserAllowedToMakeChanges } = useTypedSelector((state) => state.authentication);
-    const [{ nodeId, pDiskId }] = useQueryParams({
-        nodeId: StringParam,
-        pDiskId: StringParam,
-    });
-    React.useEffect(() => {
-        dispatch(setHeaderBreadcrumbs('pDisk', { nodeId, pDiskId }));
-    }, [dispatch, nodeId, pDiskId]);
-    const params = valueIsDefined(nodeId) && valueIsDefined(pDiskId) ? { nodeId, pDiskId } : skipToken;
-    const pdiskDataQuery = pDiskApi.useGetPdiskInfoQuery(params, {
-        pollingInterval: DEFAULT_POLLING_INTERVAL,
-    });
-    const pDiskLoading = pdiskDataQuery.isFetching && pdiskDataQuery.currentData === undefined;
-    const pDiskData = pdiskDataQuery.currentData || {};
-    const { NodeHost, NodeId, NodeType, NodeDC, Severity } = pDiskData;
-    const pDiskStorageQuery = pDiskApi.useGetStorageInfoQuery(params, {
-        pollingInterval: DEFAULT_POLLING_INTERVAL,
-    });
-    const groupsLoading = pDiskStorageQuery.isFetching && pDiskStorageQuery.currentData === undefined;
-    const groupsData = (_a = pDiskStorageQuery.currentData) !== null && _a !== void 0 ? _a : [];
-    const handleRestart = async () => {
-        if (valueIsDefined(nodeId) && valueIsDefined(pDiskId)) {
-            return window.api.restartPDisk(nodeId, pDiskId).then((res) => {
-                if ((res === null || res === void 0 ? void 0 : res.result) === false) {
-                    const err = { statusText: res.error };
-                    throw err;
-                }
-            });
-        }
-        return undefined;
-    };
-    const handleAfterRestart = async () => {
-        return Promise.all([pdiskDataQuery.refetch(), pDiskStorageQuery.refetch()]);
-    };
-    const renderHelmet = () => {
-        const pDiskPagePart = pDiskId
-            ? `${pDiskPageKeyset('pdisk')} ${pDiskId}`
-            : pDiskPageKeyset('pdisk');
-        const nodePagePart = NodeHost ? NodeHost : pDiskPageKeyset('node');
-        return (_jsx(Helmet, { titleTemplate: `%s - ${pDiskPagePart} — ${nodePagePart} — YDB Monitoring`, defaultTitle: `${pDiskPagePart} — ${nodePagePart} — YDB Monitoring` }));
-    };
-    const renderPageMeta = () => {
-        const hostItem = NodeHost ? `${pDiskPageKeyset('fqdn')}: ${NodeHost}` : undefined;
-        const nodeIdItem = NodeId ? `${pDiskPageKeyset('node')}: ${NodeId}` : undefined;
-        return (_jsx(PageMeta, { className: pdiskPageCn('meta'), loading: pDiskLoading, items: [hostItem, nodeIdItem, NodeType, NodeDC] }));
-    };
-    const renderPageTitle = () => {
-        return (_jsx(DiskPageTitle, { entityName: pDiskPageKeyset('pdisk'), status: getSeverityColor(Severity), id: pDiskId, className: pdiskPageCn('title') }));
-    };
-    const renderControls = () => {
-        return (_jsx("div", { className: pdiskPageCn('controls'), children: _jsxs(ButtonWithConfirmDialog, { onConfirmAction: handleRestart, onConfirmActionSuccess: handleAfterRestart, buttonDisabled: !nodeId || !pDiskId || !isUserAllowedToMakeChanges, buttonView: "normal", dialogContent: pDiskPageKeyset('restart-pdisk-dialog'), withPopover: true, popoverContent: pDiskPageKeyset('restart-pdisk-not-allowed'), popoverDisabled: isUserAllowedToMakeChanges, children: [_jsx(Icon, { data: ArrowRotateLeft }), pDiskPageKeyset('restart-pdisk-button')] }) }));
-    };
-    const renderInfo = () => {
-        if (pDiskLoading) {
-            return _jsx(InfoViewerSkeleton, { className: pdiskPageCn('info'), rows: 10 });
-        }
-        return (_jsx(PDiskInfo, { pDisk: pDiskData, nodeId: nodeId, className: pdiskPageCn('info'), isPDiskPage: true }));
-    };
-    const renderGroupsTable = () => {
-        return _jsx(PDiskGroups, { data: groupsData, nodesMap: nodesMap, loading: groupsLoading });
-    };
-    return (_jsxs("div", { className: pdiskPageCn(null), children: [renderHelmet(), renderPageMeta(), renderPageTitle(), renderControls(), renderInfo(), renderGroupsTable()] }));
-}

package/dist/src/containers/PDiskPage/PDiskPage.scss

@@ -1,27 +0,0 @@
-@import '../../styles//mixins.scss';
-
-.ydb-pdisk-page {
-    position: relative;
-
-    display: flex;
-    overflow: auto;
-    flex-direction: column;
-    gap: 20px;
-
-    height: 100%;
-    padding-top: 20px;
-    padding-left: 20px;
-
-    &__meta,
-    &__title,
-    &__info,
-    &__controls,
-    &__groups-title {
-        position: sticky;
-        left: 0;
-    }
-
-    &__groups-title {
-        @include header-1-typography();
-    }
-}

package/dist/src/containers/PDiskPage/i18n/index.d.ts

@@ -1 +0,0 @@
-export declare const pDiskPageKeyset: (key: "node" | "groups" | "fqdn" | "pdisk" | "restart-pdisk-button" | "restart-pdisk-dialog" | "restart-pdisk-not-allowed", params?: import("@gravity-ui/i18n").Params | undefined) => string;

package/dist/src/containers/ReduxTooltip/ReduxTooltip.d.ts

@@ -1,23 +0,0 @@
-declare const _default: import("react-redux").ConnectedComponent<typeof ReduxTooltip, {
-    className?: string | null | undefined;
-    context?: React.Context<import("react-redux").ReactReduxContextValue<any, import("redux").UnknownAction> | null> | undefined;
-    store?: import("redux").Store<any, import("redux").UnknownAction, unknown> | undefined;
-} | {
-    className?: string | null | undefined;
-    store?: import("redux").Store<any, import("redux").UnknownAction, unknown> | undefined;
-}>;
-export default _default;
-declare function ReduxTooltip(props: any): import("react/jsx-runtime").JSX.Element;
-declare namespace ReduxTooltip {
-    export { propTypes };
-}
-import React from 'react';
-declare namespace propTypes {
-    let className: PropTypes.Requireable<string>;
-    let toolTipVisible: PropTypes.Requireable<boolean>;
-    let currentHoveredRef: PropTypes.Requireable<object>;
-    let data: PropTypes.Requireable<any>;
-    let template: PropTypes.Requireable<(...args: any[]) => any>;
-    let hideTooltip: PropTypes.Requireable<(...args: any[]) => any>;
-}
-import PropTypes from 'prop-types';

package/dist/src/containers/Storage/EmptyFilter/i18n/index.d.ts

@@ -1,2 +0,0 @@
-declare const _default: (key: "default_message" | "default_button_label", params?: import("@gravity-ui/i18n").Params | undefined) => string;
-export default _default;

package/dist/src/containers/Storage/Storage.js

@@ -1,118 +0,0 @@
-import { __rest } from "tslib";
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import React from 'react';
-import { ArrayParam, StringParam, useQueryParams, withDefault } from 'use-query-params';
-import { AccessDenied } from '../../components/Errors/403';
-import { ResponseError } from '../../components/Errors/ResponseError';
-import { TableWithControlsLayout } from '../../components/TableWithControlsLayout/TableWithControlsLayout';
-import { selectNodesMap } from '../../store/reducers/nodesList';
-import { STORAGE_TYPES, VISIBLE_ENTITIES } from '../../store/reducers/storage/constants';
-import { filterGroups, filterNodes, getUsageFilterOptions, } from '../../store/reducers/storage/selectors';
-import { storageApi } from '../../store/reducers/storage/storage';
-import { storageTypeSchema, visibleEntitiesSchema } from '../../store/reducers/storage/types';
-import { DEFAULT_POLLING_INTERVAL, DEFAULT_TABLE_SETTINGS } from '../../utils/constants';
-import { useAutoRefreshInterval, useNodesRequestParams, useStorageRequestParams, useTableSort, useTypedSelector, } from '../../utils/hooks';
-import { NodesUptimeFilterValues, nodesUptimeFilterValuesSchema } from '../../utils/nodes';
-import { StorageControls } from './StorageControls/StorageControls';
-import { StorageGroups } from './StorageGroups/StorageGroups';
-import { StorageNodes } from './StorageNodes/StorageNodes';
-import { b } from './shared';
-import { defaultSortNode, getDefaultSortGroup } from './utils';
-import './Storage.scss';
-const UsageFilterParam = withDefault({
-    encode: ArrayParam.encode,
-    decode: (input) => {
-        if (input === null || input === undefined) {
-            return input;
-        }
-        if (!Array.isArray(input)) {
-            return input ? [input] : [];
-        }
-        return input.filter(Boolean);
-    },
-}, []);
-export const Storage = ({ additionalNodesProps, tenant, nodeId }) => {
-    var _a;
-    const [autorefresh] = useAutoRefreshInterval();
-    const [queryParams, setQueryParams] = useQueryParams({
-        type: StringParam,
-        visible: StringParam,
-        search: StringParam,
-        uptimeFilter: StringParam,
-        usageFilter: UsageFilterParam,
-    });
-    const type = storageTypeSchema.parse(queryParams.type);
-    const visibleEntities = visibleEntitiesSchema.parse(queryParams.visible);
-    const filter = (_a = queryParams.search) !== null && _a !== void 0 ? _a : '';
-    const uptimeFilter = nodesUptimeFilterValuesSchema.parse(queryParams.uptimeFilter);
-    const usageFilter = queryParams.usageFilter;
-    const nodesMap = useTypedSelector(selectNodesMap);
-    const [nodeSort, setNodeSort] = React.useState({
-        sortOrder: undefined,
-        sortValue: undefined,
-    });
-    const nodesSortParams = nodeSort.sortValue ? nodeSort : defaultSortNode;
-    const [groupSort, setGroupSort] = React.useState({
-        sortOrder: undefined,
-        sortValue: undefined,
-    });
-    const groupsSortParams = groupSort.sortOrder ? groupSort : getDefaultSortGroup(visibleEntities);
-    // Do not display Nodes table for Node page (NodeId present)
-    const isNodePage = nodeId !== undefined;
-    const storageType = isNodePage ? STORAGE_TYPES.groups : type;
-    const nodesRequestParams = useNodesRequestParams(Object.assign({ filter, nodesUptimeFilter: uptimeFilter }, nodesSortParams));
-    const storageRequestParams = useStorageRequestParams(Object.assign({ filter }, groupsSortParams));
-    const autoRefreshInterval = tenant ? autorefresh : DEFAULT_POLLING_INTERVAL;
-    const nodesQuery = storageApi.useGetStorageNodesInfoQuery(Object.assign({ tenant, visibleEntities }, nodesRequestParams), {
-        skip: storageType !== STORAGE_TYPES.nodes,
-        pollingInterval: autoRefreshInterval,
-    });
-    const groupsQuery = storageApi.useGetStorageGroupsInfoQuery(Object.assign({ tenant, visibleEntities, nodeId }, storageRequestParams), {
-        skip: storageType !== STORAGE_TYPES.groups,
-        pollingInterval: autoRefreshInterval,
-    });
-    const { currentData, isFetching, error } = storageType === STORAGE_TYPES.nodes ? nodesQuery : groupsQuery;
-    const { currentData: { nodes = [] } = {} } = nodesQuery;
-    const { currentData: { groups = [] } = {} } = groupsQuery;
-    const _b = currentData !== null && currentData !== void 0 ? currentData : { found: 0, total: 0 }, { nodes: _, groups: __ } = _b, entitiesCount = __rest(_b, ["nodes", "groups"]);
-    const isLoading = currentData === undefined && isFetching;
-    const storageNodes = React.useMemo(() => filterNodes(nodes, filter, uptimeFilter), [filter, nodes, uptimeFilter]);
-    const storageGroups = React.useMemo(() => filterGroups(groups, filter, usageFilter), [filter, groups, usageFilter]);
-    const usageFilterOptions = React.useMemo(() => getUsageFilterOptions(groups), [groups]);
-    const [nodesSort, handleNodesSort] = useTableSort(nodesSortParams, (params) => setNodeSort(params));
-    const [groupsSort, handleGroupsSort] = useTableSort(groupsSortParams, (params) => setGroupSort(params));
-    const handleUsageFilterChange = (value) => {
-        setQueryParams({ usageFilter: value.length ? value : undefined }, 'replaceIn');
-    };
-    const handleTextFilterChange = (value) => {
-        setQueryParams({ search: value || undefined }, 'replaceIn');
-    };
-    const handleGroupVisibilityChange = (value) => {
-        setQueryParams({ visible: value }, 'replaceIn');
-    };
-    const handleStorageTypeChange = (value) => {
-        setQueryParams({ type: value }, 'replaceIn');
-    };
-    const handleUptimeFilterChange = (value) => {
-        setQueryParams({ uptimeFilter: value }, 'replaceIn');
-    };
-    const handleShowAllNodes = () => {
-        handleGroupVisibilityChange(VISIBLE_ENTITIES.all);
-        handleUptimeFilterChange(NodesUptimeFilterValues.All);
-    };
-    const renderDataTable = () => {
-        return (_jsxs(React.Fragment, { children: [storageType === STORAGE_TYPES.groups && (_jsx(StorageGroups, { visibleEntities: visibleEntities, data: storageGroups, tableSettings: DEFAULT_TABLE_SETTINGS, nodes: nodesMap, onShowAll: () => handleGroupVisibilityChange(VISIBLE_ENTITIES.all), sort: groupsSort, handleSort: handleGroupsSort }, "groups")), storageType === STORAGE_TYPES.nodes && (_jsx(StorageNodes, { visibleEntities: visibleEntities, nodesUptimeFilter: uptimeFilter, data: storageNodes, tableSettings: DEFAULT_TABLE_SETTINGS, onShowAll: handleShowAllNodes, additionalNodesProps: additionalNodesProps, sort: nodesSort, handleSort: handleNodesSort }, "nodes"))] }));
-    };
-    const renderControls = () => {
-        return (_jsx(StorageControls, { searchValue: filter, handleSearchValueChange: handleTextFilterChange, withTypeSelector: !isNodePage, storageType: storageType, handleStorageTypeChange: handleStorageTypeChange, visibleEntities: visibleEntities, handleVisibleEntitiesChange: handleGroupVisibilityChange, nodesUptimeFilter: uptimeFilter, handleNodesUptimeFilterChange: handleUptimeFilterChange, groupsUsageFilter: usageFilter, groupsUsageFilterOptions: usageFilterOptions, handleGroupsUsageFilterChange: handleUsageFilterChange, entitiesCountCurrent: storageType === STORAGE_TYPES.groups
-                ? storageGroups.length
-                : storageNodes.length, entitiesCountTotal: entitiesCount.total, entitiesLoading: isLoading }));
-    };
-    if (error) {
-        if (error.status === 403) {
-            return _jsx(AccessDenied, { position: "left" });
-        }
-        return _jsx(ResponseError, { error: error });
-    }
-    return (_jsxs(TableWithControlsLayout, { children: [_jsx(TableWithControlsLayout.Controls, { children: renderControls() }), _jsx(TableWithControlsLayout.Table, { loading: isLoading, className: b('table'), children: renderDataTable() })] }));
-};

package/dist/src/containers/Storage/StorageGroups/getGroups.js

@@ -1,16 +0,0 @@
-import { __rest } from "tslib";
-import { prepareStorageGroupsResponse } from '../../../store/reducers/storage/utils';
-import { EVersion } from '../../../types/api/storage';
-const getConcurrentId = (limit, offset) => {
-    return `getStorageGroups|offset${offset}|limit${limit}`;
-};
-export const getStorageGroups = async (_a) => {
-    var { limit, offset } = _a, params = __rest(_a, ["limit", "offset"]);
-    const response = await window.api.getStorageInfo(Object.assign({ version: EVersion.v2, limit, offset }, params), { concurrentId: getConcurrentId(limit, offset) });
-    const preparedResponse = prepareStorageGroupsResponse(response);
-    return {
-        data: preparedResponse.groups || [],
-        found: preparedResponse.found || 0,
-        total: preparedResponse.total || 0,
-    };
-};

package/dist/src/containers/Storage/StorageGroups/getStorageGroupsColumns.d.ts

@@ -1,62 +0,0 @@
-import React from 'react';
-import type { Column as DataTableColumn } from '@gravity-ui/react-data-table';
-import type { Column as VirtualTableColumn } from '../../../components/VirtualTable';
-import type { PreparedStorageGroup, VisibleEntities } from '../../../store/reducers/storage/types';
-import type { NodesMap } from '../../../types/store/nodesList';
-import './StorageGroups.scss';
-export declare const STORAGE_GROUPS_COLUMNS_WIDTH_LS_KEY = "storageGroupsColumnsWidth";
-type StorageGroupsColumn = VirtualTableColumn<PreparedStorageGroup> & DataTableColumn<PreparedStorageGroup>;
-export declare const GROUPS_COLUMNS_IDS: {
-    readonly PoolName: "PoolName";
-    readonly MediaType: "MediaType";
-    readonly Erasure: "Erasure";
-    readonly GroupId: "GroupId";
-    readonly Used: "Used";
-    readonly Limit: "Limit";
-    readonly Usage: "Usage";
-    readonly UsedSpaceFlag: "UsedSpaceFlag";
-    readonly Read: "Read";
-    readonly Write: "Write";
-    readonly VDisks: "VDisks";
-    readonly Degraded: "Degraded";
-};
-export declare const getStorageTopGroupsColumns: () => StorageGroupsColumn[];
-export declare const getPDiskStorageColumns: (nodes?: NodesMap) => StorageGroupsColumn[];
-export declare const getPreparedStorageGroupsColumns: (nodesMap: NodesMap | undefined, visibleEntities: VisibleEntities) => {
-    sortable: boolean;
-    name: string;
-    header?: React.ReactNode;
-    className?: string | undefined;
-    resizeable?: boolean | undefined;
-    render: ((props: {
-        row: PreparedStorageGroup;
-        index: number;
-    }) => React.ReactNode) & ((props: {
-        value?: unknown;
-        row: PreparedStorageGroup;
-        index: number;
-        footer?: boolean | undefined;
-        headerData?: boolean | undefined;
-    }) => React.ReactNode);
-    width: number;
-    resizeMaxWidth?: number | undefined;
-    resizeMinWidth?: number | undefined;
-    align: "center" | "left" | "right";
-    headerTitle?: string | undefined;
-    accessor?: string | ((row: PreparedStorageGroup) => any) | undefined;
-    title?: string | ((row: PreparedStorageGroup) => string) | undefined;
-    customStyle?: ((props: import("@gravity-ui/react-data-table").CustomStyleParams<PreparedStorageGroup>) => React.CSSProperties) | undefined;
-    onClick?: ((data: {
-        row: PreparedStorageGroup;
-        index: number;
-        footer?: boolean | undefined;
-        headerData?: boolean | undefined;
-    }, column: DataTableColumn<PreparedStorageGroup>, event: React.MouseEvent<HTMLTableCellElement, MouseEvent>) => void) | undefined;
-    defaultOrder?: import("@gravity-ui/react-data-table").OrderType | undefined;
-    sortAccessor?: string | ((row: PreparedStorageGroup) => any) | undefined;
-    sortAscending?: import("@gravity-ui/react-data-table").Comparator<PreparedStorageGroup> | undefined;
-    sub?: DataTableColumn<PreparedStorageGroup>[] | undefined;
-    group?: boolean | undefined;
-    autogroup?: boolean | undefined;
-}[];
-export {};