ydb-embedded-ui 4.32.0 → 5.0.0

package/dist/containers/Storage/StorageVisibleEntitiesFilter/StorageVisibleEntitiesFilter.d.ts

@@ -0,0 +1,12 @@
+import type { VisibleEntities } from '../../../store/reducers/storage/types';
+export declare const VisibleEntitiesTitles: {
+    all: string;
+    missing: string;
+    space: string;
+};
+interface StorageProblemFilterProps {
+    value: VisibleEntities;
+    onChange: (value: VisibleEntities) => void;
+}
+export declare const StorageVisibleEntitiesFilter: ({ value, onChange }: StorageProblemFilterProps) => JSX.Element;
+export {};

package/dist/containers/Storage/StorageVisibleEntitiesFilter/StorageVisibleEntitiesFilter.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { RadioButton } from '@gravity-ui/uikit';
+import { VISIBLE_ENTITIES } from '../../../store/reducers/storage/constants';
+export const VisibleEntitiesTitles = {
+    [VISIBLE_ENTITIES.all]: 'All',
+    [VISIBLE_ENTITIES.missing]: 'Degraded',
+    [VISIBLE_ENTITIES.space]: 'Out of Space',
+};
+const storageVisibleEntitiesFilterQa = 'storage-visible-entities-filter';
+export const StorageVisibleEntitiesFilter = ({ value, onChange }) => {
+    return (_jsxs(RadioButton, Object.assign({ value: value, onUpdate: onChange, qa: storageVisibleEntitiesFilterQa }, { children: [_jsx(RadioButton.Option, Object.assign({ value: VISIBLE_ENTITIES.missing }, { children: VisibleEntitiesTitles[VISIBLE_ENTITIES.missing] })), _jsx(RadioButton.Option, Object.assign({ value: VISIBLE_ENTITIES.space }, { children: VisibleEntitiesTitles[VISIBLE_ENTITIES.space] })), _jsx(RadioButton.Option, Object.assign({ value: VISIBLE_ENTITIES.all }, { children: VisibleEntitiesTitles[VISIBLE_ENTITIES.all] }))] })));
+};

package/dist/containers/Storage/StorageWrapper.d.ts

@@ -0,0 +1,9 @@
+import type { AdditionalNodesProps } from '../../types/additionalProps';
+interface StorageWrapperProps {
+    tenant?: string;
+    nodeId?: string;
+    parentContainer?: Element | null;
+    additionalNodesProps?: AdditionalNodesProps;
+}
+export declare const StorageWrapper: ({ parentContainer, ...props }: StorageWrapperProps) => JSX.Element;
+export {};

package/dist/containers/Storage/StorageWrapper.js

@@ -0,0 +1,24 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { USE_BACKEND_PARAMS_FOR_TABLES_KEY } from '../../utils/constants';
+import { useSetting } from '../../utils/hooks';
+import { VirtualStorage } from './VirtualStorage';
+import { Storage } from './Storage';
+export const StorageWrapper = (_a) => {
+    var { parentContainer } = _a, props = __rest(_a, ["parentContainer"]);
+    const [useVirtualTable] = useSetting(USE_BACKEND_PARAMS_FOR_TABLES_KEY);
+    if (useVirtualTable) {
+        return _jsx(VirtualStorage, Object.assign({ parentContainer: parentContainer }, props));
+    }
+    return _jsx(Storage, Object.assign({}, props));
+};

package/dist/containers/Storage/UsageFilter/UsageFilter.d.ts

@@ -0,0 +1,14 @@
+import './UsageFilter.scss';
+export interface UsageFilterItem {
+    threshold: number;
+    count: number;
+}
+interface UsageFilterProps {
+    className?: string;
+    value?: string[];
+    groups?: UsageFilterItem[];
+    onChange?: (value: string[]) => void;
+    debounce?: number;
+}
+export declare const UsageFilter: (props: UsageFilterProps) => JSX.Element;
+export {};

package/dist/containers/Storage/UsageFilter/UsageFilter.js

