ydb-embedded-ui 4.33.0 → 5.0.0

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

@@ -0,0 +1,52 @@
+import type { Reducer } from 'redux';
+import type { TenantsAction, TenantsState } from './types';
+export declare const FETCH_TENANTS: {
+    readonly REQUEST: "tenants/FETCH_TENANTS_REQUEST";
+    readonly SUCCESS: "tenants/FETCH_TENANTS_SUCCESS";
+    readonly FAILURE: "tenants/FETCH_TENANTS_FAILURE";
+};
+declare const tenants: Reducer<TenantsState, TenantsAction>;
+export declare function getTenantsInfo(clusterName?: string): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("..").GetState) => Promise<{
+    backend: string | undefined;
+    sharedTenantName: string | undefined;
+    controlPlaneName: string;
+    cpu: number | undefined;
+    memory: number | undefined;
+    storage: number | undefined;
+    nodesCount: number;
+    groupsCount: number;
+    Name?: string | undefined;
+    Id?: string | undefined;
+    Type?: import("../../../types/api/tenant").ETenantType | undefined;
+    State?: import("../../../types/api/tenant").State | undefined;
+    StateStats?: import("../../../types/api/tenant").THiveDomainStatsStateCount[] | undefined;
+    Metrics?: import("../../../types/api/tenant").TMetrics | undefined;
+    NodeIds?: number[] | undefined;
+    AliveNodes?: number | undefined;
+    Resources?: import("../../../types/api/tenant").TTenantResources | undefined;
+    CreateTime?: string | undefined;
+    Owner?: string | undefined;
+    Users?: string[] | undefined;
+    PoolStats?: import("../../../types/api/nodes").TPoolStats[] | undefined;
+    UserAttributes?: Record<string, string> | undefined;
+    Overall?: import("../../../types/api/enums").EFlag | undefined;
+    SystemTablets?: import("../../../types/api/tablet").TTabletStateInfo[] | undefined;
+    ResourceId?: string | undefined;
+    Tablets?: import("../../../types/api/tablet").TTabletStateInfo[] | undefined;
+    StorageAllocatedSize?: string | undefined;
+    StorageMinAvailableSize?: string | undefined;
+    Nodes?: import("../../../types/api/nodes").TSystemStateInfo[] | undefined;
+    MemoryUsed?: string | undefined;
+    MemoryLimit?: string | undefined;
+    CoresUsed?: number | undefined;
+    StorageGroups?: string | undefined;
+    MonitoringEndpoint?: string | undefined;
+    ControlPlane?: import("../../../types/api/tenant").ControlPlane | undefined;
+    StorageAllocatedLimit?: string | undefined;
+    DatabaseQuotas?: import("../../../types/api/tenant").DatabaseQuotas | undefined;
+}[] | undefined>;
+export declare const setSearchValue: (value: string) => {
+    readonly type: "tenants/SET_SEARCH_VALUE";
+    readonly data: string;
+};
+export default tenants;

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

@@ -0,0 +1,43 @@
+import { createRequestActionTypes, createApiRequest } from '../../utils';
+import { prepareTenants } from './utils';
+export const FETCH_TENANTS = createRequestActionTypes('tenants', 'FETCH_TENANTS');
+const SET_SEARCH_VALUE = 'tenants/SET_SEARCH_VALUE';
+const initialState = { loading: true, wasLoaded: false, searchValue: '', tenants: [] };
+const tenants = (state = initialState, action) => {
+    switch (action.type) {
+        case FETCH_TENANTS.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_TENANTS.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { tenants: action.data, loading: false, wasLoaded: true, error: undefined });
+        }
+        case FETCH_TENANTS.FAILURE: {
+            return Object.assign(Object.assign({}, state), { error: action.error, loading: false });
+        }
+        case SET_SEARCH_VALUE: {
+            return Object.assign(Object.assign({}, state), { searchValue: action.data });
+        }
+        default:
+            return state;
+    }
+};
+export function getTenantsInfo(clusterName) {
+    return createApiRequest({
+        request: window.api.getTenants(clusterName),
+        actions: FETCH_TENANTS,
+        dataHandler: (response, getState) => {
+            const { singleClusterMode } = getState();
+            if (!response.TenantInfo) {
+                return [];
+            }
+            return prepareTenants(response.TenantInfo, singleClusterMode);
+        },
+    });
+}
+export const setSearchValue = (value) => {
+    return {
+        type: SET_SEARCH_VALUE,
+        data: value,
+    };
+};
+export default tenants;

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

