ydb-embedded-ui 4.32.0 → 5.0.0

package/dist/utils/constants.js

@@ -0,0 +1,99 @@
+import DataTable from '@gravity-ui/react-data-table';
+import { EType } from '../types/api/tablet';
+const SECOND = 1000;
+export const AUTO_RELOAD_INTERVAL = 10 * SECOND;
+// by agreement, display all byte values in decimal scale
+// values in data are always in bytes, never in higher units,
+// therefore there is no issue arbitrary converting them in UI
+export const KILOBYTE = 1000;
+export const MEGABYTE = 1000000;
+export const GIGABYTE = 1000000000;
+export const TERABYTE = 1000000000000;
+export const MINUTE_IN_SECONDS = 60;
+export const HOUR_IN_SECONDS = 60 * MINUTE_IN_SECONDS;
+export const DAY_IN_SECONDS = 24 * HOUR_IN_SECONDS;
+export const MS_IN_NANOSECONDS = 1000000;
+export const TABLET_COLORS = {
+    Created: 'gray',
+    ResolveStateStorage: 'lightgray',
+    Candidate: 'lightgray',
+    BlockBlobStorage: 'lightgray',
+    RebuildGraph: 'yellow',
+    Restored: 'yellow',
+    Discover: 'orange',
+    Lock: 'lightblue',
+    Dead: 'black',
+    Active: 'lightgreen',
+};
+export const TABLET_SYMBOLS = {
+    [EType.OldTxProxy]: 'P',
+    [EType.TxProxy]: 'P',
+    [EType.BSController]: 'BS',
+    [EType.Dummy]: 'DY',
+    [EType.RTMRPartition]: 'RP',
+    [EType.PersQueueReadBalancer]: 'PB',
+    [EType.Cms]: 'CM',
+    [EType.BlockStorePartition]: 'BP',
+    [EType.BlockStoreVolume]: 'BV',
+    [EType.Console]: 'CN',
+    [EType.TenantSlotBroker]: 'TB',
+    [EType.BlockStoreDiskRegistry]: 'BDR',
+};
+const isTabletType = (type) => type in TABLET_SYMBOLS;
+export const getTabletLabel = (type) => {
+    var _a;
+    if (!type) {
+        return undefined;
+    }
+    const defaultValue = (_a = type.match(/[A-Z]/g)) === null || _a === void 0 ? void 0 : _a.join('');
+    return isTabletType(type) ? TABLET_SYMBOLS[type] : defaultValue;
+};
+export const LOAD_AVERAGE_TIME_INTERVALS = ['1 min', '5 min', '15 min'];
+export const COLORS_PRIORITY = {
+    green: 5,
+    yellow: 4,
+    orange: 3,
+    red: 2,
+    blue: 1,
+    grey: 1,
+};
+export const TENANT_OVERVIEW_TABLES_LIMIT = 5;
+export const EMPTY_DATA_PLACEHOLDER = '—';
+// ==== Titles ====
+export const DEVELOPER_UI_TITLE = 'Developer UI';
+export const CLUSTER_DEFAULT_TITLE = 'Cluster';
+export const TENANT_DEFAULT_TITLE = 'Database';
+// ==== Settings ====
+export const THEME_KEY = 'theme';
+export const LANGUAGE_KEY = 'language';
+export const INVERTED_DISKS_KEY = 'invertedDisks';
+export const USE_NODES_ENDPOINT_IN_DIAGNOSTICS_KEY = 'useNodesEndpointInDiagnostics';
+export const SAVED_QUERIES_KEY = 'saved_queries';
+export const ASIDE_HEADER_COMPACT_KEY = 'asideHeaderCompact';
+export const QUERIES_HISTORY_KEY = 'queries_history';
+export const DATA_QA_TUNE_COLUMNS_POPUP = 'tune-columns-popup';
+export const DEFAULT_SIZE_RESULT_PANE_KEY = 'default-size-result-pane';
+export const DEFAULT_SIZE_TENANT_SUMMARY_KEY = 'default-size-tenant-summary-pane';
+export const DEFAULT_SIZE_TENANT_KEY = 'default-size-tenant-pane';
+export const DEFAULT_IS_TENANT_SUMMARY_COLLAPSED = 'default-is-tenant-summary-collapsed';
+export const DEFAULT_IS_TENANT_COMMON_INFO_COLLAPSED = 'default-is-tenant-common-info-collapsed';
+export const DEFAULT_IS_QUERY_RESULT_COLLAPSED = 'default-is-query-result-collapsed';
+export const DEFAULT_TABLE_SETTINGS = {
+    displayIndices: false,
+    stickyHead: DataTable.MOVING,
+    syncHeadOnResize: true,
+    dynamicRender: true,
+    highlightRows: true,
+};
+export const TENANT_OVERVIEW_TABLES_SETTINGS = Object.assign(Object.assign({}, DEFAULT_TABLE_SETTINGS), { stickyHead: 'fixed', dynamicRender: false });
+export const QUERY_INITIAL_MODE_KEY = 'query_initial_mode';
+export const LAST_USED_QUERY_ACTION_KEY = 'last_used_query_action';
+export const PARTITIONS_HIDDEN_COLUMNS_KEY = 'partitionsHiddenColumns';
+export const CLUSTER_INFO_HIDDEN_KEY = 'clusterInfoHidden';
+// Remain "tab" in key name for backward compatibility
+export const TENANT_INITIAL_PAGE_KEY = 'saved_tenant_initial_tab';
+// Send filters and sort params to backend for Nodes and Storage tables
+export const USE_BACKEND_PARAMS_FOR_TABLES_KEY = 'useBackendParamsForTables';
+// Enable schema that supports multiple resultsets
+export const QUERY_USE_MULTI_SCHEMA_KEY = 'queryUseMultiSchema';
+export const USE_CLUSTER_BALANCER_AS_BACKEND_KEY = 'useClusterBalancerAsBacked';