@@ -0,0 +1,38 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef, useState } from 'react';
+import cn from 'bem-cn-lite';
+import { Select } from '@gravity-ui/uikit';
+import EntityStatus from '../../../components/EntityStatus/EntityStatus';
+import { getUsageSeverityForEntityStatus } from '../utils';
+import i18n from './i18n';
+import './UsageFilter.scss';
+const b = cn('usage-filter');
+export const UsageFilter = (props) => {
+    const { className, value = [], groups = [], onChange, debounce = 200 } = props;
+    const [filterValue, setFilterValue] = useState(value);
+    const timer = useRef();
+    useEffect(() => {
+        // sync inner state with external value
+        setFilterValue((prevValue) => {
+            if (prevValue.join(',') !== value.join(',')) {
+                return value;
+            }
+            return prevValue;
+        });
+    }, [value]);
+    const options = useMemo(() => groups.map(({ threshold, count }) => ({
+        value: String(threshold),
+        text: `${threshold}%`,
+        data: { count },
+    })), [groups]);
+    const handleUpdate = (newValue) => {
+        setFilterValue(newValue);
+        window.clearTimeout(timer.current);
+        timer.current = window.setTimeout(() => {
+            onChange === null || onChange === void 0 ? void 0 : onChange(newValue);
+        }, debounce);
+    };
+    const maxWidth = Math.max(...groups.map(({ count }) => count));
+    const renderOption = ({ value: optionValue, data, text }) => (_jsxs("div", Object.assign({ className: b('option') }, { children: [_jsx(EntityStatus, { className: b('option-title'), status: getUsageSeverityForEntityStatus(Number(optionValue)), name: text, size: "xs" }), _jsxs("div", Object.assign({ className: b('option-meta') }, { children: [i18n('groups_count', { count: data.count }), _jsx("div", { className: b('option-bar'), style: { width: `${(data.count / maxWidth) * 100}%` } })] }))] })));
+    return (_jsx(Select, { className: b(null, className), label: i18n('label'), value: filterValue, placeholder: i18n('default_value'), options: options, multiple: true, onUpdate: handleUpdate, renderOption: renderOption, getOptionHeight: () => 50, popupWidth: 280, disabled: groups.length === 0 }));
+};

package/dist/containers/Storage/UsageFilter/i18n/en.json

@@ -1,5 +1,5 @@
 {
-  "label": "Usage:",
-  "default_value": "Any",
-  "groups_count": ["{{count}} group", "{{count}} groups", "{{count}} groups", "No groups"]
+    "label": "Usage:",
+    "default_value": "Any",
+    "groups_count": ["{{count}} group", "{{count}} groups", "{{count}} groups", "No groups"]
 }

package/dist/containers/Storage/UsageFilter/i18n/index.d.ts

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

package/dist/containers/Storage/UsageFilter/i18n/index.js

@@ -0,0 +1,7 @@
+import { i18n, Lang } from '../../../../utils/i18n';
+import en from './en.json';
+import ru from './ru.json';
+const COMPONENT = 'ydb-usage-filter';
+i18n.registerKeyset(Lang.En, COMPONENT, en);
+i18n.registerKeyset(Lang.Ru, COMPONENT, ru);
+export default i18n.keyset(COMPONENT);

package/dist/containers/Storage/UsageFilter/i18n/ru.json

@@ -1,5 +1,5 @@
 {
-  "label": "Использование:",
-  "default_value": "Любое",
-  "groups_count": ["{{count}} группа", "{{count}} группы", "{{count}} групп", "Нет групп"]
+    "label": "Использование:",
+    "default_value": "Любое",
+    "groups_count": ["{{count}} группа", "{{count}} группы", "{{count}} групп", "Нет групп"]
 }

package/dist/containers/Storage/UsageFilter/index.js

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

package/dist/containers/Storage/VDisk/VDisk.d.ts

@@ -0,0 +1,11 @@
+import type { NodesMap } from '../../../types/store/nodesList';
+import { TVDiskStateInfo } from '../../../types/api/vdisk';
+import type { UnavailableDonor } from '../utils/types';
+import './VDisk.scss';
+interface VDiskProps {
+    data?: TVDiskStateInfo | UnavailableDonor;
+    nodes?: NodesMap;
+    compact?: boolean;
+}
+export declare const VDisk: ({ data, nodes, compact }: VDiskProps) => JSX.Element;
+export {};

package/dist/containers/Storage/VDisk/VDisk.js

