ydb-embedded-ui 4.33.0 → 5.1.0

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

@@ -0,0 +1,21 @@
+import { FETCH_TOP_QUERIES, setTopQueriesState, setTopQueriesFilters } from './executeTopQueries';
+import type { ApiRequestAction } from '../../utils';
+import type { IQueryResult, QueryErrorResponse } from '../../../types/store/query';
+export interface ITopQueriesFilters {
+    /** ms from epoch */
+    from?: number;
+    /** ms from epoch */
+    to?: number;
+    text?: string;
+}
+export interface ITopQueriesState {
+    loading: boolean;
+    wasLoaded: boolean;
+    data?: IQueryResult;
+    error?: QueryErrorResponse;
+    filters: ITopQueriesFilters;
+}
+export declare type ITopQueriesAction = ApiRequestAction<typeof FETCH_TOP_QUERIES, IQueryResult, QueryErrorResponse> | ReturnType<typeof setTopQueriesState> | ReturnType<typeof setTopQueriesFilters>;
+export interface ITopQueriesRootStateSlice {
+    executeTopQueries: ITopQueriesState;
+}

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

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

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

@@ -0,0 +1,2 @@
+import { ITopQueriesFilters } from './types';
+export declare function getFiltersConditions(path: string, filters?: ITopQueriesFilters): string;

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

@@ -0,0 +1,30 @@
+const endTimeColumn = 'EndTime';
+const intervalEndColumn = 'IntervalEnd';
+const getMaxIntervalSubquery = (path) => `(
+    SELECT
+        MAX(${intervalEndColumn})
+    FROM \`${path}/.sys/top_queries_by_cpu_time_one_hour\`
+)`;
+export function getFiltersConditions(path, filters) {
+    const conditions = [];
+    if ((filters === null || filters === void 0 ? void 0 : filters.from) && (filters === null || filters === void 0 ? void 0 : filters.to) && filters.from > filters.to) {
+        throw new Error('Invalid date range');
+    }
+    if (filters === null || filters === void 0 ? void 0 : filters.from) {
+        // matching `from` & `to` is an edge case
+        // other cases should not include the starting point, since intervals are stored using the ending time
+        const gt = filters.to === filters.from ? '>=' : '>';
+        conditions.push(`${endTimeColumn} ${gt} Timestamp('${new Date(filters.from).toISOString()}')`);
+    }
+    if (filters === null || filters === void 0 ? void 0 : filters.to) {
+        conditions.push(`${endTimeColumn} <= Timestamp('${new Date(filters.to).toISOString()}')`);
+    }
+    // If there is no filters, return queries, that were executed in the last hour
+    if (!(filters === null || filters === void 0 ? void 0 : filters.from) && !(filters === null || filters === void 0 ? void 0 : filters.to)) {
+        conditions.push(`${intervalEndColumn} IN ${getMaxIntervalSubquery(path)}`);
+    }
+    if (filters === null || filters === void 0 ? void 0 : filters.text) {
+        conditions.push(`QueryText ILIKE '%${filters.text}%'`);
+    }
+    return conditions.join(' AND ');
+}

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