package/dist/utils/createToast.d.ts

@@ -0,0 +1,10 @@
+import { Toaster } from '@gravity-ui/uikit';
+export declare const toaster: Toaster;
+interface CreateToastProps {
+    name?: string;
+    title?: string;
+    content?: string;
+    type: 'error' | 'success';
+}
+declare function createToast({ name, title, type, content }: CreateToastProps): void;
+export default createToast;

package/dist/utils/createToast.js

@@ -0,0 +1,13 @@
+import { Toaster } from '@gravity-ui/uikit';
+export const toaster = new Toaster();
+function createToast({ name, title, type, content }) {
+    return toaster.add({
+        name: name !== null && name !== void 0 ? name : 'Request succeeded',
+        title: title !== null && title !== void 0 ? title : 'Request succeeded',
+        type: type !== null && type !== void 0 ? type : 'success',
+        content: content,
+        isClosable: true,
+        autoHiding: type === 'success' ? 5000 : false,
+    });
+}
+export default createToast;

package/dist/utils/dataFormatters/__test__/roundToSignificant.test.d.ts

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

package/dist/utils/dataFormatters/__test__/roundToSignificant.test.js

@@ -0,0 +1,21 @@
+import { roundToPrecision } from '../dataFormatters';
+describe('roundToSignificant', () => {
+    it('should work with only value', () => {
+        expect(roundToPrecision(123)).toBe(123);
+        expect(roundToPrecision(123.123)).toBe(123);
+        expect(roundToPrecision(12.123)).toBe(12);
+        expect(roundToPrecision(1.123)).toBe(1);
+        expect(roundToPrecision(0.123)).toBe(0);
+        expect(roundToPrecision(0)).toBe(0);
+    });
+    it('should work with precision', () => {
+        expect(roundToPrecision(123, 2)).toBe(123);
+        expect(roundToPrecision(123.123, 2)).toBe(123);
+        expect(roundToPrecision(12.123, 2)).toBe(12);
+        expect(roundToPrecision(1.123, 2)).toBe(1.1);
+        expect(roundToPrecision(0.123, 2)).toBe(0.12);
+        expect(roundToPrecision(0.012, 2)).toBe(0.01);
+        expect(roundToPrecision(0.001, 2)).toBe(0);
+        expect(roundToPrecision(0, 2)).toBe(0);
+    });
+});

