ydb-embedded-ui 4.33.0 → 5.0.0

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

@@ -0,0 +1,105 @@
+import { createSelector } from 'reselect';
+import { ASCENDING, DESCENDING } from '@gravity-ui/react-data-table/build/esm/lib/constants';
+import { NODES_SORT_VALUES } from '../../../utils/nodes';
+import { STORAGE_SORT_VALUES, getUsage } from '../../../utils/storage';
+import { filterNodesByUptime } from '../nodes/selectors';
+import { VISIBLE_ENTITIES } from './constants';
+// ==== Filters ====
+const prepareSearchText = (text) => text.trim().toLowerCase();
+const filterNodesByText = (entities, text) => {
+    const preparedSearch = prepareSearchText(text);
+    if (!preparedSearch) {
+        return entities;
+    }
+    return entities.filter((entity) => {
+        var _a, _b;
+        return (((_a = entity.NodeId) === null || _a === void 0 ? void 0 : _a.toString().includes(preparedSearch)) ||
+            ((_b = entity.Host) === null || _b === void 0 ? void 0 : _b.toLowerCase().includes(preparedSearch)));
+    });
+};
+const filterGroupsByText = (entities, text) => {
+    const preparedSearch = prepareSearchText(text);
+    if (!preparedSearch) {
+        return entities;
+    }
+    return entities.filter((entity) => {
+        var _a, _b;
+        return (((_a = entity.PoolName) === null || _a === void 0 ? void 0 : _a.toLowerCase().includes(preparedSearch)) ||
+            ((_b = entity.GroupID) === null || _b === void 0 ? void 0 : _b.toString().includes(preparedSearch)));
+    });
+};
+const filterGroupsByUsage = (entities, usage) => {
+    if (!Array.isArray(usage) || usage.length === 0) {
+        return entities;
+    }
+    return entities.filter((entity) => {
+        const entityUsage = entity.Usage;
+        return usage.some((val) => Number(val) <= entityUsage && entityUsage < Number(val) + 5);
+    });
+};
+// ==== Simple selectors ====
+export const selectEntitiesCount = (state) => ({
+    total: state.storage.total,
+    found: state.storage.found,
+});
+export const selectStorageGroups = (state) => state.storage.groups;
+export const selectStorageNodes = (state) => state.storage.nodes;
+export const selectStorageFilter = (state) => state.storage.filter;
+export const selectUsageFilter = (state) => state.storage.usageFilter;
+export const selectVisibleEntities = (state) => state.storage.visible;
+export const selectNodesUptimeFilter = (state) => state.storage.nodesUptimeFilter;
+export const selectStorageType = (state) => state.storage.type;
+// ==== Sort params selectors ====
+export const selectNodesSortParams = (state) => {
+    const defaultSortValue = NODES_SORT_VALUES.NodeId;
+    const defaultSortOrder = ASCENDING;
+    return {
+        sortValue: state.storage.nodesSortValue || defaultSortValue,
+        sortOrder: state.storage.nodesSortOrder || defaultSortOrder,
+    };
+};
+export const selectGroupsSortParams = (state) => {
+    const visibleEntities = state.storage.visible;
+    let defaultSortValue = STORAGE_SORT_VALUES.PoolName;
+    let defaultSortOrder = ASCENDING;
+    if (visibleEntities === VISIBLE_ENTITIES.missing) {
+        defaultSortValue = STORAGE_SORT_VALUES.Degraded;
+        defaultSortOrder = DESCENDING;
+    }
+    if (visibleEntities === VISIBLE_ENTITIES.space) {
+        defaultSortValue = STORAGE_SORT_VALUES.Usage;
+        defaultSortOrder = DESCENDING;
+    }
+    return {
+        sortValue: state.storage.groupsSortValue || defaultSortValue,
+        sortOrder: state.storage.groupsSortOrder || defaultSortOrder,
+    };
+};
+// ==== Complex selectors ====
+export const selectUsageFilterOptions = createSelector(selectStorageGroups, (groups) => {
+    const items = {};
+    groups === null || groups === void 0 ? void 0 : groups.forEach((group) => {
+        // Get groups usage with step 5
+        const usage = getUsage(group, 5);
+        if (!Object.prototype.hasOwnProperty.call(items, usage)) {
+            items[usage] = 0;
+        }
+        items[usage] += 1;
+    });
+    return Object.entries(items)
+        .map(([threshold, count]) => ({ threshold: Number(threshold), count }))
+        .sort((a, b) => b.threshold - a.threshold);
+});
+// ==== Complex selectors with filters ====
+export const selectFilteredNodes = createSelector([selectStorageNodes, selectStorageFilter, selectNodesUptimeFilter], (storageNodes, textFilter, uptimeFilter) => {
+    let result = storageNodes || [];
+    result = filterNodesByText(result, textFilter);
+    result = filterNodesByUptime(result, uptimeFilter);
+    return result;
+});
+export const selectFilteredGroups = createSelector([selectStorageGroups, selectStorageFilter, selectUsageFilter], (storageGroups, textFilter, usageFilter) => {
+    let result = storageGroups || [];
+    result = filterGroupsByText(result, textFilter);
+    result = filterGroupsByUsage(result, usageFilter);
+    return result;
+});

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

