ydb-embedded-ui 5.4.0 → 6.0.0

package/dist/store/reducers/cluster/cluster.js

@@ -1,9 +1,8 @@
-import { DEFAULT_CLUSTER_TAB_KEY } from '../../../utils/constants';
+import { createSlice } from '@reduxjs/toolkit';
 import { clusterTabsIds, isClusterTab } from '../../../containers/Cluster/utils';
-import { createRequestActionTypes, createApiRequest } from '../../utils';
+import { DEFAULT_CLUSTER_TAB_KEY } from '../../../utils/constants';
+import { api } from '../api';
 import { createSelectClusterGroupsQuery, parseGroupsStatsQueryResponse } from './utils';
-const SET_DEFAULT_CLUSTER_TAB = 'cluster/SET_DEFAULT_CLUSTER_TAB';
-export const FETCH_CLUSTER = createRequestActionTypes('cluster', 'FETCH_CLUSTER');
 const defaultClusterTabLS = localStorage.getItem(DEFAULT_CLUSTER_TAB_KEY);
 let defaultClusterTab;
 if (isClusterTab(defaultClusterTabLS)) {
@@ -12,83 +11,66 @@ if (isClusterTab(defaultClusterTabLS)) {
 else {
     defaultClusterTab = clusterTabsIds.overview;
 }
-const initialState = { loading: true, wasLoaded: false, defaultClusterTab };
-const cluster = (state = initialState, action) => {
-    var _a;
-    switch (action.type) {
-        case FETCH_CLUSTER.REQUEST: {
-            return Object.assign(Object.assign({}, state), { loading: true });
-        }
-        case FETCH_CLUSTER.SUCCESS: {
-            const { clusterData, groupsStats } = action.data;
-            return Object.assign(Object.assign({}, state), { data: clusterData, groupsStats, loading: false, wasLoaded: true, error: undefined });
-        }
-        case FETCH_CLUSTER.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 });
-        }
-        case SET_DEFAULT_CLUSTER_TAB: {
-            return Object.assign(Object.assign({}, state), { defaultClusterTab: action.data });
-        }
-        default:
-            return state;
-    }
+const initialState = {
+    defaultClusterTab,
 };
-export function setDefaultClusterTab(tab) {
-    return {
-        type: SET_DEFAULT_CLUSTER_TAB,
-        data: tab,
-    };
-}
+const clusterSlice = createSlice({
+    name: 'cluster',
+    initialState,
+    reducers: {
+        setDefaultClusterTab(state, action) {
+            state.defaultClusterTab = action.payload;
+        },
+    },
+});
 export function updateDefaultClusterTab(tab) {
     return (dispatch) => {
         if (isClusterTab(tab)) {
             localStorage.setItem(DEFAULT_CLUSTER_TAB_KEY, tab);
-            dispatch(setDefaultClusterTab(tab));
+            dispatch(clusterSlice.actions.setDefaultClusterTab(tab));
         }
     };
 }
-export function getClusterInfo(clusterName) {
-    async function requestClusterData() {
-        // Error here is handled by createApiRequest
-        const clusterData = await window.api.getClusterInfo(clusterName);
-        try {
-            const clusterRoot = clusterData.Domain;
-            // Without domain we cannot get stats from system tables
-            if (!clusterRoot) {
-                return {
-                    clusterData,
-                };
-            }
-            const query = createSelectClusterGroupsQuery(clusterRoot);
-            // Normally query request should be fulfilled within 300-400ms even on very big clusters
-            // Table with stats is supposed to be very small (less than 10 rows)
-            // So we batch this request with cluster request to prevent possible layout shifts, if data is missing
-            const groupsStatsResponse = await window.api.sendQuery({
-                schema: 'modern',
-                query: query,
-                database: clusterRoot,
-                action: 'execute-scan',
-            });
-            return {
-                clusterData,
-                groupsStats: parseGroupsStatsQueryResponse(groupsStatsResponse),
-            };
-        }
-        catch (_a) {
-            // Doesn't return groups stats on error
-            // It could happen if user doesn't have access rights
-            // Or there are no system tables in cluster root
-            return {
-                clusterData,
-            };
-        }
-    }
-    return createApiRequest({
-        request: requestClusterData(),
-        actions: FETCH_CLUSTER,
-    });
-}
-export default cluster;
+export default clusterSlice.reducer;
+export const clusterApi = api.injectEndpoints({
+    endpoints: (builder) => ({
+        getClusterInfo: builder.query({
+            queryFn: async (clusterName = '', { signal }) => {
+                try {
+                    const clusterData = await window.api.getClusterInfo(clusterName, { signal });
+                    const clusterRoot = clusterData.Domain;
+                    // Without domain we cannot get stats from system tables
+                    if (!clusterRoot) {
+                        return { data: { clusterData } };
+                    }
+                    try {
+                        const query = createSelectClusterGroupsQuery(clusterRoot);
+                        // Normally query request should be fulfilled within 300-400ms even on very big clusters
+                        // Table with stats is supposed to be very small (less than 10 rows)
+                        // So we batch this request with cluster request to prevent possible layout shifts, if data is missing
+                        const groupsStatsResponse = await window.api.sendQuery({
+                            schema: 'modern',
+                            query: query,
+                            database: clusterRoot,
+                            action: 'execute-scan',
+                        });
+                        return {
+                            data: {
+                                clusterData,
+                                groupsStats: parseGroupsStatsQueryResponse(groupsStatsResponse),
+                            },
+                        };
+                    }
+                    catch (_a) {
+                        return { data: { clusterData } };
+                    }
+                }
+                catch (error) {
+                    return { error };
+                }
+            },
+            providesTags: ['All'],
+        }),
+    }),
+    overrideExisting: 'throw',
+});

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

