ydb-embedded-ui 5.3.0 → 5.5.0

package/dist/store/reducers/storage/utils.js

@@ -21,7 +21,7 @@ const prepareVDisk = (vDisk, poolName) => {
     // VDisk doesn't have its own StoragePoolName when located inside StoragePool data
     return Object.assign(Object.assign({}, preparedVDisk), { StoragePoolName: poolName, Donors: (_a = preparedVDisk === null || preparedVDisk === void 0 ? void 0 : preparedVDisk.Donors) === null || _a === void 0 ? void 0 : _a.map((donor) => (Object.assign(Object.assign({}, donor), { StoragePoolName: poolName }))) });
 };
-export const prepareStorageGroupData = (group, poolName) => {
+export const prepareStorageGroupData = (group, pool) => {
     var _a;
     let missing = 0;
     let usedSpaceFlag = 0;
@@ -29,7 +29,8 @@ export const prepareStorageGroupData = (group, poolName) => {
     let limitSizeBytes = 0;
     let readSpeedBytesPerSec = 0;
     let writeSpeedBytesPerSec = 0;
-    let mediaType = '';
+    let mediaType;
+    const { Name: poolName, MediaType: poolMediaType } = pool;
     if (group.VDisks) {
         for (const vDisk of group.VDisks) {
             const { Replicated, VDiskState, AvailableSize, AllocatedSize, PDisk, DiskSpace, ReadThroughput, WriteThroughput, } = vDisk;
@@ -46,16 +47,15 @@ export const prepareStorageGroupData = (group, poolName) => {
             limitSizeBytes += available + allocated;
             readSpeedBytesPerSec += Number(ReadThroughput) || 0;
             writeSpeedBytesPerSec += Number(WriteThroughput) || 0;
-            mediaType =
-                PDiskType && (PDiskType === mediaType || mediaType === '') ? PDiskType : 'Mixed';
+            mediaType = PDiskType && (PDiskType === mediaType || !mediaType) ? PDiskType : 'Mixed';
         }
     }
     const vDisks = (_a = group.VDisks) === null || _a === void 0 ? void 0 : _a.map((vdisk) => prepareVDisk(vdisk, poolName));
     const usage = getUsage({ Used: usedSpaceBytes, Limit: limitSizeBytes }, 5);
-    return Object.assign(Object.assign({}, group), { VDisks: vDisks, Usage: usage, Read: readSpeedBytesPerSec, Write: writeSpeedBytesPerSec, PoolName: poolName, Used: usedSpaceBytes, Limit: limitSizeBytes, Degraded: missing, UsedSpaceFlag: usedSpaceFlag, Kind: mediaType || undefined });
+    return Object.assign(Object.assign({}, group), { VDisks: vDisks, Usage: usage, Read: readSpeedBytesPerSec, Write: writeSpeedBytesPerSec, PoolName: poolName, Used: usedSpaceBytes, Limit: limitSizeBytes, Degraded: missing, UsedSpaceFlag: usedSpaceFlag, MediaType: poolMediaType || mediaType || undefined });
 };
 export const prepareStorageGroupDataV2 = (group) => {
-    const { VDisks = [], PoolName, Usage = 0, Read = 0, Write = 0, Used = 0, Limit = 0, Degraded = 0, Kind, } = group;
+    const { VDisks = [], PoolName, Usage = 0, Read = 0, Write = 0, Used = 0, Limit = 0, Degraded = 0, Kind, MediaType, } = group;
     const UsedSpaceFlag = VDisks.reduce((acc, { DiskSpace }) => {
         if (DiskSpace && DiskSpace !== EFlag.Grey) {
             return acc + FLAGS_POINTS[DiskSpace];
@@ -65,8 +65,7 @@ export const prepareStorageGroupDataV2 = (group) => {
     const vDisks = VDisks.map((vdisk) => prepareVDisk(vdisk, PoolName));
     const usage = Math.floor(Number(Usage) * 100);
     return Object.assign(Object.assign({}, group), { UsedSpaceFlag,
-        PoolName,
-        Kind, VDisks: vDisks, Usage: usage, Read: Number(Read), Write: Number(Write), Used: Number(Used), Limit: Number(Limit), Degraded: Number(Degraded) });
+        PoolName, MediaType: MediaType || Kind, VDisks: vDisks, Usage: usage, Read: Number(Read), Write: Number(Write), Used: Number(Used), Limit: Number(Limit), Degraded: Number(Degraded) });
 };
 export const prepareStorageGroups = (StorageGroups, StoragePools) => {
     let preparedGroups = [];
@@ -77,7 +76,7 @@ export const prepareStorageGroups = (StorageGroups, StoragePools) => {
         StoragePools === null || StoragePools === void 0 ? void 0 : StoragePools.forEach((pool) => {
             var _a;
             (_a = pool.Groups) === null || _a === void 0 ? void 0 : _a.forEach((group) => {
-                preparedGroups.push(prepareStorageGroupData(group, pool.Name));
+                preparedGroups.push(prepareStorageGroupData(group, pool));
             });
         });
     }

package/dist/store/reducers/tablet.d.ts

@@ -93,6 +93,7 @@ export declare const getTablet: (id: string) => (dispatch: import("redux").Dispa
     saveQuery: string | null;
     fullscreen: boolean;
     clusters: import("./clusters/types").ClustersState;
+    vDisk: import("./vdisk/types").VDiskState;
 }) => Promise<ITabletHandledResponse | undefined>;
 export declare const getTabletDescribe: (tenantId?: TDomainKey) => (dispatch: import("redux").Dispatch<import("redux").UnknownAction>, getState: () => {
     singleClusterMode: boolean;
@@ -175,6 +176,7 @@ export declare const getTabletDescribe: (tenantId?: TDomainKey) => (dispatch: im
     saveQuery: string | null;
     fullscreen: boolean;
     clusters: import("./clusters/types").ClustersState;
+    vDisk: import("./vdisk/types").VDiskState;
 }) => Promise<ITabletDescribeHandledResponse | undefined>;
 export declare const clearTabletData: () => {
     readonly type: "tablet/CLEAR_TABLET_DATA";

package/dist/store/reducers/tablets.d.ts

@@ -99,5 +99,6 @@ export declare function getTabletsInfo(data: ITabletsApiRequestParams): (dispatc
     saveQuery: string | null;
     fullscreen: boolean;
     clusters: import("./clusters/types").ClustersState;
+    vDisk: import("./vdisk/types").VDiskState;
 }) => Promise<unknown>;
 export default tablets;

package/dist/store/reducers/tabletsFilters.d.ts

@@ -79,6 +79,7 @@ export function getTabletsInfo(data: any): (dispatch: import("redux").Dispatch<i
     saveQuery: string | null;
     fullscreen: boolean;
     clusters: import("./clusters/types").ClustersState;
+    vDisk: import("./vdisk/types").VDiskState;
 }) => Promise<any>;
 export function clearWasLoadingFlag(): {
     type: string;

package/dist/store/reducers/tenant/tenant.d.ts

@@ -90,6 +90,7 @@ export declare const getTenantInfo: ({ path }: {
     saveQuery: string | null;
     fullscreen: boolean;
     clusters: import("../clusters/types").ClustersState;
+    vDisk: import("../vdisk/types").VDiskState;
 }) => Promise<TTenant | undefined>;
 export declare const clearTenant: () => {
     readonly type: "tenant/CLEAR_TENANT";

package/dist/store/reducers/tenantOverview/executeTopTables/executeTopTables.d.ts

@@ -87,6 +87,7 @@ export declare const fetchTopTables: (database: string) => (dispatch: import("re
     saveQuery: string | null;
     fullscreen: boolean;
     clusters: import("../../clusters/types").ClustersState;
+    vDisk: import("../../vdisk/types").VDiskState;
 }) => Promise<import("../../../../types/store/query").IQueryResult | undefined>;
 export declare function setDataWasNotLoaded(): {
     readonly type: "top-tables/SET_DATA_WAS_NOT_LOADED";

package/dist/store/reducers/tenantOverview/topNodesByCpu/topNodesByCpu.d.ts

@@ -88,6 +88,7 @@ export declare function getTopNodesByCpu({ type, sortOrder, sortValue, limit, ..
     saveQuery: string | null;
     fullscreen: boolean;
     clusters: import("../../clusters/types").ClustersState;
+    vDisk: import("../../vdisk/types").VDiskState;
 }) => Promise<import("../../nodes/types").NodesHandledResponse | undefined>;
 export declare const selectTopNodesByCpu: (state: TopPoolsStateSlice) => import("../../nodes/types").NodesPreparedEntity[] | undefined;
 export declare const setDataWasNotLoaded: () => {

package/dist/store/reducers/tenantOverview/topNodesByLoad/topNodesByLoad.d.ts

@@ -88,6 +88,7 @@ export declare function getTopNodesByLoad({ type, sortOrder, sortValue, limit, .
     saveQuery: string | null;
     fullscreen: boolean;
     clusters: import("../../clusters/types").ClustersState;
+    vDisk: import("../../vdisk/types").VDiskState;
 }) => Promise<import("../../nodes/types").NodesHandledResponse | undefined>;
 export declare const selectTopNodesByLoad: (state: TopNodesByLoadStateSlice) => import("../../nodes/types").NodesPreparedEntity[] | undefined;
 export declare const setDataWasNotLoaded: () => {

package/dist/store/reducers/tenantOverview/topNodesByMemory/topNodesByMemory.d.ts

@@ -88,6 +88,7 @@ export declare function getTopNodesByMemory({ type, sortOrder, sortValue, limit,
     saveQuery: string | null;
     fullscreen: boolean;
     clusters: import("../../clusters/types").ClustersState;
+    vDisk: import("../../vdisk/types").VDiskState;
 }) => Promise<import("../../nodes/types").NodesHandledResponse | undefined>;
 export declare const selectTopNodesByMemory: (state: TopNodesByMemorySlice) => import("../../nodes/types").NodesPreparedEntity[] | undefined;
 export declare const setDataWasNotLoaded: () => {

package/dist/store/reducers/tenantOverview/topQueries/tenantOverviewTopQueries.d.ts

@@ -87,6 +87,7 @@ export declare const fetchTenantOverviewTopQueries: (database: string) => (dispa
     saveQuery: string | null;
     fullscreen: boolean;
     clusters: import("../../clusters/types").ClustersState;
+    vDisk: import("../../vdisk/types").VDiskState;
 }) => Promise<import("../../../../types/store/query").IQueryResult | undefined>;
 export declare function setDataWasNotLoaded(): {
     readonly type: "tenantOverviewTopQueries/SET_DATA_WAS_NOT_LOADED";

package/dist/store/reducers/tenantOverview/topShards/tenantOverviewTopShards.d.ts

@@ -87,6 +87,7 @@ export declare const sendTenantOverviewTopShardsQuery: (database: string, path?:
     saveQuery: string | null;
     fullscreen: boolean;
     clusters: import("../../clusters/types").ClustersState;
+    vDisk: import("../../vdisk/types").VDiskState;
 }) => Promise<import("../../../../types/store/query").IQueryResult | undefined>;
 export declare function setDataWasNotLoaded(): {
     readonly type: "tenantOverviewTopShards/SET_DATA_WAS_NOT_LOADED";

package/dist/store/reducers/tenantOverview/topStorageGroups/topStorageGroups.d.ts

@@ -88,6 +88,7 @@ export declare const getTopStorageGroups: ({ tenant, visibleEntities, nodeId, so
     saveQuery: string | null;
     fullscreen: boolean;
     clusters: import("../../clusters/types").ClustersState;
+    vDisk: import("../../vdisk/types").VDiskState;
 }) => Promise<import("./types").PreparedTopStorageGroupsResponse | undefined>;
 export declare const selectTopStorageGroups: (state: TopStorageGroupsStateSlice) => import("../../storage/types").PreparedStorageGroup[] | undefined;
 export declare const setDataWasNotLoaded: () => {

package/dist/store/reducers/tenants/selectors.js

@@ -1,5 +1,5 @@
 import { createSelector } from '@reduxjs/toolkit';
-import { escapeRegExp } from 'lodash';
+import escapeRegExp from 'lodash/escapeRegExp';
 import { EFlag } from '../../../types/api/enums';
 import { ProblemFilterValues, selectProblemFilter } from '../settings/settings';
 // ==== Filters ====

package/dist/store/reducers/tenants/tenants.d.ts

@@ -87,6 +87,7 @@ export declare function getTenantsInfo(clusterName?: string): (dispatch: import(
     saveQuery: string | null;
     fullscreen: boolean;
     clusters: import("../clusters/types").ClustersState;
+    vDisk: import("../vdisk/types").VDiskState;
 }) => Promise<{
     backend: string | undefined;
     sharedTenantName: string | undefined;

package/dist/store/reducers/topic.d.ts

@@ -93,6 +93,7 @@ export declare function getTopic(path?: string): (dispatch: import("redux").Disp
     saveQuery: string | null;
     fullscreen: boolean;
     clusters: import("./clusters/types").ClustersState;
+    vDisk: import("./vdisk/types").VDiskState;
 }) => Promise<unknown>;
 export declare const selectConsumersNames: Selector<ITopicRootStateSlice, string[] | undefined>;
 export declare const selectPreparedTopicStats: Selector<ITopicRootStateSlice, IPreparedTopicStats | undefined>;

package/dist/store/reducers/vdisk/types.d.ts

@@ -0,0 +1,25 @@
+import type { IResponseError } from '../../../types/api/error';
+import type { PreparedVDisk } from '../../../utils/disks/types';
+import type { ApiRequestAction } from '../../utils';
+import type { PreparedStorageGroup } from '../storage/types';
+import type { FETCH_VDISK, setVDiskDataWasNotLoaded } from './vdisk';
+export type VDiskGroup = Partial<PreparedStorageGroup>;
+export interface VDiskData extends PreparedVDisk {
+    NodeId?: number;
+    NodeHost?: string;
+    NodeType?: string;
+    NodeDC?: string;
+    PDiskId?: number;
+    PDiskType?: string;
+}
+export interface VDiskState {
+    loading: boolean;
+    wasLoaded: boolean;
+    error?: IResponseError;
+    vDiskData: VDiskData;
+    groupData?: VDiskGroup;
+}
+export type VDiskAction = ApiRequestAction<typeof FETCH_VDISK, {
+    vDiskData: VDiskData;
+    groupData?: VDiskGroup;
+}, IResponseError> | ReturnType<typeof setVDiskDataWasNotLoaded>;

package/dist/store/reducers/vdisk/utils.d.ts

@@ -0,0 +1,11 @@
+import type { TEvPDiskStateResponse } from '../../../types/api/pdisk';
+import type { TStorageInfo } from '../../../types/api/storage';
+import type { TEvSystemStateResponse } from '../../../types/api/systemState';
+import type { TEvVDiskStateResponse } from '../../../types/api/vdisk';
+import type { VDiskData } from './types';
+export declare function prepareVDiskDataResponse([vDiskResponse, pDiskResponse, nodeResponse]: [
+    TEvVDiskStateResponse,
+    TEvPDiskStateResponse,
+    TEvSystemStateResponse
+]): VDiskData;
+export declare function prepareVDiskGroupResponse(data: TStorageInfo, poolName: string, groupId: number): import("../storage/types").PreparedStorageGroup | undefined;

package/dist/store/reducers/vdisk/utils.js

@@ -0,0 +1,33 @@
+import { preparePDiskData, prepareVDiskData } from '../../../utils/disks/prepareDisks';
+import { prepareNodeSystemState } from '../../../utils/nodes';
+import { prepareStorageGroupData } from '../storage/utils';
+export function prepareVDiskDataResponse([vDiskResponse, pDiskResponse, nodeResponse]) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const rawVDisk = (_a = vDiskResponse.VDiskStateInfo) === null || _a === void 0 ? void 0 : _a[0];
+    const preparedVDisk = prepareVDiskData(rawVDisk);
+    const rawPDisk = (_b = pDiskResponse.PDiskStateInfo) === null || _b === void 0 ? void 0 : _b[0];
+    const preparedPDisk = preparePDiskData(rawPDisk);
+    const rawNode = (_c = nodeResponse.SystemStateInfo) === null || _c === void 0 ? void 0 : _c[0];
+    const preparedNode = prepareNodeSystemState(rawNode);
+    const NodeId = (_e = (_d = preparedVDisk.NodeId) !== null && _d !== void 0 ? _d : preparedPDisk.NodeId) !== null && _e !== void 0 ? _e : preparedNode.NodeId;
+    const NodeHost = preparedNode.Host;
+    const NodeType = (_f = preparedNode.Roles) === null || _f === void 0 ? void 0 : _f[0];
+    const NodeDC = preparedNode.DC;
+    const PDiskId = (_g = preparedVDisk.PDiskId) !== null && _g !== void 0 ? _g : preparedPDisk.PDiskId;
+    const PDiskType = preparedPDisk.Type;
+    return Object.assign(Object.assign({}, preparedVDisk), { NodeId,
+        NodeHost,
+        NodeType,
+        NodeDC,
+        PDiskId,
+        PDiskType });
+}
+export function prepareVDiskGroupResponse(data, poolName, groupId) {
+    var _a, _b;
+    const rawPoolData = (_a = data.StoragePools) === null || _a === void 0 ? void 0 : _a.find((pool) => pool.Name === poolName);
+    const rawGroupData = (_b = rawPoolData === null || rawPoolData === void 0 ? void 0 : rawPoolData.Groups) === null || _b === void 0 ? void 0 : _b.find((group) => group.GroupID === groupId);
+    if (rawGroupData && rawPoolData) {
+        return prepareStorageGroupData(rawGroupData, rawPoolData);
+    }
+    return undefined;
+}

package/dist/store/reducers/vdisk/vdisk.d.ts

@@ -0,0 +1,100 @@
+import type { Reducer } from '@reduxjs/toolkit';
+import type { VDiskAction, VDiskState } from './types';
+export declare const FETCH_VDISK: {
+    readonly REQUEST: "vdisk/FETCH_VDISK_REQUEST";
+    readonly SUCCESS: "vdisk/FETCH_VDISK_SUCCESS";
+    readonly FAILURE: "vdisk/FETCH_VDISK_FAILURE";
+};
+declare const vdisk: Reducer<VDiskState, VDiskAction>;
+export declare const setVDiskDataWasNotLoaded: () => {
+    readonly type: "vdisk/SET_VDISK_DATA_WAS_NOT_LOADED";
+};
+interface VDiskDataRequestParams {
+    nodeId: number | string;
+    pDiskId: number | string;
+    vDiskSlotId: number | string;
+}
+export declare const getVDiskData: (params: VDiskDataRequestParams) => (dispatch: import("redux").Dispatch<import("redux").UnknownAction>, getState: () => {
+    singleClusterMode: boolean;
+    nodes: import("../nodes/types").NodesState;
+    topNodesByLoad: import("../tenantOverview/topNodesByLoad/types").TopNodesByLoadState;
+    topNodesByCpu: import("../tenantOverview/topNodesByCpu/types").TopNodesByCpuState;
+    topNodesByMemory: import("../tenantOverview/topNodesByMemory/types").TopNodesByMemoryState;
+    cluster: import("../cluster/types").ClusterState;
+    clusterNodes: import("../clusterNodes/types").ClusterNodesState;
+    tenant: import("../tenant/types").TenantState;
+    storage: import("../storage/types").StorageState;
+    topStorageGroups: import("../tenantOverview/topStorageGroups/types").TopStorageGroupsState;
+    node: import("../node/types").NodeState;
+    tooltip: import("../../../types/store/tooltip").ITooltipState;
+    tablets: import("../../../types/store/tablets").ITabletsState;
+    schema: import("../schema/types").SchemaState;
+    overview: import("../overview/types").OverviewState;
+    olapStats: import("../../../types/store/olapStats").OlapStatsState;
+    host: import("../../../types/store/host").IHostState;
+    network: import("../network/types").NetworkState;
+    tenants: import("../tenants/types").TenantsState;
+    tablet: import("../../../types/store/tablet").ITabletState;
+    topic: import("../../../types/store/topic").ITopicState;
+    partitions: import("../partitions/types").PartitionsState;
+    pDisk: import("../pdisk/types").PDiskState;
+    executeQuery: import("../../../types/store/executeQuery").ExecuteQueryState;
+    explainQuery: import("../../../types/store/explainQuery").ExplainQueryState;
+    tabletsFilters: {
+        loading: boolean;
+        requestTime: number;
+        data: undefined;
+        wasLoaded: boolean;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        tabletsData: any;
+        nodes: any;
+        loading: boolean;
+        wasLoaded: boolean;
+        timeoutForRequest: number;
+        error: undefined;
+        data: undefined;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        error: any;
+        loading: boolean;
+        data: undefined;
+        wasLoaded: boolean;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        stateFilter: any;
+        data: undefined;
+        loading: boolean;
+        wasLoaded: boolean;
+        typeFilter: never[];
+    } | {
+        typeFilter: any;
+        data: undefined;
+        loading: boolean;
+        wasLoaded: boolean;
+        stateFilter: never[];
+    };
+    heatmap: import("../../../types/store/heatmap").IHeatmapState;
+    settings: import("../settings/types").SettingsState;
+    preview: any;
+    nodesList: import("../../../types/store/nodesList").NodesListState;
+    describe: import("../../../types/store/describe").IDescribeState;
+    schemaAcl: import("../schemaAcl/types").SchemaAclState;
+    executeTopQueries: import("../executeTopQueries/types").ITopQueriesState;
+    executeTopTables: import("../tenantOverview/executeTopTables/types").TopTablesState;
+    tenantOverviewTopQueries: import("../tenantOverview/topQueries/types").TenantOverviewTopQueriesState;
+    healthcheckInfo: import("../healthcheckInfo/types").HealthcheckInfoState;
+    shardsWorkload: import("../shardsWorkload/types").IShardsWorkloadState;
+    tenantOverviewTopShards: import("../tenantOverview/topShards/types").TenantOverviewTopShardsState;
+    hotKeys: import("../hotKeys/types").HotKeysState;
+    authentication: import("../authentication/types").AuthenticationState;
+    header: import("../header/types").HeaderState;
+    saveQuery: string | null;
+    fullscreen: boolean;
+    clusters: import("../clusters/types").ClustersState;
+    vDisk: VDiskState;
+}) => Promise<unknown>;
+export default vdisk;

package/dist/store/reducers/vdisk/vdisk.js

@@ -0,0 +1,64 @@
+import { EVersion } from '../../../types/api/storage';
+import { valueIsDefined } from '../../../utils';
+import { createRequestActionTypes, createApiRequest } from '../../utils';
+import { prepareVDiskDataResponse, prepareVDiskGroupResponse } from './utils';
+export const FETCH_VDISK = createRequestActionTypes('vdisk', 'FETCH_VDISK');
+const SET_VDISK_DATA_WAS_NOT_LOADED = 'vdisk/SET_VDISK_DATA_WAS_NOT_LOADED';
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+    vDiskData: {},
+};
+const vdisk = (state = initialState, action) => {
+    switch (action.type) {
+        case FETCH_VDISK.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_VDISK.SUCCESS: {
+            const { vDiskData, groupData } = action.data;
+            return Object.assign(Object.assign({}, state), { vDiskData,
+                groupData, loading: false, wasLoaded: true, error: undefined });
+        }
+        case FETCH_VDISK.FAILURE: {
+            return Object.assign(Object.assign({}, state), { error: action.error, loading: false });
+        }
+        case SET_VDISK_DATA_WAS_NOT_LOADED: {
+            return Object.assign(Object.assign({}, state), { wasLoaded: false });
+        }
+        default:
+            return state;
+    }
+};
+export const setVDiskDataWasNotLoaded = () => {
+    return {
+        type: SET_VDISK_DATA_WAS_NOT_LOADED,
+    };
+};
+const requestVDiskData = async ({ nodeId, pDiskId, vDiskSlotId }) => {
+    const vDiskDataResponse = await Promise.all([
+        window.api.getVdiskInfo({ nodeId, pDiskId, vDiskSlotId }),
+        window.api.getPdiskInfo(nodeId, pDiskId),
+        window.api.getNodeInfo(nodeId),
+    ]);
+    const vDiskData = prepareVDiskDataResponse(vDiskDataResponse);
+    const { StoragePoolName, VDiskId = {} } = vDiskData;
+    const { GroupID } = VDiskId;
+    let groupData;
+    if (valueIsDefined(StoragePoolName) && valueIsDefined(GroupID)) {
+        const groupResponse = await window.api.getStorageInfo({
+            nodeId,
+            poolName: StoragePoolName,
+            groupId: GroupID,
+            version: EVersion.v1,
+        });
+        groupData = prepareVDiskGroupResponse(groupResponse, StoragePoolName, GroupID);
+    }
+    return { vDiskData, groupData };
+};
+export const getVDiskData = (params) => {
+    return createApiRequest({
+        request: requestVDiskData(params),
+        actions: FETCH_VDISK,
+    });
+};
+export default vdisk;

package/dist/store/state-url-mapping.js

@@ -1,7 +1,9 @@
 import { __rest } from "tslib";
 import { createReduxLocationActions } from 'redux-location-state';
 import qs from 'qs';
-import _ from 'lodash';
+import each from 'lodash/each';
+import keys from 'lodash/keys';
+import merge from 'lodash/merge';
 import { stateToParams } from 'redux-location-state/lib/stateToParams';
 import { parseQuery } from 'redux-location-state/lib/parseQuery';
 import { LOCATION_PUSH, LOCATION_POP } from 'redux-location-state/lib/constants';
@@ -81,7 +83,7 @@ const paramSetup = {
     },
 };
 function mergeLocationToState(state, location) {
-    return _.merge({}, state, location.query);
+    return merge({}, state, location.query);
 }
 function restoreUnknownParams(location, prevLocation) {
     const { search } = location, rest = __rest(location, ["search"]);
@@ -90,11 +92,11 @@ function restoreUnknownParams(location, prevLocation) {
     const declaredPath = getMatchingDeclaredPath(paramSetup, location);
     const entries = declaredPath && paramSetup[declaredPath];
     // remove params which are mapped for this page
-    _.each(_.keys(entries), (param) => {
+    each(keys(entries), (param) => {
         delete params[param];
     });
     // and globally
-    _.each(_.keys(paramSetup.global || {}), (param) => {
+    each(keys(paramSetup.global || {}), (param) => {
         delete params[param];
     });
     const restoredParams = qs.stringify(params, { encoder: encodeURIComponent });

package/dist/types/api/storage.d.ts

@@ -31,10 +31,12 @@ export interface TStoragePoolInfo {
     MaximumThroughput?: string;
     /** uint64 */
     MaximumSize?: string;
+    MediaType?: string;
 }
 export interface TStorageGroupInfoV2 extends TStorageGroupInfo {
     PoolName?: string;
     Kind?: string;
+    MediaType?: string;
     /** uint64 */
     Degraded?: string;
     /** uint64 */

package/dist/utils/bytesParsers/__test__/formatBytes.test.js

@@ -8,21 +8,21 @@ describe('formatBytes', () => {
         expect(formatBytes({ value: 100000000000000 })).toBe('100 TB');
     });
     it('should convert to size', () => {
-        expect(formatBytes({ value: 100000, size: 'b' })).toBe('100,000 B');
-        expect(formatBytes({ value: 100000000000000, size: 'gb' })).toBe('100,000 GB');
+        expect(formatBytes({ value: 100000, size: 'b' })).toBe('100 000 B');
+        expect(formatBytes({ value: 100000000000000, size: 'gb' })).toBe('100 000 GB');
     });
     it('should convert without labels', () => {
-        expect(formatBytes({ value: 100000, size: 'b', withSizeLabel: false })).toBe('100,000');
-        expect(formatBytes({ value: 100000000000000, size: 'gb', withSizeLabel: false })).toBe('100,000');
+        expect(formatBytes({ value: 100000, size: 'b', withSizeLabel: false })).toBe('100 000');
+        expect(formatBytes({ value: 100000000000000, size: 'gb', withSizeLabel: false })).toBe('100 000');
     });
     it('should convert to speed', () => {
         expect(formatBytes({ value: 100000, withSpeedLabel: true })).toBe('100 KB/s');
-        expect(formatBytes({ value: 100000, size: 'b', withSpeedLabel: true })).toBe('100,000 B/s');
+        expect(formatBytes({ value: 100000, size: 'b', withSpeedLabel: true })).toBe('100 000 B/s');
     });
     it('should return fixed amount of significant digits', () => {
-        expect(formatBytes({ value: 99000, significantDigits: 2 })).toEqual('99,000 B');
+        expect(formatBytes({ value: 99000, significantDigits: 2 })).toEqual('99 000 B');
         expect(formatBytes({ value: 100000, significantDigits: 2 })).toEqual('100 KB');
-        expect(formatBytes({ value: 99000000000000, significantDigits: 2 })).toEqual('99,000 GB');
+        expect(formatBytes({ value: 99000000000000, significantDigits: 2 })).toEqual('99 000 GB');
         expect(formatBytes({ value: 100000000000000, significantDigits: 2 })).toEqual('100 TB');
     });
     it('should return empty string on invalid data', () => {

package/dist/utils/clusterVersionColors.js

@@ -1,4 +1,4 @@
-import { uniqBy } from 'lodash';
+import uniqBy from 'lodash/uniqBy';
 import { COLORS, GREY_COLOR, getMinorVersion, hashCode } from './versions';
 const UNDEFINED_COLOR_INDEX = '__no_color__';
 export const getVersionMap = (versions, initialMap = new Map()) => {

package/dist/utils/dataFormatters/dataFormatters.js

@@ -68,6 +68,7 @@ export const formatNumber = (number) => {
     if (!isNumeric(number)) {
         return '';
     }
+    // "," in format is delimiter sign, not delimiter itself
     return configuredNumeral(number).format('0,0.[00000]');
 };
 export const roundToPrecision = (value, precision = 0) => {

package/dist/utils/disks/constants.js

@@ -13,12 +13,12 @@ export const DISK_NUMERIC_SEVERITY_TO_STATE_COLOR = Object.entries(DISK_COLOR_ST
 export const NOT_AVAILABLE_SEVERITY = DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Grey;
 export const NOT_AVAILABLE_SEVERITY_COLOR = DISK_NUMERIC_SEVERITY_TO_STATE_COLOR[NOT_AVAILABLE_SEVERITY];
 export const VDISK_STATE_SEVERITY = {
+    [EVDiskState.OK]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Green,
     [EVDiskState.Initial]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Yellow,
+    [EVDiskState.SyncGuidRecovery]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Yellow,
     [EVDiskState.LocalRecoveryError]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Red,
     [EVDiskState.SyncGuidRecoveryError]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Red,
-    [EVDiskState.SyncGuidRecovery]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Yellow,
     [EVDiskState.PDiskError]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Red,
-    [EVDiskState.OK]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Green,
 };
 export const PDISK_STATE_SEVERITY = {
     [TPDiskState.Initial]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Grey,

package/dist/utils/disks/types.d.ts

@@ -1,5 +1,5 @@
 import type { TPDiskStateInfo } from '../../types/api/pdisk';
-import type { TVDiskStateInfo } from '../../types/api/vdisk';
+import type { TVDiskStateInfo, TVSlotId } from '../../types/api/vdisk';
 import type { ValueOf } from '../../types/common';
 import type { PDISK_TYPES } from './getPDiskType';
 export interface PreparedPDisk extends TPDiskStateInfo {
@@ -13,3 +13,7 @@ export interface PreparedVDisk extends TVDiskStateInfo {
     Severity?: number;
 }
 export type PDiskType = ValueOf<typeof PDISK_TYPES>;
+export interface UnavailableDonor extends TVSlotId {
+    DonorMode?: boolean;
+    StoragePoolName?: string;
+}

package/dist/utils/filters.js

@@ -1,4 +1,4 @@
-import { escapeRegExp } from 'lodash';
+import escapeRegExp from 'lodash/escapeRegExp';
 import { DESCENDING } from '@gravity-ui/react-data-table/build/esm/lib/constants';
 export const prepareSortValue = (sortValue, sortOrder = DESCENDING) => {
     if (!sortValue) {

package/dist/utils/hooks/useTableResize.d.ts

@@ -1,5 +1,5 @@
 import type { Column as DataTableColumn } from '@gravity-ui/react-data-table';
-import type { Column as VirtualTableColumn } from '../../components/VirtualTable';
+import { type Column as VirtualTableColumn } from '../../components/VirtualTable';
 export type Column<T> = VirtualTableColumn<T> & DataTableColumn<T>;
 export type TableColumnsWidthSetup = Record<string, number>;
 export type HandleTableColumnsResize = (newSetup: TableColumnsWidthSetup) => void;

package/dist/utils/hooks/useTableResize.js

@@ -1,12 +1,14 @@
 import { useCallback, useState } from 'react';
+import { DEFAULT_RESIZEABLE } from '../../components/VirtualTable';
 import { settingsManager } from '../../services/settings';
 export const updateColumnsWidth = (columns, columnsWidthSetup) => {
     return columns.map((column) => {
-        var _a;
-        if (!column.resizeable) {
+        var _a, _b;
+        const resizeable = (_a = column.resizeable) !== null && _a !== void 0 ? _a : DEFAULT_RESIZEABLE;
+        if (!resizeable) {
             return column;
         }
-        return Object.assign(Object.assign({}, column), { width: (_a = columnsWidthSetup[column.name]) !== null && _a !== void 0 ? _a : column.width });
+        return Object.assign(Object.assign({}, column), { width: (_b = columnsWidthSetup[column.name]) !== null && _b !== void 0 ? _b : column.width });
     });
 };
 export const useTableResize = (localStorageKey) => {

package/dist/utils/lazyComponent.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+export declare function lazyComponent<TExports extends {
+    [key: string]: any;
+}, TKey extends keyof TExports>(moduleLoader: () => Promise<TExports>, exportName: TKey, loader?: React.ReactNode): React.ForwardRefExoticComponent<React.PropsWithoutRef<React.ComponentProps<TExports[TKey]>> & React.RefAttributes<TExports[TKey]>>;

package/dist/utils/lazyComponent.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from 'react';
+import { Loader } from '@gravity-ui/uikit';
+import { ErrorBoundaryFallback } from '../components/ErrorBoundary/ErrorBoundary';
+import { useComponent } from '../components/ComponentsProvider/ComponentsProvider';
+export function lazyComponent(moduleLoader, exportName, loader) {
+    const Component = React.lazy(() => moduleLoader()
+        .then((module) => ({ default: module[exportName] }))
+        .catch((error) => ({ default: () => _jsx(ErrorBoundaryFallback, { error: error }) })));
+    const LazyComponent = (props, ref) => {
+        const ErrorBoundary = useComponent('ErrorBoundary');
+        return (_jsx(ErrorBoundary, { children: _jsx(React.Suspense, Object.assign({ fallback: loader !== null && loader !== void 0 ? loader : _jsx(DefaultLoader, {}) }, { children: _jsx(Component, Object.assign({ ref: ref }, props)) })) }));
+    };
+    LazyComponent.displayName = exportName;
+    return React.forwardRef(LazyComponent);
+}
+function DefaultLoader() {
+    return (_jsx("div", Object.assign({ style: {
+            width: '100%',
+            height: '100%',
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'center',
+        } }, { children: _jsx(Loader, { size: "l" }) })));
+}

package/dist/utils/monaco/index.d.ts

@@ -0,0 +1 @@
+export declare function registerLanguages(): void;