@@ -0,0 +1,47 @@
+import type { Reducer } from 'redux';
+import { NodesUptimeFilterValues } from '../../../utils/nodes';
+import type { NodesApiRequestParams, NodesSortParams } from '../nodes/types';
+import type { StorageAction, StorageApiRequestParams, StorageSortParams, StorageState, StorageType, VisibleEntities } from './types';
+export declare const FETCH_STORAGE: {
+    readonly REQUEST: "storage/FETCH_STORAGE_REQUEST";
+    readonly SUCCESS: "storage/FETCH_STORAGE_SUCCESS";
+    readonly FAILURE: "storage/FETCH_STORAGE_FAILURE";
+};
+declare const storage: Reducer<StorageState, StorageAction>;
+export declare const getStorageNodesInfo: ({ tenant, visibleEntities, ...params }: Omit<NodesApiRequestParams, 'type'>) => (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("..").GetState) => Promise<import("./types").PreparedStorageResponse | undefined>;
+export declare const getStorageGroupsInfo: ({ tenant, visibleEntities, nodeId, version, ...params }: StorageApiRequestParams) => (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("..").GetState) => Promise<import("./types").PreparedStorageResponse | undefined>;
+export declare function setInitialState(): {
+    readonly type: "storage/SET_INITIAL";
+};
+export declare function setStorageType(value: StorageType): {
+    readonly type: "storage/SET_STORAGE_TYPE";
+    readonly data: StorageType;
+};
+export declare function setStorageTextFilter(value: string): {
+    readonly type: "storage/SET_FILTER";
+    readonly data: string;
+};
+export declare function setUsageFilter(value: string[]): {
+    readonly type: "storage/SET_USAGE_FILTER";
+    readonly data: string[];
+};
+export declare function setVisibleEntities(value: VisibleEntities): {
+    readonly type: "storage/SET_VISIBLE_GROUPS";
+    readonly data: VisibleEntities;
+};
+export declare function setNodesUptimeFilter(value: NodesUptimeFilterValues): {
+    readonly type: "storage/SET_NODES_UPTIME_FILTER";
+    readonly data: NodesUptimeFilterValues;
+};
+export declare const setDataWasNotLoaded: () => {
+    readonly type: "storage/SET_DATA_WAS_NOT_LOADED";
+};
+export declare const setNodesSortParams: (sortParams: NodesSortParams) => {
+    readonly type: "storage/SET_NODES_SORT_PARAMS";
+    readonly data: NodesSortParams;
+};
+export declare const setGroupsSortParams: (sortParams: StorageSortParams) => {
+    readonly type: "storage/SET_GROUPS_SORT_PARAMS";
+    readonly data: StorageSortParams;
+};
+export default storage;

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