@@ -0,0 +1,28 @@
+import { FETCH_TENANTS, setSearchValue } from './tenants';
+import { ValueOf } from '../../../types/common';
+import type { TTenant } from '../../../types/api/tenant';
+import type { IResponseError } from '../../../types/api/error';
+import type { ApiRequestAction } from '../../utils';
+import { METRIC_STATUS } from './contants';
+export interface PreparedTenant extends TTenant {
+    backend: string | undefined;
+    sharedTenantName: string | undefined;
+    controlPlaneName: string;
+    cpu: number;
+    memory: number;
+    storage: number;
+    nodesCount: number;
+    groupsCount: number;
+}
+export interface TenantsState {
+    loading: boolean;
+    wasLoaded: boolean;
+    searchValue: string;
+    tenants: PreparedTenant[];
+    error?: IResponseError;
+}
+export declare type TenantsAction = ApiRequestAction<typeof FETCH_TENANTS, PreparedTenant[], IResponseError> | ReturnType<typeof setSearchValue>;
+export interface TenantsStateSlice {
+    tenants: TenantsState;
+}
+export declare type MetricStatus = ValueOf<typeof METRIC_STATUS>;

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

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

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

@@ -0,0 +1,65 @@
+import type { TTenant } from '../../../types/api/tenant';
+export declare const calculateTenantMetrics: (tenant?: TTenant | undefined) => {
+    cpu: number | undefined;
+    memory: number | undefined;
+    blobStorage: number | undefined;
+    tableStorage: number | undefined;
+    cpuUsage: number | undefined;
+    memoryLimit: number | undefined;
+    blobStorageLimit: number | undefined;
+    tableStorageLimit: number | undefined;
+};
+export declare const prepareTenants: (tenants: TTenant[], useNodeAsBackend: boolean) => {
+    backend: string | undefined;
+    sharedTenantName: string | undefined;
+    controlPlaneName: string;
+    cpu: number | undefined;
+    memory: number | undefined;
+    storage: number | undefined;
+    nodesCount: number;
+    groupsCount: number;
+    Name?: string | undefined;
+    Id?: string | undefined;
+    Type?: import("../../../types/api/tenant").ETenantType | undefined;
+    State?: import("../../../types/api/tenant").State | undefined;
+    StateStats?: import("../../../types/api/tenant").THiveDomainStatsStateCount[] | undefined;
+    Metrics?: import("../../../types/api/tenant").TMetrics | undefined;
+    NodeIds?: number[] | undefined;
+    AliveNodes?: number | undefined;
+    Resources?: import("../../../types/api/tenant").TTenantResources | undefined;
+    CreateTime?: string | undefined;
+    Owner?: string | undefined;
+    Users?: string[] | undefined;
+    PoolStats?: import("../../../types/api/nodes").TPoolStats[] | undefined;
+    UserAttributes?: Record<string, string> | undefined;
+    Overall?: import("../../../types/api/enums").EFlag | undefined;
+    SystemTablets?: import("../../../types/api/tablet").TTabletStateInfo[] | undefined;
+    ResourceId?: string | undefined;
+    Tablets?: import("../../../types/api/tablet").TTabletStateInfo[] | undefined;
+    StorageAllocatedSize?: string | undefined;
+    StorageMinAvailableSize?: string | undefined;
+    Nodes?: import("../../../types/api/nodes").TSystemStateInfo[] | undefined;
+    MemoryUsed?: string | undefined;
+    MemoryLimit?: string | undefined;
+    CoresUsed?: number | undefined;
+    StorageGroups?: string | undefined;
+    MonitoringEndpoint?: string | undefined;
+    ControlPlane?: import("../../../types/api/tenant").ControlPlane | undefined;
+    StorageAllocatedLimit?: string | undefined;
+    DatabaseQuotas?: import("../../../types/api/tenant").DatabaseQuotas | undefined;
+}[];
+export declare const calculateUsage: (valueUsed?: number | undefined, valueLimit?: number | undefined) => number | undefined;
+export declare const formatUsage: (usage?: number | undefined) => string | undefined;
+export declare const cpuUsageToStatus: (usage?: number | undefined) => "Unspecified" | "Good" | "Warning" | "Danger";
+export declare const storageUsageToStatus: (usage?: number | undefined) => "Unspecified" | "Good" | "Warning" | "Danger";
+export declare const memoryUsageToStatus: (usage?: number | undefined) => "Unspecified" | "Good" | "Warning" | "Danger";
+export declare const formatTenantMetrics: ({ cpu, storage, memory, }: {
+    cpu?: number | undefined;
+    storage?: number | undefined;
+    memory?: number | undefined;
+}) => {
+    cpu: string | undefined;
+    storage: string | undefined;
+    memory: string | undefined;
+};
+export declare const normalizeProgress: (progress: number) => number;

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

