ydb-embedded-ui 4.32.0 → 5.0.0

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

@@ -0,0 +1,200 @@
+import singleClusterMode from './singleClusterMode';
+export declare const rootReducer: {
+    singleClusterMode: typeof singleClusterMode;
+    nodes: import("redux").Reducer<import("./nodes/types").NodesState, import("./nodes/types").NodesAction>;
+    topNodesByLoad: import("redux").Reducer<import("./tenantOverview/topNodesByLoad/types").TopNodesByLoadState, import("./tenantOverview/topNodesByLoad/types").TopNodesByLoadAction>;
+    topNodesByCpu: import("redux").Reducer<import("./tenantOverview/topNodesByCpu/types").TopNodesByCpuState, import("./tenantOverview/topNodesByCpu/types").TopNodesByCpuAction>;
+    topNodesByMemory: import("redux").Reducer<import("./tenantOverview/topNodesByMemory/types").TopNodesByMemoryState, import("./tenantOverview/topNodesByMemory/types").TopNodesByMemoryAction>;
+    cluster: import("redux").Reducer<import("./cluster/types").ClusterState, import("./cluster/types").ClusterAction>;
+    clusterNodes: import("redux").Reducer<import("./clusterNodes/types").ClusterNodesState, import("./clusterNodes/types").ClusterNodesAction>;
+    tenant: import("redux").Reducer<import("./tenant/types").TenantState, import("./tenant/types").TenantAction>;
+    storage: import("redux").Reducer<import("./storage/types").StorageState, import("./storage/types").StorageAction>;
+    topStorageGroups: import("redux").Reducer<import("./tenantOverview/topStorageGroups/types").TopStorageGroupsState, import("./tenantOverview/topStorageGroups/types").TopStorageGroupsAction>;
+    node: import("redux").Reducer<import("./node/types").NodeState, import("./node/types").NodeAction>;
+    tooltip: import("redux").Reducer<import("../../types/store/tooltip").ITooltipState, import("../../types/store/tooltip").ITooltipAction>;
+    tablets: import("redux").Reducer<import("../../types/store/tablets").ITabletsState, import("../../types/store/tablets").ITabletsAction>;
+    schema: import("redux").Reducer<import("./schema/types").SchemaState, import("./schema/types").SchemaAction>;
+    overview: import("redux").Reducer<import("./overview/types").OverviewState, import("./overview/types").OverviewAction>;
+    olapStats: import("redux").Reducer<import("../../types/store/olapStats").OlapStatsState, import("../../types/store/olapStats").OlapStatsAction>;
+    host: import("redux").Reducer<import("../../types/store/host").IHostState, import("../../types/store/host").IHostAction>;
+    network: import("redux").Reducer<import("./network/types").NetworkState, import("./network/types").NetworkAction>;
+    tenants: import("redux").Reducer<import("./tenants/types").TenantsState, import("./tenants/types").TenantsAction>;
+    tablet: import("redux").Reducer<import("../../types/store/tablet").ITabletState, import("../../types/store/tablet").ITabletAction>;
+    topic: import("redux").Reducer<import("../../types/store/topic").ITopicState, import("../../types/store/topic").ITopicAction>;
+    partitions: import("redux").Reducer<import("./partitions/types").PartitionsState, import("./partitions/types").PartitionsAction>;
+    executeQuery: import("redux").Reducer<import("../../types/store/executeQuery").ExecuteQueryState, import("../../types/store/executeQuery").ExecuteQueryAction>;
+    explainQuery: import("redux").Reducer<import("../../types/store/explainQuery").ExplainQueryState, import("../../types/store/explainQuery").ExplainQueryAction>;
+    tabletsFilters: (state: {
+        data: undefined;
+        loading: boolean;
+        wasLoaded: boolean;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | undefined, action: any) => {
+        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("redux").Reducer<import("../../types/store/heatmap").IHeatmapState, import("../../types/store/heatmap").IHeatmapAction>;
+    settings: import("redux").Reducer<import("./settings/types").SettingsState, import("./settings/types").SettingsAction>;
+    preview: (state: {
+        loading: boolean;
+        wasLoaded: boolean;
+    } | undefined, action: import("../utils").ApiRequestAction<{
+        readonly REQUEST: "preview/SEND_QUERY_REQUEST";
+        readonly SUCCESS: "preview/SEND_QUERY_SUCCESS";
+        readonly FAILURE: "preview/SEND_QUERY_FAILURE";
+    }, import("../../types/store/query").IQueryResult, import("../../types/store/query").QueryErrorResponse> | {
+        readonly type: "preview/SET_QUERY_OPTIONS";
+        readonly data: any;
+    }) => any;
+    nodesList: import("redux").Reducer<import("../../types/store/nodesList").NodesListState, import("../../types/store/nodesList").NodesListAction>;
+    describe: import("redux").Reducer<import("../../types/store/describe").IDescribeState, import("../../types/store/describe").IDescribeAction>;
+    schemaAcl: import("redux").Reducer<import("./schemaAcl/types").SchemaAclState, import("./schemaAcl/types").SchemaAclAction>;
+    executeTopQueries: import("redux").Reducer<import("./executeTopQueries/types").ITopQueriesState, import("./executeTopQueries/types").ITopQueriesAction>;
+    executeTopTables: import("redux").Reducer<import("./tenantOverview/executeTopTables/types").TopTablesState, import("./tenantOverview/executeTopTables/types").TopTablesAction>;
+    tenantOverviewTopQueries: import("redux").Reducer<import("./tenantOverview/topQueries/types").TenantOverviewTopQueriesState, import("./tenantOverview/topQueries/types").TenantOverviewTopQueriesAction>;
+    healthcheckInfo: import("redux").Reducer<import("../../types/store/healthcheck").IHealthcheckInfoState, import("../../types/store/healthcheck").IHealthCheckInfoAction>;
+    shardsWorkload: import("redux").Reducer<import("./shardsWorkload/types").IShardsWorkloadState, import("./shardsWorkload/types").IShardsWorkloadAction>;
+    tenantOverviewTopShards: import("redux").Reducer<import("./tenantOverview/topShards/types").TenantOverviewTopShardsState, import("./tenantOverview/topShards/types").TenantOverviewTopShardsAction>;
+    hotKeys: (state: {
+        loading: boolean;
+        data: {};
+        wasLoaded: boolean;
+    } | undefined, action: any) => any;
+    authentication: import("redux").Reducer<import("./authentication/types").AuthenticationState, import("./authentication/types").AuthenticationAction>;
+    header: import("redux").Reducer<import("./header/types").HeaderState, {
+        readonly type: "header/SET_HEADER_BREADCRUMBS";
+        readonly page: import("./header/types").Page;
+        readonly options: {} | import("./header/types").TabletsBreadcrumbsOptions | import("./header/types").TenantBreadcrumbsOptions | import("./header/types").ClusterBreadcrumbsOptions | import("./header/types").NodeBreadcrumbsOptions | import("./header/types").TabletBreadcrumbsOptions;
+    }>;
+    saveQuery: import("redux").Reducer<string | null, {
+        readonly type: "SET_QUERY_NAME_TO_EDIT";
+        readonly data: string;
+    } | {
+        readonly type: "CLEAR_QUERY_NAME_TO_EDIT";
+    }>;
+    fullscreen: (state: boolean | undefined, action: {
+        readonly type: "ENABLE_FULLSCREEN_MODE";
+    } | {
+        readonly type: "DISABLE_FULLSCREEN_MODE";
+    }) => boolean;
+    clusters: import("redux").Reducer<import("./clusters/types").ClustersState, import("./clusters/types").ClustersAction>;
+};
+declare const combinedReducer: import("redux").Reducer<import("redux").CombinedState<{
+    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;
+    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("../../types/store/healthcheck").IHealthcheckInfoState;
+    shardsWorkload: import("./shardsWorkload/types").IShardsWorkloadState;
+    tenantOverviewTopShards: import("./tenantOverview/topShards/types").TenantOverviewTopShardsState;
+    hotKeys: any;
+    authentication: import("./authentication/types").AuthenticationState;
+    header: import("./header/types").HeaderState;
+    saveQuery: string | null;
+    fullscreen: boolean;
+    clusters: import("./clusters/types").ClustersState;
+}>, any>;
+export declare type RootReducer = typeof combinedReducer;
+export declare type RootState = ReturnType<RootReducer>;
+export declare type GetState = () => RootState;
+export default combinedReducer;

package/dist/store/reducers/index.js

@@ -0,0 +1,91 @@
+import { combineReducers } from 'redux';
+import nodes from './nodes/nodes';
+import { topNodesByLoad } from './tenantOverview/topNodesByLoad/topNodesByLoad';
+import { topNodesByCpu } from './tenantOverview/topNodesByCpu/topNodesByCpu';
+import { topNodesByMemory } from './tenantOverview/topNodesByMemory/topNodesByMemory';
+import cluster from './cluster/cluster';
+import clusterNodes from './clusterNodes/clusterNodes';
+import tenant from './tenant/tenant';
+import storage from './storage/storage';
+import topStorageGroups from './tenantOverview/topStorageGroups/topStorageGroups';
+import node from './node/node';
+import tooltip from './tooltip';
+import tablets from './tablets';
+import heatmap from './heatmap';
+import schema from './schema/schema';
+import overview from './overview/overview';
+import host from './host';
+import network from './network/network';
+import tenants from './tenants/tenants';
+import tablet from './tablet';
+import topic from './topic';
+import partitions from './partitions/partitions';
+import executeQuery from './executeQuery';
+import explainQuery from './explainQuery';
+import tabletsFilters from './tabletsFilters';
+import settings from './settings/settings';
+import preview from './preview';
+import nodesList from './nodesList';
+import describe from './describe';
+import schemaAcl from './schemaAcl/schemaAcl';
+import executeTopQueries from './executeTopQueries/executeTopQueries';
+import { tenantOverviewTopQueries } from './tenantOverview/topQueries/tenantOverviewTopQueries';
+import executeTopTables from './tenantOverview/executeTopTables/executeTopTables';
+import healthcheckInfo from './healthcheckInfo';
+import shardsWorkload from './shardsWorkload/shardsWorkload';
+import { tenantOverviewTopShards } from './tenantOverview/topShards/tenantOverviewTopShards';
+import hotKeys from './hotKeys';
+import olapStats from './olapStats';
+import authentication from './authentication/authentication';
+import header from './header/header';
+import saveQuery from './saveQuery';
+import fullscreen from './fullscreen';
+import singleClusterMode from './singleClusterMode';
+import clusters from './clusters/clusters';
+export const rootReducer = {
+    singleClusterMode,
+    nodes,
+    topNodesByLoad,
+    topNodesByCpu,
+    topNodesByMemory,
+    cluster,
+    clusterNodes,
+    tenant,
+    storage,
+    topStorageGroups,
+    node,
+    tooltip,
+    tablets,
+    schema,
+    overview,
+    olapStats,
+    host,
+    network,
+    tenants,
+    tablet,
+    topic,
+    partitions,
+    executeQuery,
+    explainQuery,
+    tabletsFilters,
+    heatmap,
+    settings,
+    preview,
+    nodesList,
+    describe,
+    schemaAcl,
+    executeTopQueries,
+    executeTopTables,
+    tenantOverviewTopQueries,
+    healthcheckInfo,
+    shardsWorkload,
+    tenantOverviewTopShards,
+    hotKeys,
+    authentication,
+    header,
+    saveQuery,
+    fullscreen,
+    clusters,
+};
+const combinedReducer = combineReducers(Object.assign({}, rootReducer));
+export default combinedReducer;

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

@@ -0,0 +1,13 @@
+import { Reducer } from 'redux';
+import type { NetworkAction, NetworkState } from './types';
+export declare const FETCH_ALL_NODES_NETWORK: {
+    readonly REQUEST: "network/FETCH_ALL_NODES_NETWORK_REQUEST";
+    readonly SUCCESS: "network/FETCH_ALL_NODES_NETWORK_SUCCESS";
+    readonly FAILURE: "network/FETCH_ALL_NODES_NETWORK_FAILURE";
+};
+declare const network: Reducer<NetworkState, NetworkAction>;
+export declare const setDataWasNotLoaded: () => {
+    readonly type: "network/SET_DATA_WAS_NOT_LOADED";
+};
+export declare const getNetworkInfo: (tenant: string) => (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("..").GetState) => Promise<unknown>;
+export default network;

package/dist/store/reducers/network/network.js

@@ -0,0 +1,37 @@
+import { createRequestActionTypes, createApiRequest } from '../../utils';
+export const FETCH_ALL_NODES_NETWORK = createRequestActionTypes('network', 'FETCH_ALL_NODES_NETWORK');
+const SET_DATA_WAS_NOT_LOADED = 'network/SET_DATA_WAS_NOT_LOADED';
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+};
+const network = (state = initialState, action) => {
+    switch (action.type) {
+        case FETCH_ALL_NODES_NETWORK.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_ALL_NODES_NETWORK.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { data: action.data, loading: false, wasLoaded: true, error: undefined });
+        }
+        case FETCH_ALL_NODES_NETWORK.FAILURE: {
+            return Object.assign(Object.assign({}, state), { error: action.error, loading: false });
+        }
+        case SET_DATA_WAS_NOT_LOADED: {
+            return Object.assign(Object.assign({}, state), { wasLoaded: false });
+        }
+        default:
+            return state;
+    }
+};
+export const setDataWasNotLoaded = () => {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    };
+};
+export const getNetworkInfo = (tenant) => {
+    return createApiRequest({
+        request: window.api.getNetwork(tenant),
+        actions: FETCH_ALL_NODES_NETWORK,
+    });
+};
+export default network;

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