@@ -0,0 +1,151 @@
+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 { EVersion } from '../../../types/api/storage';
+import { NodesUptimeFilterValues } from '../../../utils/nodes';
+import { createRequestActionTypes, createApiRequest } from '../../utils';
+import { VISIBLE_ENTITIES, STORAGE_TYPES } from './constants';
+import { prepareStorageGroupsResponse, prepareStorageNodesResponse } from './utils';
+export const FETCH_STORAGE = createRequestActionTypes('storage', 'FETCH_STORAGE');
+const SET_INITIAL = 'storage/SET_INITIAL';
+const SET_FILTER = 'storage/SET_FILTER';
+const SET_USAGE_FILTER = 'storage/SET_USAGE_FILTER';
+const SET_VISIBLE_GROUPS = 'storage/SET_VISIBLE_GROUPS';
+const SET_STORAGE_TYPE = 'storage/SET_STORAGE_TYPE';
+const SET_NODES_UPTIME_FILTER = 'storage/SET_NODES_UPTIME_FILTER';
+const SET_DATA_WAS_NOT_LOADED = 'storage/SET_DATA_WAS_NOT_LOADED';
+const SET_NODES_SORT_PARAMS = 'storage/SET_NODES_SORT_PARAMS';
+const SET_GROUPS_SORT_PARAMS = 'storage/SET_GROUPS_SORT_PARAMS';
+const initialState = {
+    loading: true,
+    wasLoaded: false,
+    filter: '',
+    usageFilter: [],
+    visible: VISIBLE_ENTITIES.all,
+    nodesUptimeFilter: NodesUptimeFilterValues.All,
+    type: STORAGE_TYPES.groups,
+};
+const storage = (state = initialState, action) => {
+    var _a;
+    switch (action.type) {
+        case FETCH_STORAGE.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_STORAGE.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { nodes: action.data.nodes, groups: action.data.groups, total: action.data.total, found: action.data.found, loading: false, wasLoaded: true, error: undefined });
+        }
+        case FETCH_STORAGE.FAILURE: {
+            if ((_a = action.error) === null || _a === void 0 ? void 0 : _a.isCancelled) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { error: action.error, loading: false, wasLoaded: true });
+        }
+        case SET_INITIAL: {
+            return Object.assign({}, initialState);
+        }
+        case SET_FILTER: {
+            return Object.assign(Object.assign({}, state), { filter: action.data });
+        }
+        case SET_USAGE_FILTER: {
+            return Object.assign(Object.assign({}, state), { usageFilter: action.data });
+        }
+        case SET_VISIBLE_GROUPS: {
+            return Object.assign(Object.assign({}, state), { visible: action.data, usageFilter: [], wasLoaded: false, error: undefined });
+        }
+        case SET_NODES_UPTIME_FILTER: {
+            return Object.assign(Object.assign({}, state), { nodesUptimeFilter: action.data });
+        }
+        case SET_STORAGE_TYPE: {
+            return Object.assign(Object.assign({}, state), { type: action.data, filter: '', usageFilter: [], wasLoaded: false, error: undefined });
+        }
+        case SET_DATA_WAS_NOT_LOADED: {
+            return Object.assign(Object.assign({}, state), { wasLoaded: false });
+        }
+        case SET_NODES_SORT_PARAMS: {
+            return Object.assign(Object.assign({}, state), { nodesSortValue: action.data.sortValue, nodesSortOrder: action.data.sortOrder });
+        }
+        case SET_GROUPS_SORT_PARAMS: {
+            return Object.assign(Object.assign({}, state), { groupsSortValue: action.data.sortValue, groupsSortOrder: action.data.sortOrder });
+        }
+        default:
+            return state;
+    }
+};
+const concurrentId = 'getStorageInfo';
+export const getStorageNodesInfo = (_a) => {
+    var { tenant, visibleEntities } = _a, params = __rest(_a, ["tenant", "visibleEntities"]);
+    return createApiRequest({
+        request: window.api.getNodes(Object.assign({ tenant, visibleEntities, storage: true, type: 'static' }, params), { concurrentId }),
+        actions: FETCH_STORAGE,
+        dataHandler: prepareStorageNodesResponse,
+    });
+};
+export const getStorageGroupsInfo = (_a) => {
+    var { tenant, visibleEntities, nodeId, version = EVersion.v1 } = _a, params = __rest(_a, ["tenant", "visibleEntities", "nodeId", "version"]);
+    return createApiRequest({
+        request: window.api.getStorageInfo(Object.assign({ tenant, visibleEntities, nodeId, version }, params), { concurrentId }),
+        actions: FETCH_STORAGE,
+        dataHandler: prepareStorageGroupsResponse,
+    });
+};
+export function setInitialState() {
+    return {
+        type: SET_INITIAL,
+    };
+}
+export function setStorageType(value) {
+    return {
+        type: SET_STORAGE_TYPE,
+        data: value,
+    };
+}
+export function setStorageTextFilter(value) {
+    return {
+        type: SET_FILTER,
+        data: value,
+    };
+}
+export function setUsageFilter(value) {
+    return {
+        type: SET_USAGE_FILTER,
+        data: value,
+    };
+}
+export function setVisibleEntities(value) {
+    return {
+        type: SET_VISIBLE_GROUPS,
+        data: value,
+    };
+}
+export function setNodesUptimeFilter(value) {
+    return {
+        type: SET_NODES_UPTIME_FILTER,
+        data: value,
+    };
+}
+export const setDataWasNotLoaded = () => {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    };
+};
+export const setNodesSortParams = (sortParams) => {
+    return {
+        type: SET_NODES_SORT_PARAMS,
+        data: sortParams,
+    };
+};
+export const setGroupsSortParams = (sortParams) => {
+    return {
+        type: SET_GROUPS_SORT_PARAMS,
+        data: sortParams,
+    };
+};
+export default storage;

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