@@ -0,0 +1,136 @@
+import { formatBytes } from '../../../utils/bytesParsers';
+import { formatCPUWithLabel } from '../../../utils/dataFormatters/dataFormatters';
+import { isNumeric } from '../../../utils/utils';
+import { METRIC_STATUS } from './contants';
+const getControlPlaneValue = (tenant) => {
+    var _a, _b;
+    const parts = (_a = tenant.Name) === null || _a === void 0 ? void 0 : _a.split('/');
+    const defaultValue = (parts === null || parts === void 0 ? void 0 : parts.length) ? parts[parts.length - 1] : '—';
+    const controlPlaneName = (_b = tenant.ControlPlane) === null || _b === void 0 ? void 0 : _b.name;
+    return controlPlaneName !== null && controlPlaneName !== void 0 ? controlPlaneName : defaultValue;
+};
+const getTenantBackend = (tenant) => {
+    var _a;
+    const node = tenant.Nodes ? tenant.Nodes[0] : {};
+    const address = node.Host && node.Endpoints
+        ? (_a = node.Endpoints.find((endpoint) => endpoint.Name === 'http-mon')) === null || _a === void 0 ? void 0 : _a.Address
+        : undefined;
+    return node.Host ? `${node.Host}${address ? address : ''}` : undefined;
+};
+export const calculateTenantMetrics = (tenant) => {
+    var _a, _b;
+    const { CoresUsed, MemoryUsed, StorageAllocatedSize, MemoryLimit, StorageAllocatedLimit, PoolStats, Metrics = {}, DatabaseQuotas = {}, } = tenant || {};
+    const systemPoolUsage = (_a = PoolStats === null || PoolStats === void 0 ? void 0 : PoolStats.find(({ Name }) => Name === 'System')) === null || _a === void 0 ? void 0 : _a.Usage;
+    const userPoolUsage = (_b = PoolStats === null || PoolStats === void 0 ? void 0 : PoolStats.find(({ Name }) => Name === 'User')) === null || _b === void 0 ? void 0 : _b.Usage;
+    const cpu = isNumeric(CoresUsed) ? Number(CoresUsed) * 1000000 : undefined;
+    const memory = isNumeric(MemoryUsed) ? Number(MemoryUsed) : undefined;
+    const blobStorage = isNumeric(StorageAllocatedSize) ? Number(StorageAllocatedSize) : undefined;
+    const tableStorage = isNumeric(Metrics.Storage) ? Number(Metrics.Storage) : undefined;
+    // We use system pool usage and user pool usage to calculate cpu usage because
+    // only these pools directly indicate resources available to perform user queries
+    const cpuUsage = isNumeric(systemPoolUsage) || isNumeric(userPoolUsage)
+        ? Math.max(Number(systemPoolUsage), Number(userPoolUsage)) * 100
+        : undefined;
+    const memoryLimit = isNumeric(MemoryLimit) ? Number(MemoryLimit) : undefined;
+    const blobStorageLimit = isNumeric(StorageAllocatedLimit)
+        ? Number(StorageAllocatedLimit)
+        : undefined;
+    const tableStorageLimit = isNumeric(DatabaseQuotas.data_size_hard_quota)
+        ? Number(DatabaseQuotas.data_size_hard_quota)
+        : undefined;
+    return {
+        cpu,
+        memory,
+        blobStorage,
+        tableStorage,
+        cpuUsage,
+        memoryLimit,
+        blobStorageLimit,
+        tableStorageLimit,
+    };
+};
+const calculateTenantEntities = (tenant) => {
+    var _a;
+    const { StorageGroups, NodeIds } = tenant;
+    const nodesCount = (_a = NodeIds === null || NodeIds === void 0 ? void 0 : NodeIds.length) !== null && _a !== void 0 ? _a : 0;
+    const groupsCount = isNumeric(StorageGroups) ? Number(StorageGroups) : 0;
+    return { nodesCount, groupsCount };
+};
+export const prepareTenants = (tenants, useNodeAsBackend) => {
+    return tenants.map((tenant) => {
+        var _a;
+        const backend = useNodeAsBackend ? getTenantBackend(tenant) : undefined;
+        const sharedTenantName = (_a = tenants.find((item) => item.Id === tenant.ResourceId)) === null || _a === void 0 ? void 0 : _a.Name;
+        const controlPlaneName = getControlPlaneValue(tenant);
+        const { cpu, memory, blobStorage } = calculateTenantMetrics(tenant);
+        const { nodesCount, groupsCount } = calculateTenantEntities(tenant);
+        return Object.assign(Object.assign({}, tenant), { backend,
+            sharedTenantName,
+            controlPlaneName,
+            cpu,
+            memory, storage: blobStorage, nodesCount,
+            groupsCount });
+    });
+};
+export const calculateUsage = (valueUsed, valueLimit) => {
+    if (valueUsed && valueLimit) {
+        return (valueUsed * 100) / valueLimit;
+    }
+    return undefined;
+};
+export const formatUsage = (usage) => {
+    if (usage) {
+        return `${usage.toFixed()}%`;
+    }
+    return undefined;
+};
+export const cpuUsageToStatus = (usage) => {
+    if (!usage) {
+        return METRIC_STATUS.Unspecified;
+    }
+    if (usage > 70) {
+        return METRIC_STATUS.Danger;
+    }
+    if (usage > 60) {
+        return METRIC_STATUS.Warning;
+    }
+    return METRIC_STATUS.Good;
+};
+export const storageUsageToStatus = (usage) => {
+    if (!usage) {
+        return METRIC_STATUS.Unspecified;
+    }
+    if (usage > 85) {
+        return METRIC_STATUS.Danger;
+    }
+    if (usage > 75) {
+        return METRIC_STATUS.Warning;
+    }
+    return METRIC_STATUS.Good;
+};
+export const memoryUsageToStatus = (usage) => {
+    if (!usage) {
+        return METRIC_STATUS.Unspecified;
+    }
+    if (usage > 70) {
+        return METRIC_STATUS.Danger;
+    }
+    if (usage > 60) {
+        return METRIC_STATUS.Warning;
+    }
+    return METRIC_STATUS.Good;
+};
+export const formatTenantMetrics = ({ cpu, storage, memory, }) => ({
+    cpu: formatCPUWithLabel(cpu),
+    storage: formatBytes({ value: storage, significantDigits: 2 }) || undefined,
+    memory: formatBytes({ value: memory, significantDigits: 2 }) || undefined,
+});
+export const normalizeProgress = (progress) => {
+    if (progress >= 100) {
+        return 100;
+    }
+    if (progress <= 0) {
+        return 0;
+    }
+    return progress;
+};

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