@@ -0,0 +1,23 @@
+import type { Reducer } from 'redux';
+import type { ExplainQueryAction, ExplainQueryState, PreparedExplainResponse } from '../../types/store/explainQuery';
+import type { QueryRequestParams, QueryMode } from '../../types/store/query';
+export declare const GET_EXPLAIN_QUERY: {
+    readonly REQUEST: "query/GET_EXPLAIN_QUERY_REQUEST";
+    readonly SUCCESS: "query/GET_EXPLAIN_QUERY_SUCCESS";
+    readonly FAILURE: "query/GET_EXPLAIN_QUERY_FAILURE";
+};
+export declare const GET_EXPLAIN_QUERY_AST: {
+    readonly REQUEST: "query/GET_EXPLAIN_QUERY_AST_REQUEST";
+    readonly SUCCESS: "query/GET_EXPLAIN_QUERY_AST_SUCCESS";
+    readonly FAILURE: "query/GET_EXPLAIN_QUERY_AST_FAILURE";
+};
+declare const explainQuery: Reducer<ExplainQueryState, ExplainQueryAction>;
+export declare const getExplainQueryAst: ({ query, database }: QueryRequestParams) => (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<import("../../types/store/query").IQueryResult | undefined>;
+export declare const explainVersions: {
+    v2: string;
+};
+interface ExplainQueryParams extends QueryRequestParams {
+    mode?: QueryMode;
+}
+export declare const getExplainQuery: ({ query, database, mode }: ExplainQueryParams) => (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<PreparedExplainResponse | undefined>;
+export default explainQuery;

package/dist/store/reducers/explainQuery.js

@@ -0,0 +1,94 @@
+import { preparePlan } from '../../utils/prepareQueryExplain';
+import { QUERY_SYNTAX, parseQueryAPIExplainResponse, parseQueryExplainPlan } from '../../utils/query';
+import { parseQueryError } from '../../utils/error';
+import { createRequestActionTypes, createApiRequest } from '../utils';
+export const GET_EXPLAIN_QUERY = createRequestActionTypes('query', 'GET_EXPLAIN_QUERY');
+export const GET_EXPLAIN_QUERY_AST = createRequestActionTypes('query', 'GET_EXPLAIN_QUERY_AST');
+const initialState = {
+    loading: false,
+};
+const explainQuery = (state = initialState, action) => {
+    switch (action.type) {
+        case GET_EXPLAIN_QUERY.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true, data: undefined, error: undefined, dataAst: undefined, errorAst: undefined });
+        }
+        case GET_EXPLAIN_QUERY.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { data: action.data.plan, dataAst: action.data.ast, loading: false, error: undefined });
+        }
+        case GET_EXPLAIN_QUERY.FAILURE: {
+            return Object.assign(Object.assign({}, state), { error: parseQueryError(action.error), loading: false });
+        }
+        case GET_EXPLAIN_QUERY_AST.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loadingAst: true, dataAst: undefined, errorAst: undefined });
+        }
+        case GET_EXPLAIN_QUERY_AST.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { dataAst: action.data.ast, loadingAst: false, error: undefined });
+        }
+        case GET_EXPLAIN_QUERY_AST.FAILURE: {
+            return Object.assign(Object.assign({}, state), { errorAst: parseQueryError(action.error), loadingAst: false });
+        }
+        default:
+            return state;
+    }
+};
+export const getExplainQueryAst = ({ query, database }) => {
+    return createApiRequest({
+        request: window.api.getExplainQueryAst(query, database),
+        actions: GET_EXPLAIN_QUERY_AST,
+        dataHandler: parseQueryAPIExplainResponse,
+    });
+};
+export const explainVersions = {
+    v2: '0.2',
+};
+const supportedExplainQueryVersions = Object.values(explainVersions);
+export const getExplainQuery = ({ query, database, mode }) => {
+    let action = 'explain';
+    let syntax = QUERY_SYNTAX.yql;
+    if (mode === 'pg') {
+        action = 'explain-query';
+        syntax = QUERY_SYNTAX.pg;
+    }
+    else if (mode) {
+        action = `explain-${mode}`;
+    }
+    return createApiRequest({
+        request: window.api.getExplainQuery(query, database, action, syntax),
+        actions: GET_EXPLAIN_QUERY,
+        dataHandler: (response) => {
+            const { plan: rawPlan, ast } = parseQueryAPIExplainResponse(response);
+            if (!rawPlan) {
+                return { ast };
+            }
+            const { tables, meta, Plan } = parseQueryExplainPlan(rawPlan);
+            if (supportedExplainQueryVersions.indexOf(meta.version) === -1) {
+                // Do not prepare plan for not supported versions
+                return {
+                    plan: {
+                        pristine: rawPlan,
+                        version: meta.version,
+                    },
+                    ast,
+                };
+            }
+            let links = [];
+            let nodes = [];
+            if (Plan) {
+                const preparedPlan = preparePlan(Plan);
+                links = preparedPlan.links;
+                nodes = preparedPlan.nodes;
+            }
+            return {
+                plan: {
+                    links,
+                    nodes,
+                    tables,
+                    version: meta.version,
+                    pristine: rawPlan,
+                },
+                ast,
+            };
+        },
+    });
+};
+export default explainQuery;

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