@@ -0,0 +1,88 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React, { useEffect, useState, useRef, useMemo } from 'react';
+import cn from 'bem-cn-lite';
+import { InternalLink } from '../../../components/InternalLink';
+import routes, { createHref } from '../../../routes';
+import { stringifyVdiskId } from '../../../utils/dataFormatters/dataFormatters';
+import { isFullVDiskData } from '../../../utils/storage';
+import { STRUCTURE } from '../../Node/NodePages';
+import { DiskStateProgressBar, EDiskStateSeverity } from '../DiskStateProgressBar';
+import { VDiskPopup } from '../VDiskPopup';
+import { NOT_AVAILABLE_SEVERITY } from '../utils';
+import './VDisk.scss';
+const b = cn('vdisk-storage');
+const stateSeverity = {
+    Initial: EDiskStateSeverity.Yellow,
+    LocalRecoveryError: EDiskStateSeverity.Red,
+    SyncGuidRecoveryError: EDiskStateSeverity.Red,
+    SyncGuidRecovery: EDiskStateSeverity.Yellow,
+    PDiskError: EDiskStateSeverity.Red,
+    OK: EDiskStateSeverity.Green,
+};
+const getStateSeverity = (vDiskState) => {
+    var _a;
+    if (!vDiskState) {
+        return NOT_AVAILABLE_SEVERITY;
+    }
+    return (_a = stateSeverity[vDiskState]) !== null && _a !== void 0 ? _a : NOT_AVAILABLE_SEVERITY;
+};
+const getColorSeverity = (color) => {
+    var _a;
+    if (!color) {
+        return EDiskStateSeverity.Grey;
+    }
+    return (_a = EDiskStateSeverity[color]) !== null && _a !== void 0 ? _a : EDiskStateSeverity.Grey;
+};
+export const VDisk = ({ data = {}, nodes, compact }) => {
+    var _a, _b;
+    const isFullData = isFullVDiskData(data);
+    const [severity, setSeverity] = useState(getStateSeverity(isFullData ? data.VDiskState : undefined));
+    const [isPopupVisible, setIsPopupVisible] = useState(false);
+    const anchor = useRef(null);
+    // determine disk status severity
+    useEffect(() => {
+        if (!isFullData) {
+            setSeverity(NOT_AVAILABLE_SEVERITY);
+            return;
+        }
+        const { DiskSpace, VDiskState, FrontQueues, Replicated, DonorMode } = data;
+        // if the disk is not available, this determines its status severity regardless of other features
+        if (!VDiskState) {
+            setSeverity(NOT_AVAILABLE_SEVERITY);
+            return;
+        }
+        const DiskSpaceSeverity = getColorSeverity(DiskSpace);
+        const VDiskSpaceSeverity = getStateSeverity(VDiskState);
+        const FrontQueuesSeverity = Math.min(EDiskStateSeverity.Orange, getColorSeverity(FrontQueues));
+        let newSeverity = Math.max(DiskSpaceSeverity, VDiskSpaceSeverity, FrontQueuesSeverity);
+        // donors are always in the not replicated state since they are leftovers
+        // painting them blue is useless
+        if (!Replicated && !DonorMode && newSeverity === EDiskStateSeverity.Green) {
+            newSeverity = EDiskStateSeverity.Blue;
+        }
+        setSeverity(newSeverity);
+    }, [data, isFullData]);
+    const showPopup = () => {
+        setIsPopupVisible(true);
+    };
+    const hidePopup = () => {
+        setIsPopupVisible(false);
+    };
+    const vdiskAllocatedPercent = useMemo(() => {
+        if (!isFullData) {
+            return undefined;
+        }
+        const { AvailableSize, AllocatedSize, PDisk } = data;
+        const available = AvailableSize ? AvailableSize : PDisk === null || PDisk === void 0 ? void 0 : PDisk.AvailableSize;
+        if (!available) {
+            return undefined;
+        }
+        return isNaN(Number(AllocatedSize))
+            ? undefined
+            : (Number(AllocatedSize) * 100) / (Number(available) + Number(AllocatedSize));
+    }, [data, isFullData]);
+    return (_jsxs(React.Fragment, { children: [_jsx(VDiskPopup, { data: data, nodes: nodes, anchorRef: anchor, open: isPopupVisible }), _jsx("div", Object.assign({ className: b(), ref: anchor, onMouseEnter: showPopup, onMouseLeave: hidePopup }, { children: data.NodeId && isFullData ? (_jsx(InternalLink, Object.assign({ to: createHref(routes.node, { id: data.NodeId, activeTab: STRUCTURE }, {
+                        pdiskId: (_a = data.PDiskId) !== null && _a !== void 0 ? _a : (_b = data.PDisk) === null || _b === void 0 ? void 0 : _b.PDiskId,
+                        vdiskId: stringifyVdiskId(data.VDiskId),
+                    }), className: b('content') }, { children: _jsx(DiskStateProgressBar, { diskAllocatedPercent: vdiskAllocatedPercent, severity: severity, compact: compact }) }))) : (_jsx(DiskStateProgressBar, { diskAllocatedPercent: vdiskAllocatedPercent, severity: severity, compact: compact })) }))] }));
+};