@@ -0,0 +1,15 @@
+import type { Reducer } from 'redux';
+import { ITooltipAction, ITooltipPositions, ITooltipState, ITooltipTemplateType } from '../../types/store/tooltip';
+declare const tooltip: Reducer<ITooltipState, ITooltipAction>;
+export declare const hideTooltip: () => {
+    readonly type: "tooltip/HIDE_TOOLTIP";
+};
+export declare const showTooltip: (node: EventTarget | null, data: any, templateType: ITooltipTemplateType, additionalData?: any, positions?: ITooltipPositions | undefined) => {
+    type: string;
+    node: EventTarget | null;
+    data: any;
+    templateType: "node" | "pool" | "tablet" | "nodeEndpoints" | "tabletsOverall" | "histogram" | "cell" | "json";
+    additionalData: any;
+    positions: ITooltipPositions | undefined;
+};
+export default tooltip;

package/dist/store/reducers/tooltip.js

@@ -0,0 +1,41 @@
+import isEqual from 'lodash/isEqual';
+import { tooltipTemplates } from '../../utils/tooltip';
+const HIDE_TOOLTIP = 'tooltip/HIDE_TOOLTIP';
+const UPDATE_REF = 'tooltip/UPDATE_REF';
+const initialState = {
+    toolTipVisible: false,
+    currentHoveredRef: undefined,
+    data: undefined,
+    templateType: 'pool',
+    template: tooltipTemplates['pool'],
+};
+const tooltip = (state = initialState, action) => {
+    switch (action.type) {
+        case HIDE_TOOLTIP: {
+            return Object.assign(Object.assign({}, state), { currentHoveredRef: undefined, toolTipVisible: false });
+        }
+        case UPDATE_REF: {
+            if (action.templateType === 'cell' && isEqual(action.node, state.currentHoveredRef)) {
+                return Object.assign(Object.assign({}, state), { currentHoveredRef: undefined, toolTipVisible: false });
+            }
+            return Object.assign(Object.assign({}, state), { toolTipVisible: true, currentHoveredRef: action.node, positions: action.positions, data: action.data, additionalData: action.additionalData, templateType: action.templateType, template: tooltipTemplates[action.templateType] });
+        }
+        default: {
+            return state;
+        }
+    }
+};
+export const hideTooltip = () => {
+    return { type: HIDE_TOOLTIP };
+};
+export const showTooltip = (node, data, templateType, additionalData, positions) => {
+    return {
+        type: UPDATE_REF,
+        node,
+        data,
+        templateType,
+        additionalData,
+        positions,
+    };
+};
+export default tooltip;

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