package/dist/utils/dataFormatters/dataFormatters.d.ts

@@ -0,0 +1,21 @@
+import type { TVDiskID, TVSlotId } from '../../types/api/vdisk';
+export declare const formatBytes: (bytes?: string | number | undefined) => string;
+export declare const formatBps: (bytes?: string | number | undefined) => string;
+export declare const formatBytesToGigabyte: (bytes: number | string) => string;
+export declare const stringifyVdiskId: (id?: TVDiskID | TVSlotId | undefined) => string;
+export declare const getPDiskId: (info: {
+    NodeId?: number;
+    PDiskId?: number;
+}) => string | undefined;
+export declare const formatUptime: (seconds: number) => string;
+export declare const formatMsToUptime: (ms?: number | undefined) => string | 0 | undefined;
+export declare const formatStorageValues: (value?: number | undefined, total?: number | undefined, size?: "b" | "kb" | "mb" | "gb" | "tb" | undefined) => string[];
+export declare const formatStorageValuesToGb: (value?: number | undefined, total?: number | undefined) => string[];
+export declare const formatStorageValuesToTb: (value?: number | undefined, total?: number | undefined) => string[];
+export declare const formatNumber: (number?: unknown) => string;
+export declare const roundToPrecision: (value: number | string, precision?: number) => number;
+export declare const formatCPU: (value?: string | number | undefined) => string | undefined;
+export declare const formatCPUWithLabel: (value?: number | undefined) => string | undefined;
+export declare const formatDateTime: (value?: string | number | undefined) => string;
+export declare const calcUptimeInSeconds: (milliseconds: number | string) => number;
+export declare const calcUptime: (milliseconds?: string | number | undefined) => string;

package/dist/utils/dataFormatters/dataFormatters.js