@@ -0,0 +1,81 @@
+import type { OrderType } from '@gravity-ui/react-data-table';
+import type { IResponseError } from '../../../types/api/error';
+import type { TSystemStateInfo } from '../../../types/api/nodes';
+import type { TPDiskStateInfo } from '../../../types/api/pdisk';
+import type { EVersion, TStorageGroupInfo } from '../../../types/api/storage';
+import type { TVDiskStateInfo } from '../../../types/api/vdisk';
+import type { ValueOf } from '../../../types/common';
+import type { NodesSortValue, NodesUptimeFilterValues } from '../../../utils/nodes';
+import type { StorageSortValue } from '../../../utils/storage';
+import type { ApiRequestAction } from '../../utils';
+import { STORAGE_TYPES, VISIBLE_ENTITIES } from './constants';
+import { FETCH_STORAGE, setDataWasNotLoaded, setGroupsSortParams, setInitialState, setNodesSortParams, setNodesUptimeFilter, setStorageTextFilter, setStorageType, setUsageFilter, setVisibleEntities } from './storage';
+export declare type VisibleEntities = ValueOf<typeof VISIBLE_ENTITIES>;
+export declare type StorageType = ValueOf<typeof STORAGE_TYPES>;
+export interface PreparedStorageNode extends TSystemStateInfo {
+    NodeId: number;
+    PDisks: TPDiskStateInfo[] | undefined;
+    VDisks: TVDiskStateInfo[] | undefined;
+    Missing: number;
+    Uptime: string;
+}
+export interface PreparedStorageGroup extends TStorageGroupInfo {
+    PoolName: string | undefined;
+    Usage: number;
+    Read: number;
+    Write: number;
+    Used: number;
+    Limit: number;
+    Degraded: number;
+    Kind: string | undefined;
+    UsedSpaceFlag: number;
+}
+export interface UsageFilter {
+    threshold: number;
+    count: number;
+}
+export interface StorageSortParams {
+    sortOrder?: OrderType;
+    sortValue?: StorageSortValue;
+}
+export interface StorageSortAndFilterParams extends StorageSortParams {
+    filter?: string;
+    offset?: number;
+    limit?: number;
+}
+export interface StorageApiRequestParams extends StorageSortAndFilterParams {
+    tenant?: string;
+    nodeId?: string;
+    visibleEntities?: VisibleEntities;
+    version?: EVersion;
+}
+export interface StorageState {
+    loading: boolean;
+    wasLoaded: boolean;
+    filter: string;
+    usageFilter: string[];
+    visible: VisibleEntities;
+    nodesUptimeFilter: NodesUptimeFilterValues;
+    groupsSortValue?: StorageSortValue;
+    groupsSortOrder?: OrderType;
+    nodesSortValue?: NodesSortValue;
+    nodesSortOrder?: OrderType;
+    type: StorageType;
+    nodes?: PreparedStorageNode[];
+    groups?: PreparedStorageGroup[];
+    found?: number;
+    total?: number;
+    error?: IResponseError;
+}
+export interface PreparedStorageResponse {
+    nodes?: PreparedStorageNode[];
+    groups?: PreparedStorageGroup[];
+    found: number | undefined;
+    total: number | undefined;
+}
+declare type GetStorageInfoApiRequestAction = ApiRequestAction<typeof FETCH_STORAGE, PreparedStorageResponse, IResponseError>;
+export declare type StorageAction = GetStorageInfoApiRequestAction | ReturnType<typeof setInitialState> | ReturnType<typeof setStorageType> | ReturnType<typeof setStorageTextFilter> | ReturnType<typeof setUsageFilter> | ReturnType<typeof setVisibleEntities> | ReturnType<typeof setNodesUptimeFilter> | ReturnType<typeof setDataWasNotLoaded> | ReturnType<typeof setNodesSortParams> | ReturnType<typeof setGroupsSortParams>;
+export interface StorageStateSlice {
+    storage: StorageState;
+}
+export {};

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

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

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