package/dist/containers/Storage/VDisk/index.js

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

package/dist/containers/Storage/VDiskPopup/VDiskPopup.d.ts

@@ -0,0 +1,11 @@
+import { PopupProps } from '@gravity-ui/uikit';
+import type { NodesMap } from '../../../types/store/nodesList';
+import type { TVDiskStateInfo } from '../../../types/api/vdisk';
+import type { UnavailableDonor } from '../utils/types';
+import './VDiskPopup.scss';
+interface VDiskPopupProps extends PopupProps {
+    data: TVDiskStateInfo | UnavailableDonor;
+    nodes?: NodesMap;
+}
+export declare const VDiskPopup: ({ data, nodes, ...props }: VDiskPopupProps) => JSX.Element;
+export {};

package/dist/containers/Storage/VDiskPopup/VDiskPopup.js

@@ -0,0 +1,105 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import cn from 'bem-cn-lite';
+import { Label, Popup } from '@gravity-ui/uikit';
+import { InfoViewer } from '../../../components/InfoViewer';
+import { EFlag } from '../../../types/api/enums';
+import { stringifyVdiskId } from '../../../utils/dataFormatters/dataFormatters';
+import { bytesToGB, bytesToSpeed } from '../../../utils/utils';
+import { isFullVDiskData } from '../../../utils/storage';
+import { preparePDiskData } from '../PDiskPopup';
+import './VDiskPopup.scss';
+const b = cn('vdisk-storage-popup');
+const prepareUnavailableVDiskData = (data) => {
+    const { NodeId, PDiskId, VSlotId, StoragePoolName } = data;
+    const vdiskData = [{ label: 'State', value: 'not available' }];
+    if (StoragePoolName) {
+        vdiskData.push({ label: 'StoragePool', value: StoragePoolName });
+    }
+    vdiskData.push({ label: 'NodeId', value: NodeId !== null && NodeId !== void 0 ? NodeId : '–' }, { label: 'PDiskId', value: PDiskId !== null && PDiskId !== void 0 ? PDiskId : '–' }, { label: 'VSlotId', value: VSlotId !== null && VSlotId !== void 0 ? VSlotId : '–' });
+    return vdiskData;
+};
+const prepareVDiskData = (data) => {
+    var _a, _b, _c, _d, _e, _f;
+    const { VDiskId, VDiskState, SatisfactionRank, DiskSpace, FrontQueues, Replicated, UnsyncedVDisks, AllocatedSize, ReadThroughput, WriteThroughput, StoragePoolName, } = data;
+    const vdiskData = [
+        { label: 'VDisk', value: stringifyVdiskId(VDiskId) },
+        { label: 'State', value: VDiskState !== null && VDiskState !== void 0 ? VDiskState : 'not available' },
+    ];
+    if (StoragePoolName) {
+        vdiskData.push({ label: 'StoragePool', value: StoragePoolName });
+    }
+    if (SatisfactionRank && ((_a = SatisfactionRank.FreshRank) === null || _a === void 0 ? void 0 : _a.Flag) !== EFlag.Green) {
+        vdiskData.push({
+            label: 'Fresh',
+            value: (_b = SatisfactionRank.FreshRank) === null || _b === void 0 ? void 0 : _b.Flag,
+        });
+    }
+    if (SatisfactionRank && ((_c = SatisfactionRank.LevelRank) === null || _c === void 0 ? void 0 : _c.Flag) !== EFlag.Green) {
+        vdiskData.push({
+            label: 'Level',
+            value: (_d = SatisfactionRank.LevelRank) === null || _d === void 0 ? void 0 : _d.Flag,
+        });
+    }
+    if (SatisfactionRank && ((_e = SatisfactionRank.FreshRank) === null || _e === void 0 ? void 0 : _e.RankPercent)) {
+        vdiskData.push({
+            label: 'Fresh',
+            value: SatisfactionRank.FreshRank.RankPercent,
+        });
+    }
+    if (SatisfactionRank && ((_f = SatisfactionRank.LevelRank) === null || _f === void 0 ? void 0 : _f.RankPercent)) {
+        vdiskData.push({
+            label: 'Level',
+            value: SatisfactionRank.LevelRank.RankPercent,
+        });
+    }
+    if (DiskSpace && DiskSpace !== EFlag.Green) {
+        vdiskData.push({ label: 'Space', value: DiskSpace });
+    }
+    if (FrontQueues && FrontQueues !== EFlag.Green) {
+        vdiskData.push({ label: 'FrontQueues', value: FrontQueues });
+    }
+    if (!Replicated) {
+        vdiskData.push({ label: 'Replicated', value: 'NO' });
+    }
+    if (UnsyncedVDisks) {
+        vdiskData.push({ label: 'UnsyncVDisks', value: UnsyncedVDisks });
+    }
+    if (Number(AllocatedSize)) {
+        vdiskData.push({
+            label: 'Allocated',
+            value: bytesToGB(AllocatedSize),
+        });
+    }
+    if (Number(ReadThroughput)) {
+        vdiskData.push({ label: 'Read', value: bytesToSpeed(ReadThroughput) });
+    }
+    if (Number(WriteThroughput)) {
+        vdiskData.push({
+            label: 'Write',
+            value: bytesToSpeed(WriteThroughput),
+        });
+    }
+    return vdiskData;
+};
+export const VDiskPopup = (_a) => {
+    var { data, nodes } = _a, props = __rest(_a, ["data", "nodes"]);
+    const isFullData = isFullVDiskData(data);
+    const vdiskInfo = useMemo(() => (isFullData ? prepareVDiskData(data) : prepareUnavailableVDiskData(data)), [data, isFullData]);
+    const pdiskInfo = useMemo(() => isFullData && data.PDisk && preparePDiskData(data.PDisk, nodes), [data, nodes, isFullData]);
+    return (_jsxs(Popup, Object.assign({ contentClassName: b(), placement: ['top', 'bottom'], 
+        // bigger offset for easier switching to neighbour nodes
+        // matches the default offset for popup with arrow out of a sense of beauty
+        offset: [0, 12] }, props, { children: [data.DonorMode && _jsx(Label, Object.assign({ className: b('donor-label') }, { children: "Donor" })), _jsx(InfoViewer, { title: "VDisk", info: vdiskInfo, size: "s" }), pdiskInfo && _jsx(InfoViewer, { title: "PDisk", info: pdiskInfo, size: "s" })] })));
+};