@@ -0,0 +1,116 @@
+import { dateTimeParse } from '@gravity-ui/date-utils';
+import { DAY_IN_SECONDS, GIGABYTE } from '../constants';
+import { configuredNumeral } from '../numeral';
+import { isNumeric } from '../utils';
+import { formatBytes as formatBytesCustom, getSizeWithSignificantDigits, } from '../bytesParsers/formatBytes';
+import i18n from './i18n';
+// Here you can't control displayed size and precision
+// If you need more custom format, use formatBytesCustom instead
+export const formatBytes = (bytes) => {
+    if (!isNumeric(bytes)) {
+        return '';
+    }
+    // by agreement, display byte values in decimal scale
+    return configuredNumeral(bytes).format('0 b');
+};
+export const formatBps = (bytes) => {
+    const formattedBytes = formatBytes(bytes);
+    if (!formattedBytes) {
+        return '';
+    }
+    return formattedBytes + '/s';
+};
+export const formatBytesToGigabyte = (bytes) => {
+    return `${Math.floor(Number(bytes) / GIGABYTE)} GB`;
+};
+export const stringifyVdiskId = (id) => {
+    return id ? Object.values(id).join('-') : '';
+};
+export const getPDiskId = (info) => {
+    return info.NodeId && info.PDiskId ? `${info.NodeId}-${info.PDiskId}` : undefined;
+};
+export const formatUptime = (seconds) => {
+    const days = Math.floor(seconds / DAY_IN_SECONDS);
+    const remain = seconds % DAY_IN_SECONDS;
+    const uptime = [days && `${days}d`, configuredNumeral(remain).format('00:00:00')]
+        .filter(Boolean)
+        .join(' ');
+    return uptime;
+};
+export const formatMsToUptime = (ms) => {
+    return ms && formatUptime(ms / 1000);
+};
+export const formatStorageValues = (value, total, size) => {
+    let calculatedSize = getSizeWithSignificantDigits(Number(value), 0);
+    let valueWithSizeLabel = true;
+    let valuePrecision = 0;
+    if (isNumeric(total)) {
+        calculatedSize = getSizeWithSignificantDigits(Number(total), 0);
+        valueWithSizeLabel = false;
+        valuePrecision = 1;
+    }
+    const formattedValue = formatBytesCustom({
+        value,
+        withSizeLabel: valueWithSizeLabel,
+        size: size || calculatedSize,
+        precision: valuePrecision,
+    });
+    const formattedTotal = formatBytesCustom({ value: total, size: size || calculatedSize });
+    return [formattedValue, formattedTotal];
+};
+export const formatStorageValuesToGb = (value, total) => {
+    return formatStorageValues(value, total, 'gb');
+};
+export const formatStorageValuesToTb = (value, total) => {
+    return formatStorageValues(value, total, 'tb');
+};
+export const formatNumber = (number) => {
+    if (!isNumeric(number)) {
+        return '';
+    }
+    return configuredNumeral(number).format('0,0.[00000]');
+};
+export const roundToPrecision = (value, precision = 0) => {
+    let [digits] = String(value).split('.');
+    if (Number(value) < 1) {
+        digits = '';
+    }
+    if (digits.length >= precision) {
+        return Math.round(Number(value));
+    }
+    return Number(Number(value).toFixed(precision - digits.length));
+};
+const normalizeCPU = (value) => {
+    const rawCores = Number(value) / 1000000;
+    return roundToPrecision(rawCores, 3);
+};
+export const formatCPU = (value) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    return configuredNumeral(normalizeCPU(value)).format('0.[000]');
+};
+export const formatCPUWithLabel = (value) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    const cores = normalizeCPU(value);
+    const localizedCores = configuredNumeral(cores).format('0.[000]');
+    return `${localizedCores} ${i18n('format-cpu.cores', { count: cores })}`;
+};
+export const formatDateTime = (value) => {
+    var _a;
+    if (!isNumeric(value)) {
+        return '';
+    }
+    const formattedData = (_a = dateTimeParse(Number(value))) === null || _a === void 0 ? void 0 : _a.format('YYYY-MM-DD HH:mm');
+    return Number(value) > 0 && formattedData ? formattedData : 'N/A';
+};
+export const calcUptimeInSeconds = (milliseconds) => {
+    const currentDate = new Date();
+    const diff = currentDate.getTime() - Number(milliseconds);
+    return diff <= 0 ? 0 : diff / 1000;
+};
+export const calcUptime = (milliseconds) => {
+    return formatUptime(calcUptimeInSeconds(Number(milliseconds)));
+};

package/dist/utils/dataFormatters/i18n/en.json

@@ -1,3 +1,3 @@
 {
-  "format-cpu.cores": ["core", "cores", "cores", "cores"]
+    "format-cpu.cores": ["core", "cores", "cores", "cores"]
 }

package/dist/utils/dataFormatters/i18n/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (key: string, params?: import("@gravity-ui/i18n").Params | undefined) => string;
+export default _default;

package/dist/utils/dataFormatters/i18n/index.js

@@ -0,0 +1,7 @@
+import { i18n, Lang } from '../../i18n';
+import en from './en.json';
+import ru from './ru.json';
+const COMPONENT = 'ydb-format-cpu';
+i18n.registerKeyset(Lang.En, COMPONENT, en);
+i18n.registerKeyset(Lang.Ru, COMPONENT, ru);
+export default i18n.keyset(COMPONENT);

package/dist/utils/dataFormatters/i18n/ru.json

@@ -1,3 +1,3 @@
 {
-  "format-cpu.cores": ["ядро", "ядра", "ядер", "ядер"]
+    "format-cpu.cores": ["ядро", "ядра", "ядер", "ядер"]
 }

package/dist/utils/developerUI/__test__/developerUI.test.d.ts

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

package/dist/utils/developerUI/__test__/developerUI.test.js