@@ -0,0 +1,6 @@
+import type { TNodesInfo } from '../../../types/api/nodes';
+import type { TStorageGroupInfoV2, TStorageInfo, TStoragePoolInfo } from '../../../types/api/storage';
+import type { PreparedStorageGroup, PreparedStorageResponse } from './types';
+export declare const prepareStorageGroups: (StorageGroups?: TStorageGroupInfoV2[] | undefined, StoragePools?: TStoragePoolInfo[] | undefined) => PreparedStorageGroup[];
+export declare const prepareStorageNodesResponse: (data: TNodesInfo) => PreparedStorageResponse;
+export declare const prepareStorageGroupsResponse: (data: TStorageInfo) => PreparedStorageResponse;

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

@@ -0,0 +1,125 @@
+import { EVDiskState } from '../../../types/api/vdisk';
+import { TPDiskState } from '../../../types/api/pdisk';
+import { EFlag } from '../../../types/api/enums';
+import { getPDiskType } from '../../../utils/pdisk';
+import { getUsage } from '../../../utils/storage';
+import { calcUptime } from '../../../utils/dataFormatters/dataFormatters';
+// ==== Constants  ====
+const FLAGS_POINTS = {
+    [EFlag.Green]: 1,
+    [EFlag.Yellow]: 100,
+    [EFlag.Orange]: 10000,
+    [EFlag.Red]: 1000000,
+};
+// ==== Prepare groups ====
+const prepareVDisk = (vDisk, poolName) => {
+    var _a;
+    // VDisk doesn't have its own StoragePoolName when located inside StoragePool data
+    return Object.assign(Object.assign({}, vDisk), { StoragePoolName: poolName, Donors: (_a = vDisk.Donors) === null || _a === void 0 ? void 0 : _a.map((donor) => (Object.assign(Object.assign({}, donor), { StoragePoolName: poolName }))) });
+};
+const prepareStorageGroupData = (group, poolName) => {
+    var _a;
+    let missing = 0;
+    let usedSpaceFlag = 0;
+    let usedSpaceBytes = 0;
+    let limitSizeBytes = 0;
+    let readSpeedBytesPerSec = 0;
+    let writeSpeedBytesPerSec = 0;
+    let mediaType = '';
+    if (group.VDisks) {
+        for (const vDisk of group.VDisks) {
+            const { Replicated, VDiskState, AvailableSize, AllocatedSize, PDisk, DiskSpace, ReadThroughput, WriteThroughput, } = vDisk;
+            if (!Replicated ||
+                (PDisk === null || PDisk === void 0 ? void 0 : PDisk.State) !== TPDiskState.Normal ||
+                VDiskState !== EVDiskState.OK) {
+                missing += 1;
+            }
+            if (DiskSpace && DiskSpace !== EFlag.Grey) {
+                usedSpaceFlag += FLAGS_POINTS[DiskSpace];
+            }
+            const available = Number(AvailableSize !== null && AvailableSize !== void 0 ? AvailableSize : PDisk === null || PDisk === void 0 ? void 0 : PDisk.AvailableSize) || 0;
+            const allocated = Number(AllocatedSize) || 0;
+            usedSpaceBytes += allocated;
+            limitSizeBytes += available + allocated;
+            readSpeedBytesPerSec += Number(ReadThroughput) || 0;
+            writeSpeedBytesPerSec += Number(WriteThroughput) || 0;
+            const currentType = getPDiskType(PDisk || {});
+            mediaType =
+                currentType && (currentType === mediaType || mediaType === '')
+                    ? currentType
+                    : '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 });
+};
+const prepareStorageGroupDataV2 = (group) => {
+    const { VDisks = [], PoolName, Usage = 0, Read = 0, Write = 0, Used = 0, Limit = 0, Degraded = 0, Kind, } = group;
+    const UsedSpaceFlag = VDisks.reduce((acc, { DiskSpace }) => {
+        if (DiskSpace && DiskSpace !== EFlag.Grey) {
+            return acc + FLAGS_POINTS[DiskSpace];
+        }
+        return acc;
+    }, 0);
+    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) });
+};
+export const prepareStorageGroups = (StorageGroups, StoragePools) => {
+    let preparedGroups = [];
+    if (StorageGroups) {
+        preparedGroups = StorageGroups.map(prepareStorageGroupDataV2);
+    }
+    else {
+        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));
+            });
+        });
+    }
+    return preparedGroups;
+};
+// ==== Prepare nodes ====
+const prepareStorageNodeData = (node) => {
+    var _a, _b;
+    const systemState = (_a = node.SystemState) !== null && _a !== void 0 ? _a : {};
+    const missing = ((_b = node.PDisks) === null || _b === void 0 ? void 0 : _b.filter((pDisk) => {
+        return pDisk.State !== TPDiskState.Normal;
+    }).length) || 0;
+    return {
+        NodeId: node.NodeId,
+        SystemState: systemState.SystemState,
+        DataCenter: systemState.DataCenter,
+        Rack: systemState.Rack,
+        Host: systemState.Host,
+        Endpoints: systemState.Endpoints,
+        Uptime: calcUptime(systemState.StartTime),
+        StartTime: systemState.StartTime,
+        PDisks: node.PDisks,
+        VDisks: node.VDisks,
+        Missing: missing,
+    };
+};
+// ==== Prepare responses ====
+export const prepareStorageNodesResponse = (data) => {
+    const { Nodes, TotalNodes, FoundNodes } = data;
+    const preparedNodes = Nodes === null || Nodes === void 0 ? void 0 : Nodes.map(prepareStorageNodeData);
+    return {
+        nodes: preparedNodes,
+        total: Number(TotalNodes) || (preparedNodes === null || preparedNodes === void 0 ? void 0 : preparedNodes.length),
+        found: Number(FoundNodes),
+    };
+};
+export const prepareStorageGroupsResponse = (data) => {
+    const { StoragePools, StorageGroups, TotalGroups, FoundGroups } = data;
+    const preparedGroups = prepareStorageGroups(StorageGroups, StoragePools);
+    return {
+        groups: preparedGroups,
+        total: Number(TotalGroups) || preparedGroups.length,
+        found: Number(FoundGroups),
+    };
+};

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