@@ -0,0 +1,8 @@
+declare const fullscreen: (state: boolean | undefined, action: ReturnType<typeof enableFullscreen> | ReturnType<typeof disableFullscreen>) => boolean;
+export declare function enableFullscreen(): {
+    readonly type: "ENABLE_FULLSCREEN_MODE";
+};
+export declare function disableFullscreen(): {
+    readonly type: "DISABLE_FULLSCREEN_MODE";
+};
+export default fullscreen;

package/dist/store/reducers/fullscreen.js

@@ -0,0 +1,24 @@
+const ENABLE_FULLSCREEN_MODE = 'ENABLE_FULLSCREEN_MODE';
+const DISABLE_FULLSCREEN_MODE = 'DISABLE_FULLSCREEN_MODE';
+const initialState = false;
+const fullscreen = function (state = initialState, action) {
+    switch (action.type) {
+        case DISABLE_FULLSCREEN_MODE:
+            return false;
+        case ENABLE_FULLSCREEN_MODE:
+            return true;
+        default:
+            return state;
+    }
+};
+export function enableFullscreen() {
+    return {
+        type: ENABLE_FULLSCREEN_MODE,
+    };
+}
+export function disableFullscreen() {
+    return {
+        type: DISABLE_FULLSCREEN_MODE,
+    };
+}
+export default fullscreen;

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

@@ -0,0 +1,9 @@
+import type { Reducer } from 'redux';
+import type { HeaderAction, HeaderState, Page, PageBreadcrumbsOptions } from './types';
+declare const header: Reducer<HeaderState, HeaderAction>;
+export declare function setHeaderBreadcrumbs<T extends Page>(page: T, options: PageBreadcrumbsOptions<T>): {
+    readonly type: "header/SET_HEADER_BREADCRUMBS";
+    readonly page: T;
+    readonly options: PageBreadcrumbsOptions<T>;
+};
+export default header;

package/dist/store/reducers/header/header.js

@@ -0,0 +1,23 @@
+const SET_HEADER_BREADCRUMBS = 'header/SET_HEADER_BREADCRUMBS';
+const initialState = {
+    pageBreadcrumbsOptions: {},
+};
+const header = (state = initialState, action) => {
+    switch (action.type) {
+        case SET_HEADER_BREADCRUMBS:
+            return {
+                page: action.page,
+                pageBreadcrumbsOptions: action.options,
+            };
+        default:
+            return state;
+    }
+};
+export function setHeaderBreadcrumbs(page, options) {
+    return {
+        type: SET_HEADER_BREADCRUMBS,
+        page,
+        options,
+    };
+}
+export default header;

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