@@ -0,0 +1,31 @@
+import { createDeveloperUILinkWithNodeId, createPDiskDeveloperUILink, createVDiskDeveloperUILink, } from '../developerUI';
+describe('Developer UI links generators', () => {
+    describe('createDeveloperUILinkWithNodeId', () => {
+        it('should create relative link with no host', () => {
+            expect(createDeveloperUILinkWithNodeId(1)).toBe('/node/1/');
+        });
+        it('should create relative link with existing relative path with nodeId', () => {
+            expect(createDeveloperUILinkWithNodeId(1, '/node/3/')).toBe('/node/1/');
+        });
+        it('should create full link with host', () => {
+            expect(createDeveloperUILinkWithNodeId(1, 'http://ydb-vla-dev02-001.search.yandex.net:8765')).toBe('http://ydb-vla-dev02-001.search.yandex.net:8765/node/1/');
+        });
+        it('should create full link with host with existing node path with nodeId', () => {
+            expect(createDeveloperUILinkWithNodeId(1, 'http://ydb-vla-dev02-001.search.yandex.net:8765/node/3')).toBe('http://ydb-vla-dev02-001.search.yandex.net:8765/node/1/');
+        });
+    });
+    describe('createPDiskDeveloperUILink', () => {
+        it('should create link with pDiskId and nodeId', () => {
+            expect(createPDiskDeveloperUILink({ nodeId: 1, pDiskId: 1 })).toBe('/node/1/actors/pdisks/pdisk000000001');
+        });
+    });
+    describe('createVDiskDeveloperUILink', () => {
+        it('should create link with pDiskId, vDiskSlotId nodeId', () => {
+            expect(createVDiskDeveloperUILink({
+                nodeId: 1,
+                pDiskId: 1,
+                vDiskSlotId: 1,
+            })).toBe('/node/1/actors/vdisks/vdisk000000001_000000001');
+        });
+    });
+});

package/dist/utils/developerUI/developerUI.d.ts

@@ -0,0 +1,12 @@
+export declare const createDeveloperUILinkWithNodeId: (nodeId: number | string, host?: any) => string;
+interface PDiskDeveloperUILinkParams {
+    nodeId: number | string;
+    pDiskId: number | string;
+    host?: string;
+}
+export declare const createPDiskDeveloperUILink: ({ nodeId, pDiskId, host }: PDiskDeveloperUILinkParams) => string;
+interface VDiskDeveloperUILinkParams extends PDiskDeveloperUILinkParams {
+    vDiskSlotId: number | string;
+}
+export declare const createVDiskDeveloperUILink: ({ nodeId, pDiskId, vDiskSlotId, host, }: VDiskDeveloperUILinkParams) => string;
+export {};

package/dist/utils/developerUI/developerUI.js

@@ -0,0 +1,20 @@
+import { backend } from '../../store';
+import { pad9 } from '../utils';
+// Current node connects with target node by itself using nodeId
+export const createDeveloperUILinkWithNodeId = (nodeId, host = backend) => {
+    const nodePathRegexp = /\/node\/\d+\/?$/g;
+    // In case current backend is already relative node path ({host}/node/{nodeId})
+    // We replace existing nodeId path with new nodeId path
+    if (nodePathRegexp.test(String(host))) {
+        return String(host).replace(nodePathRegexp, `/node/${nodeId}/`);
+    }
+    return `${host !== null && host !== void 0 ? host : ''}/node/${nodeId}/`;
+};
+export const createPDiskDeveloperUILink = ({ nodeId, pDiskId, host }) => {
+    const pdiskPath = 'actors/pdisks/pdisk' + pad9(pDiskId);
+    return createDeveloperUILinkWithNodeId(nodeId, host) + pdiskPath;
+};
+export const createVDiskDeveloperUILink = ({ nodeId, pDiskId, vDiskSlotId, host, }) => {
+    const vdiskPath = 'actors/vdisks/vdisk' + pad9(pDiskId) + '_' + pad9(vDiskSlotId);
+    return createDeveloperUILinkWithNodeId(nodeId, host) + vdiskPath;
+};