@@ -0,0 +1,11 @@
+import type { IResponseError } from '../../../types/api/error';
+import type { TNetInfo } from '../../../types/api/netInfo';
+import type { ApiRequestAction } from '../../utils';
+import { FETCH_ALL_NODES_NETWORK, setDataWasNotLoaded } from './network';
+export interface NetworkState {
+    loading: boolean;
+    wasLoaded: boolean;
+    data?: TNetInfo;
+    error?: IResponseError;
+}
+export declare type NetworkAction = ApiRequestAction<typeof FETCH_ALL_NODES_NETWORK, TNetInfo, IResponseError> | ReturnType<typeof setDataWasNotLoaded>;

package/dist/store/reducers/network/types.js

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

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

@@ -0,0 +1,19 @@
+import { Reducer } from 'redux';
+import type { NodeAction, NodeState } from './types';
+export declare const FETCH_NODE: {
+    readonly REQUEST: "node/FETCH_NODE_REQUEST";
+    readonly SUCCESS: "node/FETCH_NODE_SUCCESS";
+    readonly FAILURE: "node/FETCH_NODE_FAILURE";
+};
+export declare const FETCH_NODE_STRUCTURE: {
+    readonly REQUEST: "node/FETCH_NODE_STRUCTURE_REQUEST";
+    readonly SUCCESS: "node/FETCH_NODE_STRUCTURE_SUCCESS";
+    readonly FAILURE: "node/FETCH_NODE_STRUCTURE_FAILURE";
+};
+declare const node: Reducer<NodeState, NodeAction>;
+export declare const getNodeInfo: (id: string) => (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("..").GetState) => Promise<unknown>;
+export declare const getNodeStructure: (nodeId: string) => (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("..").GetState) => Promise<unknown>;
+export declare function resetNode(): {
+    readonly type: "node/RESET_NODE";
+};
+export default node;