@@ -0,0 +1,28 @@
+import type { ClusterTab } from '../../../containers/Cluster/utils';
+import type { EType } from '../../../types/api/tablet';
+import { setHeaderBreadcrumbs } from './header';
+export declare type Page = 'cluster' | 'tenant' | 'node' | 'tablets' | 'tablet' | undefined;
+export interface ClusterBreadcrumbsOptions {
+    clusterName?: string;
+    clusterTab?: ClusterTab;
+}
+export interface TenantBreadcrumbsOptions extends ClusterBreadcrumbsOptions {
+    tenantName?: string;
+}
+export interface NodeBreadcrumbsOptions extends TenantBreadcrumbsOptions {
+    nodeId?: string | number;
+}
+export interface TabletsBreadcrumbsOptions extends TenantBreadcrumbsOptions {
+    nodeIds?: string[] | number[];
+}
+export interface TabletBreadcrumbsOptions extends TabletsBreadcrumbsOptions {
+    tabletId?: string;
+    tabletType?: EType;
+}
+export declare type BreadcrumbsOptions = ClusterBreadcrumbsOptions | TenantBreadcrumbsOptions | NodeBreadcrumbsOptions | TabletsBreadcrumbsOptions | TabletBreadcrumbsOptions;
+export declare type PageBreadcrumbsOptions<T extends Page = undefined> = T extends 'cluster' ? ClusterBreadcrumbsOptions : T extends 'tenant' ? TenantBreadcrumbsOptions : T extends 'node' ? NodeBreadcrumbsOptions : T extends 'tablets' ? TabletsBreadcrumbsOptions : T extends 'tablet' ? TabletBreadcrumbsOptions : {};
+export interface HeaderState {
+    page?: Page;
+    pageBreadcrumbsOptions: BreadcrumbsOptions;
+}
+export declare type HeaderAction = ReturnType<typeof setHeaderBreadcrumbs>;

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

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

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

@@ -0,0 +1,21 @@
+import { Selector } from 'reselect';
+import { Reducer } from 'redux';
+import type { IHealthCheckInfoAction, IHealthcheckInfoRootStateSlice, IHealthcheckInfoState, IIssuesTree } from '../../types/store/healthcheck';
+import type { IssueLog, StatusFlag } from '../../types/api/healthcheck';
+export declare const FETCH_HEALTHCHECK: {
+    readonly REQUEST: "cluster/FETCH_HEALTHCHECK_REQUEST";
+    readonly SUCCESS: "cluster/FETCH_HEALTHCHECK_SUCCESS";
+    readonly FAILURE: "cluster/FETCH_HEALTHCHECK_FAILURE";
+};
+declare const healthcheckInfo: Reducer<IHealthcheckInfoState, IHealthCheckInfoAction>;
+export declare const selectIssuesTreesRoots: Selector<IHealthcheckInfoRootStateSlice, IssueLog[]>;
+export declare const selectIssuesTrees: Selector<IHealthcheckInfoRootStateSlice, IIssuesTree[]>;
+export declare const selectIssuesStatistics: Selector<IHealthcheckInfoRootStateSlice, [
+    StatusFlag,
+    number
+][]>;
+export declare function getHealthcheckInfo(database: string): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<unknown>;
+export declare const setDataWasNotLoaded: () => {
+    readonly type: "healthcheckInfo/SET_DATA_WAS_NOT_LOADED";
+};
+export default healthcheckInfo;

package/dist/store/reducers/healthcheckInfo.js