package/dist/utils/diagnostics.d.ts

@@ -0,0 +1,18 @@
+import { ValueOf } from '../types/common';
+declare const TOP_SHARDS_SORT_VALUES: {
+    readonly CPUCores: "CPUCores";
+    readonly DataSize: "DataSize";
+    readonly InFlightTxCount: "InFlightTxCount";
+};
+declare const TOP_QUERIES_SORT_VALUES: {
+    readonly CPUTimeUs: "CPUTimeUs";
+    readonly EndTime: "EndTime";
+    readonly ReadRows: "ReadRows";
+    readonly ReadBytes: "ReadBytes";
+    readonly UserSID: "UserSID";
+};
+declare type TopShardsSortValue = ValueOf<typeof TOP_SHARDS_SORT_VALUES>;
+declare type TopQueriesSortValue = ValueOf<typeof TOP_QUERIES_SORT_VALUES>;
+export declare const isSortableTopShardsProperty: (value: string) => value is TopShardsSortValue;
+export declare const isSortableTopQueriesProperty: (value: string) => value is TopQueriesSortValue;
+export {};

package/dist/utils/diagnostics.js

@@ -0,0 +1,14 @@
+const TOP_SHARDS_SORT_VALUES = {
+    CPUCores: 'CPUCores',
+    DataSize: 'DataSize',
+    InFlightTxCount: 'InFlightTxCount',
+};
+const TOP_QUERIES_SORT_VALUES = {
+    CPUTimeUs: 'CPUTimeUs',
+    EndTime: 'EndTime',
+    ReadRows: 'ReadRows',
+    ReadBytes: 'ReadBytes',
+    UserSID: 'UserSID',
+};
+export const isSortableTopShardsProperty = (value) => Object.values(TOP_SHARDS_SORT_VALUES).includes(value);
+export const isSortableTopQueriesProperty = (value) => Object.values(TOP_QUERIES_SORT_VALUES).includes(value);

package/dist/utils/error.d.ts

@@ -0,0 +1,2 @@
+import type { QueryError, QueryErrorResponse } from '../types/store/query';
+export declare const parseQueryError: (error: QueryError) => QueryErrorResponse | string | undefined;

package/dist/utils/error.js

@@ -0,0 +1,13 @@
+const isNetworkError = (error) => {
+    return Boolean(error &&
+        typeof error === 'object' &&
+        'message' in error &&
+        error.message === 'Network Error');
+};
+export const parseQueryError = (error) => {
+    if (isNetworkError(error)) {
+        return error.message;
+    }
+    // 401 Unauthorized error is handled by GenericAPI
+    return error !== null && error !== void 0 ? error : 'Unauthorized';
+};

package/dist/utils/filters.d.ts

@@ -0,0 +1,3 @@
+import type { OrderType } from '@gravity-ui/react-data-table';
+export declare const prepareSortValue: (sortValue: string | undefined, sortOrder?: OrderType) => string;
+export declare const prepareSearchValue: (searchValue?: string) => RegExp;

package/dist/utils/filters.js

@@ -0,0 +1,14 @@
+import { escapeRegExp } from 'lodash';
+import { DESCENDING } from '@gravity-ui/react-data-table/build/esm/lib/constants';
+export const prepareSortValue = (sortValue, sortOrder = DESCENDING) => {
+    if (!sortValue) {
+        return '';
+    }
+    if (sortOrder === DESCENDING) {
+        return '-' + sortValue;
+    }
+    return sortValue;
+};
+export const prepareSearchValue = (searchValue = '') => {
+    return new RegExp(escapeRegExp(searchValue), 'i');
+};

package/dist/utils/generateEvaluator.d.ts

@@ -0,0 +1 @@
+export declare const generateEvaluator: <OkLevel extends string, WarnLevel extends string, CritLevel extends string>(warn: number, crit: number, levels: [OkLevel, WarnLevel, CritLevel]) => (value: number) => OkLevel | WarnLevel | CritLevel | undefined;