@@ -0,0 +1,20 @@
+import type { Reducer } from 'redux';
+import { Selector } from 'reselect';
+import type { IPreparedConsumerData, IPreparedTopicStats, ITopicAction, ITopicRootStateSlice, ITopicState } from '../../types/store/topic';
+export declare const FETCH_TOPIC: {
+    readonly REQUEST: "topic/FETCH_TOPIC_REQUEST";
+    readonly SUCCESS: "topic/FETCH_TOPIC_SUCCESS";
+    readonly FAILURE: "topic/FETCH_TOPIC_FAILURE";
+};
+declare const topic: Reducer<ITopicState, ITopicAction>;
+export declare const setDataWasNotLoaded: () => {
+    readonly type: "topic/SET_DATA_WAS_NOT_LOADED";
+};
+export declare const cleanTopicData: () => {
+    readonly type: "topic/CLEAN_TOPIC_DATA";
+};
+export declare function getTopic(path?: string): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<unknown>;
+export declare const selectConsumersNames: Selector<ITopicRootStateSlice, string[] | undefined>;
+export declare const selectPreparedTopicStats: Selector<ITopicRootStateSlice, IPreparedTopicStats | undefined>;
+export declare const selectPreparedConsumersData: Selector<ITopicRootStateSlice, IPreparedConsumerData[] | undefined>;
+export default topic;

package/dist/store/reducers/topic.js