package/dist/containers/Storage/VDiskPopup/index.js

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

package/dist/containers/Storage/VirtualStorage.d.ts

@@ -0,0 +1,9 @@
+import type { AdditionalNodesProps } from '../../types/additionalProps';
+interface VirtualStorageProps {
+    tenant?: string;
+    nodeId?: string;
+    parentContainer?: Element | null;
+    additionalNodesProps?: AdditionalNodesProps;
+}
+export declare const VirtualStorage: ({ tenant, nodeId, parentContainer, additionalNodesProps, }: VirtualStorageProps) => JSX.Element;
+export {};

package/dist/containers/Storage/VirtualStorage.js

@@ -0,0 +1,43 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { useDispatch } from 'react-redux';
+import { STORAGE_TYPES, VISIBLE_ENTITIES } from '../../store/reducers/storage/constants';
+import { NodesUptimeFilterValues } from '../../utils/nodes';
+import { AccessDenied } from '../../components/Errors/403/AccessDenied';
+import { ResponseError } from '../../components/Errors/ResponseError/ResponseError';
+import { getNodesList, selectNodesMap } from '../../store/reducers/nodesList';
+import { useTypedSelector } from '../../utils/hooks';
+import { StorageControls } from './StorageControls/StorageControls';
+import { VirtualStorageGroups } from './StorageGroups/VirtualStorageGroups';
+import { VirtualStorageNodes } from './StorageNodes/VirtualStorageNodes';
+export const VirtualStorage = ({ tenant, nodeId, parentContainer, additionalNodesProps, }) => {
+    const dispatch = useDispatch();
+    const [searchValue, setSearchValue] = useState('');
+    const [storageType, setStorageType] = useState(STORAGE_TYPES.groups);
+    const [visibleEntities, setVisibleEntities] = useState(VISIBLE_ENTITIES.all);
+    const [nodesUptimeFilter, setNodesUptimeFilter] = useState(NodesUptimeFilterValues.All);
+    const nodesMap = useTypedSelector(selectNodesMap);
+    useEffect(() => {
+        dispatch(getNodesList());
+    }, [dispatch]);
+    const handleShowAllGroups = () => {
+        setVisibleEntities(VISIBLE_ENTITIES.all);
+    };
+    const handleShowAllNodes = () => {
+        setVisibleEntities(VISIBLE_ENTITIES.all);
+        setNodesUptimeFilter(NodesUptimeFilterValues.All);
+    };
+    const renderControls = ({ totalEntities, foundEntities, inited }) => {
+        return (_jsx(StorageControls, { searchValue: searchValue, handleSearchValueChange: setSearchValue, withTypeSelector: !nodeId, storageType: storageType, handleStorageTypeChange: setStorageType, visibleEntities: visibleEntities, handleVisibleEntitiesChange: setVisibleEntities, nodesUptimeFilter: nodesUptimeFilter, handleNodesUptimeFilterChange: setNodesUptimeFilter, withGroupsUsageFilter: false, entitiesCountCurrent: foundEntities, entitiesCountTotal: totalEntities, entitiesLoading: !inited }));
+    };
+    const renderErrorMessage = (error) => {
+        if (error.status === 403) {
+            return _jsx(AccessDenied, { position: "left" });
+        }
+        return _jsx(ResponseError, { error: error });
+    };
+    if (storageType === STORAGE_TYPES.nodes) {
+        return (_jsx(VirtualStorageNodes, { searchValue: searchValue, visibleEntities: visibleEntities, nodesUptimeFilter: nodesUptimeFilter, tenant: tenant, additionalNodesProps: additionalNodesProps, onShowAll: handleShowAllNodes, parentContainer: parentContainer, renderControls: renderControls, renderErrorMessage: renderErrorMessage }));
+    }
+    return (_jsx(VirtualStorageGroups, { searchValue: searchValue, visibleEntities: visibleEntities, tenant: tenant, nodeId: nodeId, nodesMap: nodesMap, onShowAll: handleShowAllGroups, parentContainer: parentContainer, renderControls: renderControls, renderErrorMessage: renderErrorMessage }));
+};