package/dist/utils/generateEvaluator.js

@@ -0,0 +1,12 @@
+export const generateEvaluator = (warn, crit, levels) => (value) => {
+    if (0 <= value && value < warn) {
+        return levels[0];
+    }
+    if (warn <= value && value < crit) {
+        return levels[1];
+    }
+    if (crit <= value) {
+        return levels[2];
+    }
+    return undefined;
+};

package/dist/utils/generateHash.d.ts

@@ -0,0 +1 @@
+export declare const generateHash: (value: string) => string;

package/dist/utils/generateHash.js

@@ -0,0 +1,10 @@
+import crc32 from 'crc-32';
+export const generateHash = (value) => {
+    // 1. crc32.str(value) - generate crc32 hash
+    // 2. (>>>) - use unsigned right shift operator (>>>) to avoid negative values
+    // 3. toString(16) - convert hash to hex format
+    // 4. toUpperCase() - convert hash to uppercase
+    // 5. padStart(8, '0') - fill hash with leading zeros if hash length < 8
+    // eslint-disable-next-line no-bitwise
+    return (crc32.str(value) >>> 0).toString(16).toUpperCase().padStart(8, '0');
+};

package/dist/utils/hooks/index.d.ts

@@ -0,0 +1,8 @@
+export * from './useAutofetcher';
+export * from './useTypedSelector';
+export * from './useSetting';
+export * from './useQueryModes';
+export * from './useTableSort';
+export * from './useSearchQuery';
+export * from './useNodesRequestParams';
+export * from './useStorageRequestParams';

package/dist/utils/hooks/index.js

@@ -0,0 +1,8 @@
+export * from './useAutofetcher';
+export * from './useTypedSelector';
+export * from './useSetting';
+export * from './useQueryModes';
+export * from './useTableSort';
+export * from './useSearchQuery';
+export * from './useNodesRequestParams';
+export * from './useStorageRequestParams';

package/dist/utils/hooks/useAutofetcher.d.ts

@@ -0,0 +1,2 @@
+import { DependencyList } from 'react';
+export declare const useAutofetcher: (fetchData: (isBackground: boolean) => void, deps: DependencyList, enabled?: boolean) => void;

package/dist/utils/hooks/useAutofetcher.js

@@ -0,0 +1,23 @@
+import { useEffect, useRef } from 'react';
+import { AutoFetcher } from '../autofetcher';
+export const useAutofetcher = (fetchData, deps, enabled = true) => {
+    const ref = useRef(null);
+    if (ref.current === null) {
+        ref.current = new AutoFetcher();
+    }
+    const autofetcher = ref.current;
+    // initial fetch
+    useEffect(() => {
+        fetchData(false);
+    }, deps); // eslint-disable-line react-hooks/exhaustive-deps
+    useEffect(() => {
+        autofetcher.stop();
+        if (enabled) {
+            autofetcher.start();
+            autofetcher.fetch(() => fetchData(true));
+        }
+        return () => {
+            autofetcher.stop();
+        };
+    }, [enabled, ...deps]); // eslint-disable-line react-hooks/exhaustive-deps
+};

package/dist/utils/hooks/useNodesRequestParams.d.ts

@@ -0,0 +1,15 @@
+import type { NodesGeneralRequestParams } from '../../store/reducers/nodes/types';
+import type { ProblemFilterValue } from '../../store/reducers/settings/types';
+import { NodesUptimeFilterValues } from '../nodes';
+interface NodesRawRequestParams extends Omit<NodesGeneralRequestParams, 'problems_only' | 'uptime'> {
+    problemFilter?: ProblemFilterValue;
+    nodesUptimeFilter?: NodesUptimeFilterValues;
+}
+export declare const useNodesRequestParams: ({ filter, problemFilter, nodesUptimeFilter, sortOrder, sortValue, }: NodesRawRequestParams) => {
+    filter: string | undefined;
+    problems_only: boolean;
+    uptime: number | undefined;
+    sortOrder: import("@gravity-ui/react-data-table").OrderType | undefined;
+    sortValue: import("../nodes").NodesSortValue | undefined;
+} | undefined;
+export {};