@@ -0,0 +1,93 @@
+import { createSelector } from 'reselect';
+import { createRequestActionTypes, createApiRequest } from '../utils';
+export const FETCH_HEALTHCHECK = createRequestActionTypes('cluster', 'FETCH_HEALTHCHECK');
+const SET_DATA_WAS_NOT_LOADED = 'healthcheckInfo/SET_DATA_WAS_NOT_LOADED';
+const initialState = { loading: false, wasLoaded: false };
+const healthcheckInfo = function (state = initialState, action) {
+    var _a;
+    switch (action.type) {
+        case FETCH_HEALTHCHECK.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_HEALTHCHECK.SUCCESS: {
+            const { data } = action;
+            return Object.assign(Object.assign({}, state), { data, wasLoaded: true, loading: false, error: undefined });
+        }
+        case FETCH_HEALTHCHECK.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, data: undefined });
+        }
+        case SET_DATA_WAS_NOT_LOADED: {
+            return Object.assign(Object.assign({}, state), { wasLoaded: false });
+        }
+        default:
+            return state;
+    }
+};
+const mapStatusToPriority = {
+    RED: 0,
+    ORANGE: 1,
+    YELLOW: 2,
+    BLUE: 3,
+    GREEN: 4,
+};
+const sortIssues = (data) => {
+    return data.sort((a, b) => {
+        const aPriority = mapStatusToPriority[a.status] || 0;
+        const bPriority = mapStatusToPriority[b.status] || 0;
+        return aPriority - bPriority;
+    });
+};
+const getReasonsForIssue = ({ issue, data }) => {
+    return sortIssues(data.filter((item) => issue.reason && issue.reason.indexOf(item.id) !== -1));
+};
+const getRoots = (data) => {
+    return sortIssues(data.filter((item) => {
+        return !data.find((issue) => issue.reason && issue.reason.indexOf(item.id) !== -1);
+    }));
+};
+const getInvertedConsequencesTree = ({ data, roots, }) => {
+    return roots
+        ? roots.map((issue) => {
+            const reasonsItems = getInvertedConsequencesTree({
+                roots: getReasonsForIssue({ issue, data }),
+                data,
+            });
+            return Object.assign(Object.assign({}, issue), { reasonsItems });
+        })
+        : [];
+};
+const getIssuesStatistics = (data) => {
+    const issuesMap = {};
+    for (const issue of data) {
+        if (!issuesMap[issue.status]) {
+            issuesMap[issue.status] = 0;
+        }
+        issuesMap[issue.status]++;
+    }
+    return Object.entries(issuesMap).sort(([aStatus], [bStatus]) => {
+        const bPriority = mapStatusToPriority[bStatus] || 0;
+        const aPriority = mapStatusToPriority[aStatus] || 0;
+        return aPriority - bPriority;
+    });
+};
+const getIssuesLog = (state) => { var _a; return (_a = state.healthcheckInfo.data) === null || _a === void 0 ? void 0 : _a.issue_log; };
+export const selectIssuesTreesRoots = createSelector(getIssuesLog, (issues = []) => getRoots(issues));
+export const selectIssuesTrees = createSelector([getIssuesLog, selectIssuesTreesRoots], (data = [], roots = []) => {
+    return getInvertedConsequencesTree({ data, roots });
+});
+export const selectIssuesStatistics = createSelector(getIssuesLog, (issues = []) => getIssuesStatistics(issues));
+export function getHealthcheckInfo(database) {
+    return createApiRequest({
+        request: window.api.getHealthcheckInfo(database, { concurrentId: 'getHealthcheckInfo' }),
+        actions: FETCH_HEALTHCHECK,
+    });
+}
+export const setDataWasNotLoaded = () => {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    };
+};
+export default healthcheckInfo;

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

@@ -0,0 +1,27 @@
+import type { Reducer } from 'redux';
+import type { IHeatmapAction, IHeatmapApiRequestParams, IHeatmapState, IHeatmapTabletData } from '../../types/store/heatmap';
+export declare const FETCH_HEATMAP: {
+    readonly REQUEST: "heatmap/FETCH_HEATMAP_REQUEST";
+    readonly SUCCESS: "heatmap/FETCH_HEATMAP_SUCCESS";
+    readonly FAILURE: "heatmap/FETCH_HEATMAP_FAILURE";
+};
+export declare const initialState: {
+    loading: boolean;
+    wasLoaded: boolean;
+    currentMetric: undefined;
+    sort: boolean;
+    heatmap: boolean;
+};
+declare const heatmap: Reducer<IHeatmapState, IHeatmapAction>;
+export declare function getTabletsInfo({ nodes, path }: IHeatmapApiRequestParams): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<{
+    data: IHeatmapTabletData[];
+    metrics: {
+        value: string;
+        content: string;
+    }[] | undefined;
+} | undefined>;
+export declare function setHeatmapOptions(options: Partial<IHeatmapState>): {
+    readonly type: "heatmap/SET_HEATMAP_OPTIONS";
+    readonly data: Partial<IHeatmapState>;
+};
+export default heatmap;

package/dist/store/reducers/heatmap.js