package/dist/containers/Storage/i18n/en.json

@@ -1,7 +1,6 @@
 {
-  "groups": "Groups",
-  "nodes": "Nodes",
-
-  "controls_groups-search-placeholder": "Group ID, Pool name",
-  "controls_nodes-search-placeholder": "Node ID, FQDN"
+    "groups": "Groups",
+    "nodes": "Nodes",
+    "controls_groups-search-placeholder": "Group ID, Pool name",
+    "controls_nodes-search-placeholder": "Node ID, FQDN"
 }

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

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

package/dist/containers/Storage/i18n/index.js

@@ -0,0 +1,7 @@
+import { i18n, Lang } from '../../../utils/i18n';
+import en from './en.json';
+import ru from './ru.json';
+const COMPONENT = 'ydb-storage';
+i18n.registerKeyset(Lang.En, COMPONENT, en);
+i18n.registerKeyset(Lang.Ru, COMPONENT, ru);
+export default i18n.keyset(COMPONENT);

package/dist/containers/Storage/i18n/ru.json

@@ -1,7 +1,6 @@
 {
-  "groups": "Группы",
-  "nodes": "Ноды",
-
-  "controls_groups-search-placeholder": "ID группы, имя пула",
-  "controls_nodes-search-placeholder": "ID узла, FQDN"
+    "groups": "Группы",
+    "nodes": "Ноды",
+    "controls_groups-search-placeholder": "ID группы, имя пула",
+    "controls_nodes-search-placeholder": "ID узла, FQDN"
 }

package/dist/containers/Storage/shared.d.ts