package/dist/utils/hooks/useNodesRequestParams.js

@@ -0,0 +1,23 @@
+import { useMemo } from 'react';
+import { USE_BACKEND_PARAMS_FOR_TABLES_KEY } from '../constants';
+import { getProblemParamValue, getUptimeParamValue } from '../nodes';
+import { useSetting } from './useSetting';
+export const useNodesRequestParams = ({ filter, problemFilter, nodesUptimeFilter, sortOrder, sortValue, }) => {
+    const [useBackendParamsForTables] = useSetting(USE_BACKEND_PARAMS_FOR_TABLES_KEY);
+    // If backend params are enabled, update params value to use them in fetch request
+    // Otherwise no params will be updated, no hooks that depend on requestParams will be triggered
+    return useMemo(() => {
+        if (useBackendParamsForTables) {
+            const problemsOnly = getProblemParamValue(problemFilter);
+            const uptime = getUptimeParamValue(nodesUptimeFilter);
+            return {
+                filter,
+                problems_only: problemsOnly,
+                uptime,
+                sortOrder,
+                sortValue,
+            };
+        }
+        return undefined;
+    }, [useBackendParamsForTables, filter, problemFilter, nodesUptimeFilter, sortOrder, sortValue]);
+};

package/dist/utils/hooks/useQueryModes.d.ts

@@ -0,0 +1,2 @@
+import type { QueryMode } from '../../types/store/query';
+export declare const useQueryModes: () => [QueryMode, (value: QueryMode) => void];

package/dist/utils/hooks/useQueryModes.js

@@ -0,0 +1,5 @@
+import { QUERY_INITIAL_MODE_KEY } from '../constants';
+import { useSetting } from './useSetting';
+export const useQueryModes = () => {
+    return useSetting(QUERY_INITIAL_MODE_KEY);
+};

package/dist/utils/hooks/useSearchQuery.d.ts

@@ -0,0 +1 @@
+export declare const useSearchQuery: () => import("qs").ParsedQs;

package/dist/utils/hooks/useSearchQuery.js

@@ -0,0 +1,6 @@
+import { useLocation } from 'react-router';
+import { parseQuery } from '../../routes';
+export const useSearchQuery = () => {
+    const location = useLocation();
+    return parseQuery(location);
+};

package/dist/utils/hooks/useSetting.d.ts

@@ -0,0 +1 @@
+export declare const useSetting: <T>(key: string, defaultValue?: T | undefined) => [T, (value: T) => void];

package/dist/utils/hooks/useSetting.js

@@ -0,0 +1,16 @@
+import { useCallback } from 'react';
+import { useDispatch } from 'react-redux';
+import { getSettingValue, setSettingValue } from '../../store/reducers/settings/settings';
+import { useTypedSelector } from './useTypedSelector';
+export const useSetting = (key, defaultValue) => {
+    const dispatch = useDispatch();
+    const settingValue = useTypedSelector((state) => {
+        var _a;
+        // Since we type setter value as T, we assume that received value is also T
+        return ((_a = getSettingValue(state, key)) !== null && _a !== void 0 ? _a : defaultValue);
+    });
+    const setValue = useCallback((value) => {
+        dispatch(setSettingValue(key, value));
+    }, [dispatch, key]);
+    return [settingValue, setValue];
+};

package/dist/utils/hooks/useStorageRequestParams.d.ts

@@ -0,0 +1,8 @@
+import type { StorageSortAndFilterParams } from '../../store/reducers/storage/types';
+import { EVersion } from '../../types/api/storage';
+export declare const useStorageRequestParams: ({ filter, sortOrder, sortValue, }: StorageSortAndFilterParams) => {
+    version: EVersion;
+    filter: string | undefined;
+    sortOrder: import("@gravity-ui/react-data-table").OrderType | undefined;
+    sortValue: import("../storage").StorageSortValue | undefined;
+} | undefined;