package/dist/store/reducers/node/node.js

@@ -0,0 +1,57 @@
+import { createRequestActionTypes, createApiRequest } from '../../utils';
+export const FETCH_NODE = createRequestActionTypes('node', 'FETCH_NODE');
+export const FETCH_NODE_STRUCTURE = createRequestActionTypes('node', 'FETCH_NODE_STRUCTURE');
+const RESET_NODE = 'node/RESET_NODE';
+const initialState = {
+    data: {},
+    loading: true,
+    wasLoaded: false,
+    nodeStructure: {},
+    loadingStructure: true,
+    wasLoadedStructure: false,
+};
+const node = (state = initialState, action) => {
+    switch (action.type) {
+        case FETCH_NODE.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_NODE.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { data: action.data, loading: false, wasLoaded: true, error: undefined });
+        }
+        case FETCH_NODE.FAILURE: {
+            return Object.assign(Object.assign({}, state), { error: action.error, loading: false });
+        }
+        case FETCH_NODE_STRUCTURE.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loadingStructure: true });
+        }
+        case FETCH_NODE_STRUCTURE.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { nodeStructure: action.data, loadingStructure: false, wasLoadedStructure: true, errorStructure: undefined });
+        }
+        case FETCH_NODE_STRUCTURE.FAILURE: {
+            return Object.assign(Object.assign({}, state), { errorStructure: action.error, loadingStructure: false });
+        }
+        case RESET_NODE: {
+            return Object.assign(Object.assign({}, state), { data: {}, wasLoaded: false, nodeStructure: {}, wasLoadedStructure: false });
+        }
+        default:
+            return state;
+    }
+};
+export const getNodeInfo = (id) => {
+    return createApiRequest({
+        request: window.api.getNodeInfo(id),
+        actions: FETCH_NODE,
+    });
+};
+export const getNodeStructure = (nodeId) => {
+    return createApiRequest({
+        request: window.api.getStorageInfo({ nodeId }, { concurrentId: 'getNodeStructure' }),
+        actions: FETCH_NODE_STRUCTURE,
+    });
+};
+export function resetNode() {
+    return {
+        type: RESET_NODE,
+    };
+}
+export default node;