@@ -1,8 +1,5 @@
 import type { ClusterTab } from '../../../containers/Cluster/utils';
 import type { TClusterInfo } from '../../../types/api/cluster';
-import type { IResponseError } from '../../../types/api/error';
-import type { ApiRequestAction } from '../../utils';
-import type { FETCH_CLUSTER, setDefaultClusterTab } from './cluster';
 export interface DiskErasureGroupsStats {
     diskType: string;
     erasure: string;
@@ -16,15 +13,9 @@ export type DiskGroupsStats = Record<string, DiskErasureGroupsStats>;
 /** Keys - PDisks types */
 export type ClusterGroupsStats = Record<string, DiskGroupsStats>;
 export interface ClusterState {
-    loading: boolean;
-    wasLoaded: boolean;
-    data?: TClusterInfo;
-    error?: IResponseError;
-    groupsStats?: ClusterGroupsStats;
     defaultClusterTab: ClusterTab;
 }
 export interface HandledClusterResponse {
     clusterData: TClusterInfo;
     groupsStats: ClusterGroupsStats;
 }
-export type ClusterAction = ApiRequestAction<typeof FETCH_CLUSTER, HandledClusterResponse, IResponseError> | ReturnType<typeof setDefaultClusterTab>;

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

@@ -1,91 +1,7 @@
-import type { Reducer } from '@reduxjs/toolkit';
-import type { ClusterNodesAction, ClusterNodesState, PreparedClusterNode } from './types';
-export declare const FETCH_CLUSTER_NODES: {
-    readonly REQUEST: "cluster/FETCH_CLUSTER_NODES_REQUEST";
-    readonly SUCCESS: "cluster/FETCH_CLUSTER_NODES_SUCCESS";
-    readonly FAILURE: "cluster/FETCH_CLUSTER_NODES_FAILURE";
-};
-declare const clusterNodes: Reducer<ClusterNodesState, ClusterNodesAction>;
-export declare function getClusterNodes(): (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: 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;
-}) => Promise<PreparedClusterNode[] | undefined>;
-export default clusterNodes;
+import type { TSystemStateInfo } from '../../../types/api/nodes';
+export interface PreparedClusterNode extends TSystemStateInfo {
+    uptime: string;
+}
+export declare const clusterNodesApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, {
+    getClusterNodes: import("@reduxjs/toolkit/query").QueryDefinition<any, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", PreparedClusterNode[] | undefined, "api">;
+}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/dist/query/react").reactHooksModuleName>;

package/dist/store/reducers/clusterNodes/clusterNodes.js

@@ -1,37 +1,23 @@
-import { createRequestActionTypes, createApiRequest } from '../../utils';
 import { calcUptime } from '../../../utils/dataFormatters/dataFormatters';