@@ -0,0 +1,70 @@
+import { createRequestActionTypes, createApiRequest } from '../utils';
+export const FETCH_HEATMAP = createRequestActionTypes('heatmap', 'FETCH_HEATMAP');
+const SET_HEATMAP_OPTIONS = 'heatmap/SET_HEATMAP_OPTIONS';
+export const initialState = {
+    loading: false,
+    wasLoaded: false,
+    currentMetric: undefined,
+    sort: false,
+    heatmap: false,
+};
+const heatmap = (state = initialState, action) => {
+    switch (action.type) {
+        case FETCH_HEATMAP.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_HEATMAP.SUCCESS: {
+            return Object.assign(Object.assign(Object.assign({}, state), action.data), { loading: false, wasLoaded: true, error: undefined });
+        }
+        case FETCH_HEATMAP.FAILURE: {
+            return Object.assign(Object.assign({}, state), { error: action.error, loading: false, wasLoaded: false });
+        }
+        case SET_HEATMAP_OPTIONS:
+            return Object.assign(Object.assign({}, state), action.data);
+        default:
+            return state;
+    }
+};
+export function getTabletsInfo({ nodes, path }) {
+    return createApiRequest({
+        request: Promise.all([
+            window.api.getTabletsInfo({ nodes, path }),
+            window.api.getHeatmapData({ path }),
+        ]),
+        actions: FETCH_HEATMAP,
+        dataHandler: ([tabletsData = {}, describe = {}]) => {
+            const { TabletStateInfo: tablets = [] } = tabletsData;
+            const TabletsMap = new Map();
+            const { PathDescription = {} } = describe;
+            const { TablePartitions = [], TablePartitionStats = [], TablePartitionMetrics = [], } = PathDescription;
+            tablets.forEach((item) => {
+                if (item.TabletId) {
+                    TabletsMap.set(item.TabletId, item);
+                }
+            });
+            TablePartitions.forEach((item, index) => {
+                const metrics = Object.assign({}, TablePartitionStats[index], TablePartitionMetrics[index]);
+                if (item.DatashardId) {
+                    TabletsMap.set(item.DatashardId, Object.assign(Object.assign({}, TabletsMap.get(item.DatashardId)), { metrics }));
+                }
+            });
+            const preparedTablets = Array.from(TabletsMap.values());
+            const selectMetrics = preparedTablets[0] &&
+                preparedTablets[0].metrics &&
+                Object.keys(preparedTablets[0].metrics).map((item) => {
+                    return {
+                        value: item,
+                        content: item,
+                    };
+                });
+            return { data: preparedTablets, metrics: selectMetrics };
+        },
+    });
+}
+export function setHeatmapOptions(options) {
+    return {
+        type: SET_HEATMAP_OPTIONS,
+        data: options,
+    };
+}
+export default heatmap;

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

@@ -0,0 +1,10 @@
+import type { Reducer } from 'redux';
+import type { IHostAction, IHostState } from '../../types/store/host';
+export declare const FETCH_HOST: {
+    readonly REQUEST: "host/FETCH_HOST_REQUEST";
+    readonly SUCCESS: "host/FETCH_HOST_SUCCESS";
+    readonly FAILURE: "host/FETCH_HOST_FAILURE";
+};
+declare const host: Reducer<IHostState, IHostAction>;
+export declare function getHostInfo(): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<unknown>;
+export default host;

package/dist/store/reducers/host.js

@@ -0,0 +1,26 @@
+import { createRequestActionTypes, createApiRequest } from '../utils';
+export const FETCH_HOST = createRequestActionTypes('host', 'FETCH_HOST');
+const initialState = { loading: true, wasLoaded: false, data: {} };
+const host = (state = initialState, action) => {
+    var _a;
+    switch (action.type) {
+        case FETCH_HOST.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_HOST.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { data: (_a = action.data.SystemStateInfo) === null || _a === void 0 ? void 0 : _a[0], loading: false, wasLoaded: true, error: undefined });
+        }
+        case FETCH_HOST.FAILURE: {
+            return Object.assign(Object.assign({}, state), { error: action.error, loading: false });
+        }
+        default:
+            return state;
+    }
+};
+export function getHostInfo() {
+    return createApiRequest({
+        request: window.api.getHostInfo(),
+        actions: FETCH_HOST,
+    });
+}
+export default host;

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