@@ -0,0 +1,10 @@
+export declare const b: {
+    (elementName: string, modifiers: import("bem-cn-lite").Modifications | null, mixin?: string | string[] | undefined): string;
+    (elementName: string, mixin?: string | string[] | undefined): string;
+    (elementName: string, modifiers: import("bem-cn-lite").Modifications): string;
+    (mods: import("bem-cn-lite").Modifications | null, mixin?: string | string[] | undefined): string;
+    (elementName: string): string;
+    (mods: import("bem-cn-lite").Modifications | null): string;
+    (): string;
+    builder(): import("bem-cn").Block;
+};

package/dist/containers/Storage/shared.js

@@ -0,0 +1,2 @@
+import cn from 'bem-cn-lite';
+export const b = cn('global-storage');

package/dist/containers/Storage/utils/constants.d.ts

@@ -0,0 +1,2 @@
+import { EDiskStateSeverity } from '../DiskStateProgressBar';
+export declare const NOT_AVAILABLE_SEVERITY = EDiskStateSeverity.Grey;

package/dist/containers/Storage/utils/constants.js

@@ -0,0 +1,2 @@
+import { EDiskStateSeverity } from '../DiskStateProgressBar';
+export const NOT_AVAILABLE_SEVERITY = EDiskStateSeverity.Grey;

package/dist/containers/Storage/utils/index.d.ts

@@ -0,0 +1,7 @@
+import type { PreparedStorageGroup } from '../../../store/reducers/storage/types';
+import { EFlag } from '../../../types/api/enums';
+export * from './constants';
+export declare const getDegradedSeverity: (group: PreparedStorageGroup) => "success" | "warning" | "danger" | undefined;
+export declare const getUsageSeverityForStorageGroup: (value: number) => "success" | "warning" | "danger" | undefined;
+export declare const getUsageSeverityForEntityStatus: (value: number) => "Green" | "Yellow" | "Red" | undefined;
+export declare const getUsageSeverityForPDisk: (value: number) => EFlag.Green | EFlag.Yellow | EFlag.Red | undefined;

package/dist/containers/Storage/utils/index.js

@@ -0,0 +1,30 @@
+import { EFlag } from '../../../types/api/enums';
+import { generateEvaluator } from '../../../utils/generateEvaluator';
+export * from './constants';
+const defaultDegradationEvaluator = generateEvaluator(1, 2, ['success', 'warning', 'danger']);
+const degradationEvaluators = {
+    'block-4-2': generateEvaluator(1, 2, ['success', 'warning', 'danger']),
+    'mirror-3-dc': generateEvaluator(1, 3, ['success', 'warning', 'danger']),
+};
+const canEvaluateErasureSpecies = (value) => value !== undefined && value in degradationEvaluators;
+export const getDegradedSeverity = (group) => {
+    const evaluate = canEvaluateErasureSpecies(group.ErasureSpecies)
+        ? degradationEvaluators[group.ErasureSpecies]
+        : defaultDegradationEvaluator;
+    return evaluate(group.Degraded);
+};
+export const getUsageSeverityForStorageGroup = generateEvaluator(80, 85, [
+    'success',
+    'warning',
+    'danger',
+]);
+export const getUsageSeverityForEntityStatus = generateEvaluator(80, 85, [
+    'Green',
+    'Yellow',
+    'Red',
+]);
+export const getUsageSeverityForPDisk = generateEvaluator(85, 95, [
+    EFlag.Green,
+    EFlag.Yellow,
+    EFlag.Red,
+]);

package/dist/containers/Storage/utils/types.d.ts

@@ -0,0 +1,5 @@
+import { TVSlotId } from '../../../types/api/vdisk';
+export interface UnavailableDonor extends TVSlotId {
+    DonorMode?: boolean;
+    StoragePoolName?: string;
+}

package/dist/containers/Storage/utils/types.js

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

package/dist/containers/Tablet/Tablet.d.ts

@@ -0,0 +1,12 @@
+import './Tablet.scss';
+export declare const b: {
+    (elementName: string, modifiers: import("bem-cn-lite").Modifications | null, mixin?: string | string[] | undefined): string;
+    (elementName: string, mixin?: string | string[] | undefined): string;
+    (elementName: string, modifiers: import("bem-cn-lite").Modifications): string;
+    (mods: import("bem-cn-lite").Modifications | null, mixin?: string | string[] | undefined): string;
+    (elementName: string): string;
+    (mods: import("bem-cn-lite").Modifications | null): string;
+    (): string;
+    builder(): import("bem-cn").Block;
+};
+export declare const Tablet: () => JSX.Element;