-export const FETCH_CLUSTER_NODES = createRequestActionTypes('cluster', 'FETCH_CLUSTER_NODES');
-const initialState = { loading: false, wasLoaded: false };
-const clusterNodes = (state = initialState, action) => {
-    var _a;
-    switch (action.type) {
-        case FETCH_CLUSTER_NODES.REQUEST: {
-            return Object.assign(Object.assign({}, state), { loading: true });
-        }
-        case FETCH_CLUSTER_NODES.SUCCESS: {
-            const { data = [] } = action;
-            return Object.assign(Object.assign({}, state), { nodes: data, loading: false, wasLoaded: true, error: undefined });
-        }
-        case FETCH_CLUSTER_NODES.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 });
-        }
-        default:
-            return state;
-    }
-};
-export function getClusterNodes() {
-    return createApiRequest({
-        request: window.api.getClusterNodes(),
-        actions: FETCH_CLUSTER_NODES,
-        dataHandler: (data) => {
-            const { SystemStateInfo: nodes = [] } = data;
-            return nodes.map((node) => {
-                return Object.assign(Object.assign({}, node), { uptime: calcUptime(node.StartTime) });
-            });
-        },
-    });
-}
-export default clusterNodes;
+import { api } from '../api';
+export const clusterNodesApi = api.injectEndpoints({
+    endpoints: (builder) => ({
+        getClusterNodes: builder.query({
+            queryFn: async () => {
+                try {
+                    const result = await window.api.getClusterNodes();
+                    const { SystemStateInfo: nodes = [] } = result;
+                    const data = nodes.map((node) => {
+                        return Object.assign(Object.assign({}, node), { uptime: calcUptime(node.StartTime) });
+                    });
+                    return { data };
+                }
+                catch (error) {
+                    return { error };
+                }
+            },
+            providesTags: ['All'],
+        }),
+    }),
+    overrideExisting: 'throw',
+});

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

@@ -1,95 +1,7 @@
-import type { Reducer } from '@reduxjs/toolkit';
-import type { ClustersAction, ClustersFilters, ClustersState } from './types';
-export declare const FETCH_CLUSTERS: {
-    readonly REQUEST: "clusters/FETCH_CLUSTERS_REQUEST";
-    readonly SUCCESS: "clusters/FETCH_CLUSTERS_SUCCESS";
-    readonly FAILURE: "clusters/FETCH_CLUSTERS_FAILURE";
-};
-declare const clusters: Reducer<ClustersState, ClustersAction>;
-export declare function fetchClustersList(): (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: ClustersState;
-}) => Promise<import("./types").PreparedCluster[] | undefined>;
-export declare function changeClustersFilters(filters: Partial<ClustersFilters>): {
-    readonly type: "clusters/CHANGE_FILTER";
-    readonly data: Partial<ClustersFilters>;
-};
-export default clusters;
+import type { ClustersFilters } from './types';
+declare const _default: import("redux").Reducer<ClustersFilters>;
+export default _default;
+export declare const changeClustersFilters: import("@reduxjs/toolkit").ActionCreatorWithPayload<Partial<ClustersFilters>, "clusters/changeClustersFilters">;
+export declare const clustersApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, {
+    getClustersList: import("@reduxjs/toolkit/query").QueryDefinition<any, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", import("./types").PreparedCluster[] | undefined, "api">;
+}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/dist/query/react").reactHooksModuleName>;

package/dist/store/reducers/clusters/clusters.js

@@ -1,45 +1,35 @@
-import { createRequestActionTypes, createApiRequest } from '../../utils';
+import { createSlice } from '@reduxjs/toolkit';
+import { api } from '../api';
 import { prepareClustersData } from './utils';
-export const FETCH_CLUSTERS = createRequestActionTypes('clusters', 'FETCH_CLUSTERS');
-const CHANGE_FILTERS = 'clusters/CHANGE_FILTER';
 const initialState = {
-    loading: false,
-    list: [],
     clusterName: '',
     status: [],
     service: [],
     version: [],
 };