package/dist/store/reducers/node/selectors.d.ts

@@ -0,0 +1,3 @@
+import type { Selector } from 'reselect';
+import type { NodeStateSlice, PreparedNodeStructure } from './types';
+export declare const selectNodeStructure: Selector<NodeStateSlice, PreparedNodeStructure>;

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

@@ -0,0 +1,36 @@
+import { createSelector } from 'reselect';
+import { stringifyVdiskId } from '../../../utils/dataFormatters/dataFormatters';
+const selectNodeId = (state) => { var _a, _b, _c; return (_c = (_b = (_a = state.node) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.SystemStateInfo) === null || _c === void 0 ? void 0 : _c[0].NodeId; };
+const selectRawNodeStructure = (state) => { var _a; return (_a = state.node) === null || _a === void 0 ? void 0 : _a.nodeStructure; };
+export const selectNodeStructure = createSelector([selectNodeId, selectRawNodeStructure], (nodeId, storageInfo) => {
+    const pools = storageInfo === null || storageInfo === void 0 ? void 0 : storageInfo.StoragePools;
+    const structure = {};
+    pools === null || pools === void 0 ? void 0 : pools.forEach((pool) => {
+        const groups = pool.Groups;
+        groups === null || groups === void 0 ? void 0 : groups.forEach((group) => {
+            var _a;
+            const vDisks = (_a = group.VDisks) === null || _a === void 0 ? void 0 : _a.filter((el) => el.NodeId === nodeId);
+            vDisks === null || vDisks === void 0 ? void 0 : vDisks.forEach((vd) => {
+                var _a;
+                const vDiskId = stringifyVdiskId(vd.VDiskId);
+                const pDiskId = (_a = vd.PDisk) === null || _a === void 0 ? void 0 : _a.PDiskId;
+                if (!structure[String(pDiskId)]) {
+                    structure[String(pDiskId)] = Object.assign({ vDisks: {} }, vd.PDisk);
+                }
+                structure[String(pDiskId)].vDisks[vDiskId] = Object.assign(Object.assign({}, vd), { 
+                    // VDisk doesn't have its own StoragePoolName when located inside StoragePool data
+                    StoragePoolName: pool.Name });
+            });
+        });
+    });
+    const structureWithVdisksArray = Object.keys(structure).reduce((preparedStructure, el) => {
+        const vDisks = structure[el].vDisks;
+        const vDisksArray = Object.keys(vDisks).reduce((acc, key, index) => {
+            acc.push(Object.assign(Object.assign({}, vDisks[key]), { id: key, order: index }));
+            return acc;
+        }, []);
+        preparedStructure[el] = Object.assign(Object.assign({}, structure[el]), { vDisks: vDisksArray });
+        return preparedStructure;
+    }, {});
+    return structureWithVdisksArray;
+});

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

@@ -0,0 +1,34 @@
+import type { IResponseError } from '../../../types/api/error';
+import type { TPDiskStateInfo } from '../../../types/api/pdisk';
+import type { TStorageInfo } from '../../../types/api/storage';
+import type { TEvSystemStateResponse } from '../../../types/api/systemState';
+import type { TVDiskStateInfo } from '../../../types/api/vdisk';
+import type { ApiRequestAction } from '../../utils';
+import { FETCH_NODE, FETCH_NODE_STRUCTURE, resetNode } from './node';
+interface RawStructurePDisk extends TPDiskStateInfo {
+    vDisks: Record<string, TVDiskStateInfo>;
+}
+export declare type RawNodeStructure = Record<string, RawStructurePDisk>;
+export interface PreparedStructureVDisk extends TVDiskStateInfo {
+    id: string;
+    order: number;
+}
+export interface PreparedStructurePDisk extends TPDiskStateInfo {
+    vDisks: PreparedStructureVDisk[];
+}
+export declare type PreparedNodeStructure = Record<string, PreparedStructurePDisk>;
+export interface NodeState {
+    data: TEvSystemStateResponse;
+    loading: boolean;
+    wasLoaded: boolean;
+    error?: IResponseError;
+    nodeStructure: TStorageInfo;
+    loadingStructure: boolean;
+    wasLoadedStructure: boolean;
+    errorStructure?: IResponseError;
+}
+export declare type NodeAction = ApiRequestAction<typeof FETCH_NODE, TEvSystemStateResponse, IResponseError> | ApiRequestAction<typeof FETCH_NODE_STRUCTURE, TStorageInfo, IResponseError> | ReturnType<typeof resetNode>;
+export interface NodeStateSlice {
+    node: NodeState;
+}
+export {};

package/dist/store/reducers/node/types.js

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

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

@@ -0,0 +1,30 @@
+import type { Reducer } from 'redux';
+import { NodesUptimeFilterValues } from '../../../utils/nodes';
+import type { ComputeApiRequestParams, NodesAction, NodesApiRequestParams, NodesSortParams, NodesState } from './types';
+export declare const FETCH_NODES: {
+    readonly REQUEST: "nodes/FETCH_NODES_REQUEST";
+    readonly SUCCESS: "nodes/FETCH_NODES_SUCCESS";
+    readonly FAILURE: "nodes/FETCH_NODES_FAILURE";
+};
+declare const nodes: Reducer<NodesState, NodesAction>;
+export declare function getNodes({ type, storage, ...params }: NodesApiRequestParams): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("..").GetState) => Promise<import("./types").NodesHandledResponse | undefined>;
+export declare function getComputeNodes({ version, ...params }: ComputeApiRequestParams): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("..").GetState) => Promise<import("./types").NodesHandledResponse | undefined>;
+export declare const resetNodesState: () => {
+    readonly type: "nodes/RESET_NODES_STATE";
+};
+export declare const setNodesUptimeFilter: (value: NodesUptimeFilterValues) => {
+    readonly type: "nodes/SET_NODES_UPTIME_FILTER";
+    readonly data: NodesUptimeFilterValues;
+};
+export declare const setDataWasNotLoaded: () => {
+    readonly type: "nodes/SET_DATA_WAS_NOT_LOADED";
+};
+export declare const setSearchValue: (value: string) => {
+    readonly type: "nodes/SET_SEARCH_VALUE";
+    readonly data: string;
+};
+export declare const setSort: (sortParams: NodesSortParams) => {
+    readonly type: "nodes/SET_SORT";
+    readonly data: NodesSortParams;
+};
+export default nodes;