@@ -0,0 +1,25 @@
+import type { Reducer } from 'redux';
+import type { JsonHotKeysResponse } from '../../../types/api/hotkeys';
+import type { IResponseError } from '../../../types/api/error';
+import type { HotKeysAction, HotKeysState } from './types';
+export declare const FETCH_HOT_KEYS: {
+    readonly REQUEST: "hot_keys/FETCH_HOT_KEYS_REQUEST";
+    readonly SUCCESS: "hot_keys/FETCH_HOT_KEYS_SUCCESS";
+    readonly FAILURE: "hot_keys/FETCH_HOT_KEYS_FAILURE";
+};
+declare const hotKeys: Reducer<HotKeysState, HotKeysAction>;
+export declare function setHotKeysDataWasNotLoaded(): {
+    readonly type: "hot_keys/SET_DATA_WAS_NOT_LOADED";
+};
+export declare function setHotKeysLoading(): {
+    readonly type: "hot_keys/FETCH_HOT_KEYS_REQUEST";
+};
+export declare function setHotKeysData(data: JsonHotKeysResponse): {
+    readonly type: "hot_keys/FETCH_HOT_KEYS_SUCCESS";
+    readonly data: JsonHotKeysResponse;
+};
+export declare function setHotKeysError(error: IResponseError): {
+    readonly type: "hot_keys/FETCH_HOT_KEYS_FAILURE";
+    readonly error: IResponseError<unknown>;
+};
+export default hotKeys;

package/dist/store/reducers/hotKeys/hotKeys.js

@@ -0,0 +1,49 @@
+import { createRequestActionTypes } from '../../utils';
+export const FETCH_HOT_KEYS = createRequestActionTypes('hot_keys', 'FETCH_HOT_KEYS');
+const SET_DATA_WAS_NOT_LOADED = 'hot_keys/SET_DATA_WAS_NOT_LOADED';
+const initialState = { loading: true, wasLoaded: false, data: null };
+const hotKeys = (state = initialState, action) => {
+    var _a;
+    switch (action.type) {
+        case FETCH_HOT_KEYS.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_HOT_KEYS.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { data: action.data.hotkeys, loading: false, error: undefined, wasLoaded: true });
+        }
+        case FETCH_HOT_KEYS.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_DATA_WAS_NOT_LOADED: {
+            return Object.assign(Object.assign({}, state), { wasLoaded: false });
+        }
+        default:
+            return state;
+    }
+};
+export function setHotKeysDataWasNotLoaded() {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    };
+}
+export function setHotKeysLoading() {
+    return {
+        type: FETCH_HOT_KEYS.REQUEST,
+    };
+}
+export function setHotKeysData(data) {
+    return {
+        type: FETCH_HOT_KEYS.SUCCESS,
+        data: data,
+    };
+}
+export function setHotKeysError(error) {
+    return {
+        type: FETCH_HOT_KEYS.FAILURE,
+        error: error,
+    };
+}
+export default hotKeys;

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

@@ -0,0 +1,10 @@
+import type { IResponseError } from '../../../types/api/error';
+import type { HotKey } from '../../../types/api/hotkeys';
+import type { setHotKeysData, setHotKeysDataWasNotLoaded, setHotKeysError, setHotKeysLoading } from './hotKeys';
+export interface HotKeysState {
+    loading: boolean;
+    wasLoaded: boolean;
+    data: null | HotKey[];
+    error?: IResponseError;
+}
+export declare type HotKeysAction = ReturnType<typeof setHotKeysDataWasNotLoaded> | ReturnType<typeof setHotKeysLoading> | ReturnType<typeof setHotKeysData> | ReturnType<typeof setHotKeysError>;

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

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