-const clusters = (state = initialState, action) => {
-    switch (action.type) {
-        case FETCH_CLUSTERS.REQUEST: {
-            return Object.assign(Object.assign({}, state), { loading: true });
-        }
-        case FETCH_CLUSTERS.SUCCESS: {
-            const { data = [] } = action;
-            return Object.assign(Object.assign({}, state), { loading: false, list: data, error: undefined });
-        }
-        case FETCH_CLUSTERS.FAILURE: {
-            return Object.assign(Object.assign({}, state), { error: action.error, loading: false });
-        }
-        case CHANGE_FILTERS: {
-            return Object.assign(Object.assign({}, state), action.data);
-        }
-        default:
-            return state;
-    }
-};
-export function fetchClustersList() {
-    return createApiRequest({
-        request: window.api.getClustersList(),
-        actions: FETCH_CLUSTERS,
-        dataHandler: prepareClustersData,
-    });
-}
-export function changeClustersFilters(filters) {
-    return {
-        type: CHANGE_FILTERS,
-        data: filters,
-    };
-}
-export default clusters;
+const slice = createSlice({
+    name: 'clusters',
+    initialState,
+    reducers: {
+        changeClustersFilters: (state, action) => (Object.assign(Object.assign({}, state), action.payload)),
+    },
+});
+export default slice.reducer;
+export const { changeClustersFilters } = slice.actions;
+export const clustersApi = api.injectEndpoints({
+    endpoints: (builder) => ({
+        getClustersList: builder.query({
+            queryFn: async (_, { signal }) => {
+                try {
+                    const data = await window.api.getClustersList(undefined, { signal });
+                    return { data: prepareClustersData(data) };
+                }
+                catch (error) {
+                    return { error };
+                }
+            },
+            providesTags: ['All'],
+        }),
+    }),
+    overrideExisting: 'throw',
+});

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

@@ -1,36 +1,7 @@
-import { type Selector } from '@reduxjs/toolkit';
-import type { MetaExtendedClusterInfo } from '../../../types/api/meta';
-import type { ClusterDataAggregation, ClustersStateSlice, PreparedCluster } from './types';
-export declare const selectLoadingFlag: (state: ClustersStateSlice) => boolean;
-export declare const selectClustersList: (state: ClustersStateSlice) => PreparedCluster[];
+import type { ClusterDataAggregation, ClustersFilters, ClustersStateSlice, PreparedCluster } from './types';
 export declare const selectClusterNameFilter: (state: ClustersStateSlice) => string;
 export declare const selectStatusFilter: (state: ClustersStateSlice) => string[];
 export declare const selectServiceFilter: (state: ClustersStateSlice) => string[];
 export declare const selectVersionFilter: (state: ClustersStateSlice) => string[];
-export declare const selectVersions: Selector<ClustersStateSlice, {
-    value: string;
-    content: string;
-}[]>;
-export declare const selectFilteredClusters: Selector<ClustersStateSlice, PreparedCluster[]>;
-export declare const selectClustersAggregation: Selector<ClustersStateSlice, ClusterDataAggregation>;
-export declare const selectClusterInfo: ((state: ClustersStateSlice, clusterName: string) => MetaExtendedClusterInfo) & {
-    clearCache: () => void;
-    resultsCount: () => number;
-    resetResultsCount: () => void;
-} & {
-    resultFunc: (resultFuncArgs_0: PreparedCluster[], resultFuncArgs_1: string) => MetaExtendedClusterInfo;
-    memoizedResultFunc: ((resultFuncArgs_0: PreparedCluster[], resultFuncArgs_1: string) => MetaExtendedClusterInfo) & {
-        clearCache: () => void;
-        resultsCount: () => number;
-        resetResultsCount: () => void;
-    };
-    lastResult: () => MetaExtendedClusterInfo;
-    dependencies: [(state: ClustersStateSlice) => PreparedCluster[], (_: unknown, clusterName: string) => string];
-    recomputations: () => number;
-    resetRecomputations: () => void;
-    dependencyRecomputations: () => number;
-    resetDependencyRecomputations: () => void;
-} & {
-    argsMemoize: typeof import("reselect").weakMapMemoize;
-    memoize: typeof import("reselect").weakMapMemoize;
-};
+export declare function filterClusters(clusters: PreparedCluster[], filters: ClustersFilters): PreparedCluster[];
+export declare function aggregateClustersInfo(clusters: PreparedCluster[]): ClusterDataAggregation;

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