@@ -0,0 +1,88 @@
+import { createSelector } from 'reselect';
+import { createRequestActionTypes, createApiRequest } from '../utils';
+import { parseLag, parseTimestampToIdleTime } from '../../utils/timeParsers';
+import { convertBytesObjectToSpeed } from '../../utils/bytesParsers';
+export const FETCH_TOPIC = createRequestActionTypes('topic', 'FETCH_TOPIC');
+const SET_DATA_WAS_NOT_LOADED = 'topic/SET_DATA_WAS_NOT_LOADED';
+const CLEAN_TOPIC_DATA = 'topic/CLEAN_TOPIC_DATA';
+const initialState = {
+    loading: true,
+    wasLoaded: false,
+    data: undefined,
+};
+const topic = (state = initialState, action) => {
+    var _a;
+    switch (action.type) {
+        case FETCH_TOPIC.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_TOPIC.SUCCESS: {
+            // On older version it can return HTML page of Developer UI with an error
+            if (typeof action.data !== 'object') {
+                return Object.assign(Object.assign({}, state), { loading: false, error: {} });
+            }
+            return Object.assign(Object.assign({}, state), { data: action.data, loading: false, wasLoaded: true, error: undefined });
+        }
+        case FETCH_TOPIC.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 });
+        }
+        case CLEAN_TOPIC_DATA: {
+            return Object.assign(Object.assign({}, state), { data: undefined });
+        }
+        default:
+            return state;
+    }
+};
+export const setDataWasNotLoaded = () => {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    };
+};
+export const cleanTopicData = () => {
+    return {
+        type: CLEAN_TOPIC_DATA,
+    };
+};
+export function getTopic(path) {
+    return createApiRequest({
+        request: window.api.getTopic({ path }),
+        actions: FETCH_TOPIC,
+    });
+}
+const selectTopicStats = (state) => { var _a; return (_a = state.topic.data) === null || _a === void 0 ? void 0 : _a.topic_stats; };
+const selectConsumers = (state) => { var _a; return (_a = state.topic.data) === null || _a === void 0 ? void 0 : _a.consumers; };
+export const selectConsumersNames = createSelector([selectConsumers], (consumers) => {
+    return consumers === null || consumers === void 0 ? void 0 : consumers.map((consumer) => consumer === null || consumer === void 0 ? void 0 : consumer.name).filter((consumer) => consumer !== undefined);
+});
+export const selectPreparedTopicStats = createSelector([selectTopicStats], (rawTopicStats) => {
+    if (!rawTopicStats) {
+        return undefined;
+    }
+    const { store_size_bytes = '0', min_last_write_time, max_write_time_lag, bytes_written, } = rawTopicStats || {};
+    return {
+        storeSize: store_size_bytes,
+        partitionsIdleTime: parseTimestampToIdleTime(min_last_write_time),
+        partitionsWriteLag: parseLag(max_write_time_lag),
+        writeSpeed: convertBytesObjectToSpeed(bytes_written),
+    };
+});
+export const selectPreparedConsumersData = createSelector([selectConsumers], (consumers) => {
+    return consumers === null || consumers === void 0 ? void 0 : consumers.map((consumer) => {
+        const { name, consumer_stats } = consumer || {};
+        const { min_partitions_last_read_time, max_read_time_lag, max_write_time_lag, bytes_read } = consumer_stats || {};
+        return {
+            name,
+            readSpeed: convertBytesObjectToSpeed(bytes_read),
+            writeLag: parseLag(max_write_time_lag),
+            readLag: parseLag(max_read_time_lag),
+            readIdleTime: parseTimestampToIdleTime(min_partitions_last_read_time),
+        };
+    });
+});
+export default topic;

package/dist/store/state-url-mapping.d.ts

@@ -0,0 +1,4 @@
+export default function getLocationMiddleware(history: any, rootReducer: any): {
+    locationMiddleware: any;
+    reducersWithLocation: (state: any, action: any) => any;
+};

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

@@ -1,14 +1,23 @@
-import {createReduxLocationActions} from 'redux-location-state';
+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 { createReduxLocationActions } from 'redux-location-state';
 import qs from 'qs';
 import _ from 'lodash';