package/dist/store/reducers/nodes/nodes.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 { NodesUptimeFilterValues } from '../../../utils/nodes';
+import { EVersion } from '../../../types/api/compute';
+import { createRequestActionTypes, createApiRequest } from '../../utils';
+import { prepareComputeNodesData, prepareNodesData } from './utils';
+export const FETCH_NODES = createRequestActionTypes('nodes', 'FETCH_NODES');
+const RESET_NODES_STATE = 'nodes/RESET_NODES_STATE';
+const SET_NODES_UPTIME_FILTER = 'nodes/SET_NODES_UPTIME_FILTER';
+const SET_DATA_WAS_NOT_LOADED = 'nodes/SET_DATA_WAS_NOT_LOADED';
+const SET_SEARCH_VALUE = 'nodes/SET_SEARCH_VALUE';
+const SET_SORT = 'nodes/SET_SORT';
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+    nodesUptimeFilter: NodesUptimeFilterValues.All,
+    searchValue: '',
+};
+const nodes = (state = initialState, action) => {
+    var _a, _b, _c;
+    switch (action.type) {
+        case FETCH_NODES.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_NODES.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { data: (_a = action.data) === null || _a === void 0 ? void 0 : _a.Nodes, totalNodes: (_b = action.data) === null || _b === void 0 ? void 0 : _b.TotalNodes, loading: false, wasLoaded: true, error: undefined });
+        }
+        case FETCH_NODES.FAILURE: {
+            if ((_c = action.error) === null || _c === void 0 ? void 0 : _c.isCancelled) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { error: action.error, loading: false });
+        }
+        case RESET_NODES_STATE: {
+            return Object.assign(Object.assign({}, state), { loading: initialState.loading, wasLoaded: initialState.wasLoaded, nodesUptimeFilter: initialState.nodesUptimeFilter, searchValue: initialState.searchValue });
+        }
+        case SET_NODES_UPTIME_FILTER: {
+            return Object.assign(Object.assign({}, state), { nodesUptimeFilter: action.data });
+        }
+        case SET_SEARCH_VALUE: {
+            return Object.assign(Object.assign({}, state), { searchValue: action.data });
+        }
+        case SET_SORT: {
+            return Object.assign(Object.assign({}, state), { sortValue: action.data.sortValue, sortOrder: action.data.sortOrder });
+        }
+        case SET_DATA_WAS_NOT_LOADED: {
+            return Object.assign(Object.assign({}, state), { wasLoaded: false });
+        }
+        default:
+            return state;
+    }
+};
+const concurrentId = 'getNodes';
+export function getNodes(_a) {
+    var { type = 'any', storage = false } = _a, params = __rest(_a, ["type", "storage"]);
+    return createApiRequest({
+        request: window.api.getNodes(Object.assign({ type, storage }, params), { concurrentId }),
+        actions: FETCH_NODES,
+        dataHandler: prepareNodesData,
+    });
+}
+export function getComputeNodes(_a) {
+    var { version = EVersion.v2 } = _a, params = __rest(_a, ["version"]);
+    return createApiRequest({
+        request: window.api.getCompute(Object.assign({ version }, params), { concurrentId }),
+        actions: FETCH_NODES,
+        dataHandler: prepareComputeNodesData,
+    });
+}
+export const resetNodesState = () => {
+    return {
+        type: RESET_NODES_STATE,
+    };
+};
+export const setNodesUptimeFilter = (value) => ({
+    type: SET_NODES_UPTIME_FILTER,
+    data: value,
+});
+export const setDataWasNotLoaded = () => {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    };
+};
+export const setSearchValue = (value) => {
+    return {
+        type: SET_SEARCH_VALUE,
+        data: value,
+    };
+};
+export const setSort = (sortParams) => {
+    return {
+        type: SET_SORT,
+        data: sortParams,
+    };
+};
+export default nodes;