@@ -1,6 +1,9 @@
-import { createSelector } from '@reduxjs/toolkit';
-import { escapeRegExp } from 'lodash/fp';
-import { getMinorVersion } from '../../../utils/versions';
+import escapeRegExp from 'lodash/escapeRegExp';
+// ==== Simple selectors ====
+export const selectClusterNameFilter = (state) => state.clusters.clusterName;
+export const selectStatusFilter = (state) => state.clusters.status;
+export const selectServiceFilter = (state) => state.clusters.service;
+export const selectVersionFilter = (state) => state.clusters.version;
 // ==== Filters ====
 const isMatchesByStatus = (clusterData, selectedStatuses) => {
     return (selectedStatuses.length === 0 ||
@@ -39,41 +42,15 @@ const isMatchesByTextQuery = (clusterData, searchQuery = '') => {
     const filteredByHost = Boolean(clusterData.hosts && clusterData.hosts[preparedSearchQuery]);
     return filteredByName || filteredByVersion || filteredByHost;
 };
-// ==== Simple selectors ====
-export const selectLoadingFlag = (state) => state.clusters.loading;
-export const selectClustersList = (state) => state.clusters.list;
-export const selectClusterNameFilter = (state) => state.clusters.clusterName;
-export const selectStatusFilter = (state) => state.clusters.status;
-export const selectServiceFilter = (state) => state.clusters.service;
-export const selectVersionFilter = (state) => state.clusters.version;
-// ==== Complex selectors ====
-export const selectVersions = createSelector(selectClustersList, (clusters) => {
-    const uniqVersions = new Set();
-    clusters
-        .map(({ cluster }) => cluster === null || cluster === void 0 ? void 0 : cluster.Versions)
-        .forEach((clusterVersions) => clusterVersions === null || clusterVersions === void 0 ? void 0 : clusterVersions.forEach((version) => {
-        uniqVersions.add(getMinorVersion(version));
-    }));
-    return Array.from(uniqVersions).map((version) => ({
-        value: version,
-        content: version,
-    }));
-});
-export const selectFilteredClusters = createSelector([
-    selectClustersList,
-    selectClusterNameFilter,
-    selectStatusFilter,
-    selectServiceFilter,
-    selectVersionFilter,
-], (clusters, textSearchQuery, selectedStatuses, selectedServices, selectedVersions) => {
+export function filterClusters(clusters, filters) {
     return clusters.filter((cluster) => {
-        return (isMatchesByStatus(cluster, selectedStatuses) &&
-            isMatchesByService(cluster, selectedServices) &&
-            isMatchesByVersion(cluster, selectedVersions) &&
-            isMatchesByTextQuery(cluster, textSearchQuery));
+        return (isMatchesByStatus(cluster, filters.status) &&
+            isMatchesByService(cluster, filters.service) &&
+            isMatchesByVersion(cluster, filters.version) &&
+            isMatchesByTextQuery(cluster, filters.clusterName));
     });
-});
-export const selectClustersAggregation = createSelector(selectFilteredClusters, (clusters) => {
+}
+export function aggregateClustersInfo(clusters) {
     let NodesTotal = 0, NodesAlive = 0, LoadAverage = 0, NumberOfCpus = 0, StorageUsed = 0, StorageTotal = 0, Tenants = 0;
     const Hosts = new Set();
     const filteredClusters = clusters.filter(({ cluster }) => !(cluster === null || cluster === void 0 ? void 0 : cluster.error));
@@ -85,9 +62,7 @@ export const selectClustersAggregation = createSelector(selectFilteredClusters,
         LoadAverage += Number(cluster === null || cluster === void 0 ? void 0 : cluster.LoadAverage) || 0;
         NumberOfCpus += (cluster === null || cluster === void 0 ? void 0 : cluster.NumberOfCpus) || 0;
         StorageUsed += (cluster === null || cluster === void 0 ? void 0 : cluster.StorageUsed) ? Math.floor(parseInt(cluster.StorageUsed, 10)) : 0;
-        StorageTotal += (cluster === null || cluster === void 0 ? void 0 : cluster.StorageTotal)
-            ? Math.floor(parseInt(cluster.StorageTotal, 10))
-            : 0;
+        StorageTotal += (cluster === null || cluster === void 0 ? void 0 : cluster.StorageTotal) ? Math.floor(parseInt(cluster.StorageTotal, 10)) : 0;
     });
     return {
         NodesTotal,
@@ -99,8 +74,4 @@ export const selectClustersAggregation = createSelector(selectFilteredClusters,
         StorageUsed,
         StorageTotal,
     };
-});
-export const selectClusterInfo = createSelector(selectClustersList, (_, clusterName) => clusterName, (clusters, clusterName) => {
-    const info = clusters.filter((item) => item.name === clusterName)[0] || {};
-    return info;
-});
+}