-import {stateToParams} from 'redux-location-state/lib/stateToParams';
-import {parseQuery} from 'redux-location-state/lib/parseQuery';
-import {LOCATION_PUSH, LOCATION_POP} from 'redux-location-state/lib/constants';
-import {getMatchingDeclaredPath} from 'redux-location-state/lib/helpers';
-
-import {initialState as initialSettingsState} from './reducers/settings/settings';
-import {initialState as initialHeatmapState} from './reducers/heatmap';
-
+import { stateToParams } from 'redux-location-state/lib/stateToParams';
+import { parseQuery } from 'redux-location-state/lib/parseQuery';
+import { LOCATION_PUSH, LOCATION_POP } from 'redux-location-state/lib/constants';
+import { getMatchingDeclaredPath } from 'redux-location-state/lib/helpers';
+import { initialState as initialSettingsState } from './reducers/settings/settings';
+import { initialState as initialHeatmapState } from './reducers/heatmap';
 const paramSetup = {
     global: {
         problemFilter: {
@@ -81,19 +90,15 @@ const paramSetup = {
         },
     },
 };
-
 function mergeLocationToState(state, location) {
     return _.merge({}, state, location.query);
 }
-
 function restoreUnknownParams(location, prevLocation) {
-    const {search, ...rest} = location;
+    const { search } = location, rest = __rest(location, ["search"]);
     const params = qs.parse(prevLocation.search.slice(1));
-
     // figure out which path key inside paramSetup matches location.pathname
     const declaredPath = getMatchingDeclaredPath(paramSetup, location);
     const entries = declaredPath && paramSetup[declaredPath];
-
     // remove params which are mapped for this page
     _.each(_.keys(entries), (param) => {
         delete params[param];
@@ -102,38 +107,31 @@ function restoreUnknownParams(location, prevLocation) {
     _.each(_.keys(paramSetup.global || {}), (param) => {
         delete params[param];
     });
-
-    const restoredParams = qs.stringify(params, {encoder: encodeURIComponent});
+    const restoredParams = qs.stringify(params, { encoder: encodeURIComponent });
     const searchDelimiter = search.startsWith('?') ? '&' : '?';
-
-    return {search: `${search}${searchDelimiter}${restoredParams}`, ...rest};
+    return Object.assign({ search: `${search}${searchDelimiter}${restoredParams}` }, rest);
 }
-
 let prevSearchStringFromState = '';
-
 // Keep intact params that are not present in paramSetup
 function overwriteLocationHandling(setupObject, nextState, prevLocation) {
     const nextLocation = stateToParams(setupObject, nextState, prevLocation);
-    let {location} = nextLocation;
-
+    let { location } = nextLocation;
     if (location.search !== prevSearchStringFromState) {
         const searchRe = /\?\w+/;
         prevSearchStringFromState = location.search;
-
         if (searchRe.test(prevLocation.search)) {
             location = restoreUnknownParams(location, prevLocation);
         }
-
-        return {...nextLocation, location};
-    } else {
+        return Object.assign(Object.assign({}, nextLocation), { location });
+    }
+    else {
         // nothing to do here, state parts represented in query params didn't change
-        return {location: prevLocation, shouldPush: false};
+        return { location: prevLocation, shouldPush: false };
     }
 }
-
 function makeReducersWithLocation(setupObject, mapLocationToState, rootReducer) {
     const locationReducer = (state, action) => {
-        const {type, payload} = action;
+        const { type, payload } = action;
         if (!payload) {
             return state;
         }
@@ -143,28 +141,15 @@ function makeReducersWithLocation(setupObject, mapLocationToState, rootReducer)
         }
         return state;
     };
-
     return (state, action) => {
         const postReducerState = rootReducer(state, action);
         const postLocationState = locationReducer(postReducerState, action);
         const hasChanged = postLocationState !== state;
-
         return hasChanged ? postLocationState : state;
     };
 }
-
 export default function getLocationMiddleware(history, rootReducer) {
-    const {locationMiddleware} = createReduxLocationActions(
-        paramSetup,
-        mergeLocationToState,
-        history,
-        rootReducer,
-        overwriteLocationHandling,
-    );
-    const reducersWithLocation = makeReducersWithLocation(
-        paramSetup,
-        mergeLocationToState,
-        rootReducer,
-    );
-    return {locationMiddleware, reducersWithLocation};
+    const { locationMiddleware } = createReduxLocationActions(paramSetup, mergeLocationToState, history, rootReducer, overwriteLocationHandling);
+    const reducersWithLocation = makeReducersWithLocation(paramSetup, mergeLocationToState, rootReducer);
+    return { locationMiddleware, reducersWithLocation };
 }

package/dist/store/utils.d.ts

@@ -0,0 +1,24 @@
+import type { Dispatch } from 'redux';
+import type { GetState } from './reducers';
+export declare const nop: (result: any) => any;
+export declare function createRequestActionTypes<Prefix extends string, Type extends string>(prefix: Prefix, type: Type): {
+    readonly REQUEST: `${Prefix}/${Type}_REQUEST`;
+    readonly SUCCESS: `${Prefix}/${Type}_SUCCESS`;
+    readonly FAILURE: `${Prefix}/${Type}_FAILURE`;
+};
+declare type CreateApiRequestParams<Actions, Response, HandledResponse> = {
+    actions: Actions;
+    request: Promise<Response>;
+    dataHandler?: (data: Response, getState: GetState) => HandledResponse;
+};
+export declare function createApiRequest<Actions extends ReturnType<typeof createRequestActionTypes>, Response, HandledResponse>({ actions, request, dataHandler, }: CreateApiRequestParams<Actions, Response, HandledResponse>): (dispatch: Dispatch, getState: GetState) => Promise<HandledResponse | undefined>;
+export declare type ApiRequestAction<Actions extends ReturnType<typeof createRequestActionTypes>, SuccessResponse = unknown, ErrorResponse = unknown> = {
+    type: Actions['REQUEST'];
+} | {
+    type: Actions['SUCCESS'];
+    data: SuccessResponse;
+} | {
+    type: Actions['FAILURE'];
+    error: ErrorResponse;
+};
+export {};