@@ -0,0 +1,20 @@
+import type { Reducer } from 'redux';
+import type { TDomainKey } from '../../types/api/tablet';
+import type { ITabletAction, ITabletDescribeHandledResponse, ITabletHandledResponse, ITabletState } from '../../types/store/tablet';
+export declare const FETCH_TABLET: {
+    readonly REQUEST: "TABLET/FETCH_TABLET_REQUEST";
+    readonly SUCCESS: "TABLET/FETCH_TABLET_SUCCESS";
+    readonly FAILURE: "TABLET/FETCH_TABLET_FAILURE";
+};
+export declare const FETCH_TABLET_DESCRIBE: {
+    readonly REQUEST: "TABLET/FETCH_TABLET_DESCRIBE_REQUEST";
+    readonly SUCCESS: "TABLET/FETCH_TABLET_DESCRIBE_SUCCESS";
+    readonly FAILURE: "TABLET/FETCH_TABLET_DESCRIBE_FAILURE";
+};
+declare const tablet: Reducer<ITabletState, ITabletAction>;
+export declare const getTablet: (id: string) => (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<ITabletHandledResponse | undefined>;
+export declare const getTabletDescribe: (tenantId?: TDomainKey) => (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<ITabletDescribeHandledResponse | undefined>;
+export declare const clearTabletData: () => {
+    readonly type: "tablet/CLEAR_TABLET_DATA";
+};
+export default tablet;

package/dist/store/reducers/tablet.js

@@ -0,0 +1,85 @@
+import { createRequestActionTypes, createApiRequest } from '../utils';
+import { prepareNodesMap } from '../../utils/nodes';
+export const FETCH_TABLET = createRequestActionTypes('TABLET', 'FETCH_TABLET');
+export const FETCH_TABLET_DESCRIBE = createRequestActionTypes('TABLET', 'FETCH_TABLET_DESCRIBE');
+const CLEAR_TABLET_DATA = 'tablet/CLEAR_TABLET_DATA';
+const initialState = {
+    loading: false,
+    tenantPath: undefined,
+};
+const tablet = (state = initialState, action) => {
+    switch (action.type) {
+        case FETCH_TABLET.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_TABLET.SUCCESS: {
+            const { tabletData, historyData } = action.data;
+            const { TabletId: id } = tabletData;
+            return Object.assign(Object.assign({}, state), { id, data: tabletData, history: historyData, loading: false, error: undefined });
+        }
+        case FETCH_TABLET.FAILURE: {
+            return Object.assign(Object.assign({}, state), { error: action.error, loading: false });
+        }
+        case FETCH_TABLET_DESCRIBE.SUCCESS: {
+            const { tenantPath } = action.data;
+            return Object.assign(Object.assign({}, state), { tenantPath, error: undefined });
+        }
+        case CLEAR_TABLET_DATA: {
+            return Object.assign(Object.assign({}, state), { id: undefined, tenantPath: undefined, data: undefined, history: undefined });
+        }
+        default:
+            return state;
+    }
+};
+export const getTablet = (id) => {
+    return createApiRequest({
+        request: Promise.all([
+            window.api.getTablet({ id }),
+            window.api.getTabletHistory({ id }),
+            window.api.getNodesList(),
+        ]),
+        actions: FETCH_TABLET,
+        dataHandler: ([tabletResponseData, historyResponseData, nodesList,]) => {
+            const nodesMap = prepareNodesMap(nodesList);
+            const historyData = Object.keys(historyResponseData).reduce((list, nodeId) => {
+                var _a;
+                const tabletInfo = (_a = historyResponseData[nodeId]) === null || _a === void 0 ? void 0 : _a.TabletStateInfo;
+                if (tabletInfo && tabletInfo.length) {
+                    const leaderTablet = tabletInfo.find((t) => t.Leader) || tabletInfo[0];
+                    const { ChangeTime, Generation, State, Leader, FollowerId } = leaderTablet;
+                    const fqdn = nodesMap && nodeId ? nodesMap.get(Number(nodeId)) : undefined;
+                    list.push({
+                        nodeId,
+                        generation: Generation,
+                        changeTime: ChangeTime,
+                        state: State,
+                        leader: Leader,
+                        followerId: FollowerId,
+                        fqdn,
+                    });
+                }
+                return list;
+            }, []);
+            const { TabletStateInfo = [] } = tabletResponseData;
+            const [tabletData = {}] = TabletStateInfo;
+            return { tabletData, historyData };
+        },
+    });
+};
+export const getTabletDescribe = (tenantId = {}) => {
+    return createApiRequest({
+        request: window.api.getTabletDescribe(tenantId),
+        actions: FETCH_TABLET_DESCRIBE,
+        dataHandler: (tabletDescribe) => {
+            const { SchemeShard, PathId } = tenantId;
+            const tenantPath = tabletDescribe.Path || `${SchemeShard}:${PathId}`;
+            return { tenantPath };
+        },
+    });
+};
+export const clearTabletData = () => {
+    return {
+        type: CLEAR_TABLET_DATA,
+    };
+};
+export default tablet;

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

@@ -0,0 +1,22 @@
+import type { Reducer } from 'redux';
+import type { ETabletState, EType } from '../../types/api/tablet';
+import type { ITabletsAction, ITabletsApiRequestParams, ITabletsState } from '../../types/store/tablets';
+export declare const FETCH_TABLETS: {
+    readonly REQUEST: "tablets/FETCH_TABLETS_REQUEST";
+    readonly SUCCESS: "tablets/FETCH_TABLETS_SUCCESS";
+    readonly FAILURE: "tablets/FETCH_TABLETS_FAILURE";
+};
+declare const tablets: Reducer<ITabletsState, ITabletsAction>;
+export declare const setStateFilter: (stateFilter: ETabletState[]) => {
+    readonly type: "tablets/SET_STATE_FILTER";
+    readonly data: ETabletState[];
+};
+export declare const setTypeFilter: (typeFilter: EType[]) => {
+    readonly type: "tablets/SET_TYPE_FILTER";
+    readonly data: EType[];
+};
+export declare const clearWasLoadingFlag: () => {
+    readonly type: "tablets/CLEAR_WAS_LOADING_TABLETS";
+};
+export declare function getTabletsInfo(data: ITabletsApiRequestParams): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<unknown>;
+export default tablets;