ydb-embedded-ui 4.32.0 → 5.0.0

package/dist/containers/Tenant/Diagnostics/Consumers/TopicStats/index.js

@@ -0,0 +1 @@
+export * from './ConsumersTopicStats';

package/dist/containers/Tenant/Diagnostics/Consumers/columns/columns.d.ts

@@ -0,0 +1,4 @@
+import { Column } from '@gravity-ui/react-data-table';
+import type { IPreparedConsumerData } from '../../../../../types/store/topic';
+import './Columns.scss';
+export declare const columns: Column<IPreparedConsumerData>[];

package/dist/containers/Tenant/Diagnostics/Consumers/columns/columns.js

@@ -0,0 +1,62 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import DataTable from '@gravity-ui/react-data-table';
+import block from 'bem-cn-lite';
+import qs from 'qs';
+import { TENANT_DIAGNOSTICS_TABS_IDS } from '../../../../../store/reducers/tenant/constants';
+import { SpeedMultiMeter } from '../../../../../components/SpeedMultiMeter';
+import { InternalLink } from '../../../../../components/InternalLink';
+import { formatMsToUptime } from '../../../../../utils/dataFormatters/dataFormatters';
+import routes, { createHref } from '../../../../../routes';
+import { TenantTabsGroups } from '../../../TenantPages';
+import { CONSUMERS_COLUMNS_IDS, CONSUMERS_COLUMNS_TITILES, CONSUMERS_READ_LAGS_SUB_COLUMNS_IDS, CONSUMERS_READ_LAGS_SUB_COLUMNS_TITLES, } from '../utils/constants';
+import { ReadLagsHeader } from '../Headers';
+import './Columns.scss';
+const b = block('ydb-diagnostics-consumers-columns');
+export const columns = [
+    {
+        name: CONSUMERS_COLUMNS_IDS.CONSUMER,
+        header: CONSUMERS_COLUMNS_TITILES[CONSUMERS_COLUMNS_IDS.CONSUMER],
+        align: DataTable.LEFT,
+        render: ({ row }) => {
+            if (!row.name) {
+                return '–';
+            }
+            const queryParams = qs.parse(location.search, {
+                ignoreQueryPrefix: true,
+            });
+            return (_jsx(InternalLink, Object.assign({ to: createHref(routes.tenant, undefined, Object.assign(Object.assign({}, queryParams), { [TenantTabsGroups.diagnosticsTab]: TENANT_DIAGNOSTICS_TABS_IDS.partitions, selectedConsumer: row.name })) }, { children: row.name })));
+        },
+    },
+    {
+        name: CONSUMERS_COLUMNS_IDS.READ_SPEED,
+        header: CONSUMERS_COLUMNS_TITILES[CONSUMERS_COLUMNS_IDS.READ_SPEED],
+        align: DataTable.RIGHT,
+        sortAccessor: (row) => row.readSpeed.perMinute,
+        render: ({ row }) => _jsx(SpeedMultiMeter, { data: row.readSpeed }),
+    },
+    {
+        name: CONSUMERS_COLUMNS_IDS.READ_LAGS,
+        header: _jsx(ReadLagsHeader, {}),
+        className: b('lags-header'),
+        sub: [
+            {
+                name: CONSUMERS_READ_LAGS_SUB_COLUMNS_IDS.WRITE_LAG,
+                header: CONSUMERS_READ_LAGS_SUB_COLUMNS_TITLES[CONSUMERS_READ_LAGS_SUB_COLUMNS_IDS.WRITE_LAG],
+                align: DataTable.RIGHT,
+                render: ({ row }) => formatMsToUptime(row.writeLag),
+            },
+            {
+                name: CONSUMERS_READ_LAGS_SUB_COLUMNS_IDS.READ_LAG,
+                header: CONSUMERS_READ_LAGS_SUB_COLUMNS_TITLES[CONSUMERS_READ_LAGS_SUB_COLUMNS_IDS.READ_LAG],
+                align: DataTable.RIGHT,
+                render: ({ row }) => formatMsToUptime(row.readLag),
+            },
+            {
+                name: CONSUMERS_READ_LAGS_SUB_COLUMNS_IDS.READ_IDLE_TIME,
+                header: CONSUMERS_READ_LAGS_SUB_COLUMNS_TITLES[CONSUMERS_READ_LAGS_SUB_COLUMNS_IDS.READ_IDLE_TIME],
+                align: DataTable.RIGHT,
+                render: ({ row }) => formatMsToUptime(row.readIdleTime),
+            },
+        ],
+    },
+];

package/dist/containers/Tenant/Diagnostics/Consumers/i18n/en.json

@@ -1,7 +1,7 @@
 {
-  "noConsumersMessage.topic": "This topic has no consumers",
-  "noConsumersMessage.stream": "This changefeed has no consumers",
-  "lagsPopover.readLags": "Read lags statistics, maximum among all consumer partitions (time format dd hh:mm:ss)",
-  "table.emptyDataMessage": "No consumers match the current search",
-  "controls.search": "Consumer"
+    "noConsumersMessage.topic": "This topic has no consumers",
+    "noConsumersMessage.stream": "This changefeed has no consumers",
+    "lagsPopover.readLags": "Read lags statistics, maximum among all consumer partitions (time format dd hh:mm:ss)",
+    "table.emptyDataMessage": "No consumers match the current search",
+    "controls.search": "Consumer"
 }

package/dist/containers/Tenant/Diagnostics/Consumers/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/containers/Tenant/Diagnostics/Consumers/i18n/index.js

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

package/dist/containers/Tenant/Diagnostics/Consumers/i18n/ru.json

@@ -1,7 +1,7 @@
 {
-  "noConsumersMessage.topic": "У этого топика нет читателей",
-  "noConsumersMessage.stream": "У этого стрима нет читателей",
-  "lagsPopover.readLags": "Статистика лагов чтения, максимальное значение среди всех партиций читателя (формат времени дд чч:мм:сс)",
-  "table.emptyDataMessage": "По заданному поиску нет читателей",
-  "controls.search": "Consumer"
+    "noConsumersMessage.topic": "У этого топика нет читателей",
+    "noConsumersMessage.stream": "У этого стрима нет читателей",
+    "lagsPopover.readLags": "Статистика лагов чтения, максимальное значение среди всех партиций читателя (формат времени дд чч:мм:сс)",
+    "table.emptyDataMessage": "По заданному поиску нет читателей",
+    "controls.search": "Consumer"
 }

package/dist/containers/Tenant/Diagnostics/Consumers/index.js

@@ -0,0 +1 @@
+export * from './Consumers';

package/dist/containers/Tenant/Diagnostics/Consumers/utils/constants.d.ts

@@ -0,0 +1,20 @@
+export declare const CONSUMERS_COLUMNS_IDS: {
+    readonly CONSUMER: "consumer";
+    readonly READ_SPEED: "readSpeed";
+    readonly READ_LAGS: "readLags";
+};
+export declare const CONSUMERS_COLUMNS_TITILES: {
+    readonly consumer: "Consumer";
+    readonly readSpeed: "Read speed";
+    readonly readLags: "Read lags, duration";
+};
+export declare const CONSUMERS_READ_LAGS_SUB_COLUMNS_IDS: {
+    readonly WRITE_LAG: "writeLag";
+    readonly READ_LAG: "readLag";
+    readonly READ_IDLE_TIME: "readIdleTime";
+};
+export declare const CONSUMERS_READ_LAGS_SUB_COLUMNS_TITLES: {
+    readonly writeLag: "write lag";
+    readonly readLag: "read lag";
+    readonly readIdleTime: "read idle time";
+};

package/dist/containers/Tenant/Diagnostics/Consumers/utils/constants.js

@@ -0,0 +1,20 @@
+export const CONSUMERS_COLUMNS_IDS = {
+    CONSUMER: 'consumer',
+    READ_SPEED: 'readSpeed',
+    READ_LAGS: 'readLags',
+};
+export const CONSUMERS_COLUMNS_TITILES = {
+    [CONSUMERS_COLUMNS_IDS.CONSUMER]: 'Consumer',
+    [CONSUMERS_COLUMNS_IDS.READ_SPEED]: 'Read speed',
+    [CONSUMERS_COLUMNS_IDS.READ_LAGS]: 'Read lags, duration',
+};
+export const CONSUMERS_READ_LAGS_SUB_COLUMNS_IDS = {
+    WRITE_LAG: 'writeLag',
+    READ_LAG: 'readLag',
+    READ_IDLE_TIME: 'readIdleTime',
+};
+export const CONSUMERS_READ_LAGS_SUB_COLUMNS_TITLES = {
+    [CONSUMERS_READ_LAGS_SUB_COLUMNS_IDS.WRITE_LAG]: 'write lag',
+    [CONSUMERS_READ_LAGS_SUB_COLUMNS_IDS.READ_LAG]: 'read lag',
+    [CONSUMERS_READ_LAGS_SUB_COLUMNS_IDS.READ_IDLE_TIME]: 'read idle time',
+};

package/dist/containers/Tenant/Diagnostics/Describe/Describe.d.ts

@@ -0,0 +1,9 @@
+import 'react-json-inspector/json-inspector.css';
+import type { EPathType } from '../../../../types/api/schema';
+import './Describe.scss';
+interface IDescribeProps {
+    tenant: string;
+    type?: EPathType;
+}
+declare const Describe: ({ tenant, type }: IDescribeProps) => JSX.Element;
+export default Describe;

package/dist/containers/Tenant/Diagnostics/Describe/Describe.js

@@ -0,0 +1,66 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useEffect, useState } from 'react';
+import { shallowEqual, useDispatch } from 'react-redux';
+import cn from 'bem-cn-lite';
+import JSONTree from 'react-json-inspector';
+import 'react-json-inspector/json-inspector.css';
+import { Loader } from '../../../../components/Loader';
+import { ResponseError } from '../../../../components/Errors/ResponseError';
+import { useAutofetcher, useTypedSelector } from '../../../../utils/hooks';
+import { getDescribe, setDataWasNotLoaded, setCurrentDescribePath, getDescribeBatched, } from '../../../../store/reducers/describe';
+import { selectSchemaMergedChildrenPaths } from '../../../../store/reducers/schema/schema';
+import { isEntityWithMergedImplementation } from '../../utils/schema';
+import './Describe.scss';
+const b = cn('kv-describe');
+const expandMap = new Map();
+const Describe = ({ tenant, type }) => {
+    const dispatch = useDispatch();
+    const { currentDescribe, error, loading, wasLoaded } = useTypedSelector((state) => state.describe);
+    const [preparedDescribeData, setPreparedDescribeData] = useState();
+    useEffect(() => {
+        if (currentDescribe) {
+            const paths = Object.keys(currentDescribe);
+            if (paths.length === 1) {
+                setPreparedDescribeData(currentDescribe[paths[0]]);
+            }
+            else {
+                setPreparedDescribeData(currentDescribe);
+            }
+        }
+    }, [currentDescribe]);
+    const { autorefresh, currentSchemaPath } = useTypedSelector((state) => state.schema);
+    const isEntityWithMergedImpl = isEntityWithMergedImplementation(type);
+    const mergedChildrenPaths = useTypedSelector((state) => selectSchemaMergedChildrenPaths(state, currentSchemaPath, type), shallowEqual);
+    const fetchData = useCallback((isBackground) => {
+        if (!isBackground) {
+            dispatch(setDataWasNotLoaded());
+        }
+        const path = currentSchemaPath || tenant;
+        dispatch(setCurrentDescribePath(path));
+        if (!isEntityWithMergedImpl) {
+            dispatch(getDescribe({ path }));
+        }
+        else if (mergedChildrenPaths) {
+            dispatch(getDescribeBatched([path, ...mergedChildrenPaths]));
+        }
+    }, [currentSchemaPath, tenant, mergedChildrenPaths, isEntityWithMergedImpl, dispatch]);
+    useAutofetcher(fetchData, [fetchData], autorefresh);
+    if ((loading && !wasLoaded) || (isEntityWithMergedImpl && !mergedChildrenPaths)) {
+        return _jsx(Loader, { size: "m" });
+    }
+    if (error) {
+        return _jsx(ResponseError, { error: error, className: b('message-container') });
+    }
+    if (!loading && !preparedDescribeData) {
+        return _jsx("div", Object.assign({ className: b('message-container') }, { children: "Empty" }));
+    }
+    return (_jsx("div", Object.assign({ className: b() }, { children: _jsx("div", Object.assign({ className: b('result') }, { children: _jsx(JSONTree, { data: preparedDescribeData, className: b('tree'), onClick: ({ path }) => {
+                    const newValue = !(expandMap.get(path) || false);
+                    expandMap.set(path, newValue);
+                }, searchOptions: {
+                    debounceTime: 300,
+                }, isExpanded: (keypath) => {
+                    return expandMap.get(keypath) || false;
+                } }) })) })));
+};
+export default Describe;

package/dist/containers/Tenant/Diagnostics/DetailedOverview/DetailedOverview.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import type { EPathType } from '../../../../types/api/schema';
+import type { AdditionalNodesProps, AdditionalTenantsProps } from '../../../../types/additionalProps';
+import './DetailedOverview.scss';
+interface DetailedOverviewProps {
+    type?: EPathType;
+    className?: string;
+    tenantName: string;
+    additionalTenantProps?: AdditionalTenantsProps;
+    additionalNodesProps?: AdditionalNodesProps;
+}
+declare function DetailedOverview(props: DetailedOverviewProps): JSX.Element;
+export default DetailedOverview;

package/dist/containers/Tenant/Diagnostics/DetailedOverview/DetailedOverview.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useSelector } from 'react-redux';
+import cn from 'bem-cn-lite';
+import Overview from '../Overview/Overview';
+import { TenantOverview } from '../TenantOverview/TenantOverview';
+import './DetailedOverview.scss';
+const b = cn('kv-detailed-overview');
+function DetailedOverview(props) {
+    const { type, tenantName, additionalTenantProps, additionalNodesProps } = props;
+    const { currentSchemaPath } = useSelector((state) => state.schema);
+    const renderTenantOverview = () => {
+        return (_jsx("div", Object.assign({ className: b('section') }, { children: _jsx(TenantOverview, { tenantName: tenantName, additionalTenantProps: additionalTenantProps, additionalNodesProps: additionalNodesProps }) })));
+    };
+    const isTenant = tenantName === currentSchemaPath;
+    return (_jsx("div", Object.assign({ className: b() }, { children: isTenant ? renderTenantOverview() : _jsx(Overview, { type: type, tenantName: tenantName }) })));
+}
+export default DetailedOverview;

package/dist/containers/Tenant/Diagnostics/Diagnostics.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import type { EPathType } from '../../../types/api/schema';
+import type { AdditionalTenantsProps, AdditionalNodesProps } from '../../../types/additionalProps';
+import './Diagnostics.scss';
+interface DiagnosticsProps {
+    type?: EPathType;
+    additionalTenantProps?: AdditionalTenantsProps;
+    additionalNodesProps?: AdditionalNodesProps;
+}
+declare function Diagnostics(props: DiagnosticsProps): JSX.Element;
+export default Diagnostics;

package/dist/containers/Tenant/Diagnostics/Diagnostics.js

@@ -0,0 +1,133 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo, useRef } from 'react';
+import qs from 'qs';
+import cn from 'bem-cn-lite';
+import { Link } from 'react-router-dom';
+import { useDispatch, useSelector } from 'react-redux';
+import { useLocation } from 'react-router';
+import { Switch, Tabs } from '@gravity-ui/uikit';
+import { useTypedSelector } from '../../../utils/hooks';
+import routes, { createHref } from '../../../routes';
+import { enableAutorefresh, disableAutorefresh } from '../../../store/reducers/schema/schema';
+import { setDiagnosticsTab } from '../../../store/reducers/tenant/tenant';
+import { TENANT_DIAGNOSTICS_TABS_IDS } from '../../../store/reducers/tenant/constants';
+import { Loader } from '../../../components/Loader';
+import { Heatmap } from '../../Heatmap';
+import { NodesWrapper } from '../../Nodes/NodesWrapper';
+import { StorageWrapper } from '../../Storage/StorageWrapper';
+import { Tablets } from '../../Tablets';
+import Describe from './Describe/Describe';
+import HotKeys from './HotKeys/HotKeys';
+import Network from './Network/Network';
+import { Partitions } from './Partitions/Partitions';
+import { Consumers } from './Consumers';
+import { TopQueries } from './TopQueries';
+import { TopShards } from './TopShards';
+import DetailedOverview from './DetailedOverview/DetailedOverview';
+import { isDatabaseEntityType } from '../utils/schema';
+import { TenantTabsGroups } from '../TenantPages';
+import { DATABASE_PAGES, getPagesByType } from './DiagnosticsPages';
+import './Diagnostics.scss';
+const b = cn('kv-tenant-diagnostics');
+function Diagnostics(props) {
+    const container = useRef(null);
+    const dispatch = useDispatch();
+    const { currentSchemaPath, autorefresh, wasLoaded } = useSelector((state) => state.schema);
+    const { diagnosticsTab = TENANT_DIAGNOSTICS_TABS_IDS.overview } = useTypedSelector((state) => state.tenant);
+    const location = useLocation();
+    const queryParams = qs.parse(location.search, {
+        ignoreQueryPrefix: true,
+    });
+    const { name: rootTenantName } = queryParams;
+    const tenantName = isDatabaseEntityType(props.type) ? currentSchemaPath : rootTenantName;
+    const isDatabase = isDatabaseEntityType(props.type) || currentSchemaPath === rootTenantName;
+    const pages = useMemo(() => {
+        if (isDatabase) {
+            return DATABASE_PAGES;
+        }
+        return getPagesByType(props.type);
+    }, [props.type, isDatabase]);
+    const forwardToDiagnosticTab = (tab) => {
+        dispatch(setDiagnosticsTab(tab));
+    };
+    const activeTab = useMemo(() => {
+        if (wasLoaded) {
+            if (pages.find((el) => el.id === diagnosticsTab)) {
+                return diagnosticsTab;
+            }
+            else {
+                const newPage = pages[0].id;
+                forwardToDiagnosticTab(newPage);
+                return newPage;
+            }
+        }
+        return undefined;
+    }, [pages, diagnosticsTab, wasLoaded]);
+    const onAutorefreshToggle = (value) => {
+        if (value) {
+            dispatch(enableAutorefresh());
+        }
+        else {
+            dispatch(disableAutorefresh());
+        }
+    };
+    const renderTabContent = () => {
+        const { type } = props;
+        const tenantNameString = tenantName;
+        switch (diagnosticsTab) {
+            case TENANT_DIAGNOSTICS_TABS_IDS.overview: {
+                return (_jsx(DetailedOverview, { type: type, tenantName: tenantNameString, additionalTenantProps: props.additionalTenantProps, additionalNodesProps: props.additionalNodesProps }));
+            }
+            case TENANT_DIAGNOSTICS_TABS_IDS.topQueries: {
+                return _jsx(TopQueries, { path: tenantNameString, type: type });
+            }
+            case TENANT_DIAGNOSTICS_TABS_IDS.topShards: {
+                return _jsx(TopShards, { tenantPath: tenantNameString, type: type });
+            }
+            case TENANT_DIAGNOSTICS_TABS_IDS.nodes: {
+                return (_jsx(NodesWrapper, { path: currentSchemaPath, additionalNodesProps: props.additionalNodesProps, parentContainer: container.current }));
+            }
+            case TENANT_DIAGNOSTICS_TABS_IDS.tablets: {
+                return _jsx(Tablets, { path: currentSchemaPath });
+            }
+            case TENANT_DIAGNOSTICS_TABS_IDS.storage: {
+                return (_jsx(StorageWrapper, { tenant: tenantNameString, parentContainer: container.current }));
+            }
+            case TENANT_DIAGNOSTICS_TABS_IDS.network: {
+                return _jsx(Network, { path: tenantNameString });
+            }
+            case TENANT_DIAGNOSTICS_TABS_IDS.describe: {
+                return _jsx(Describe, { tenant: tenantNameString, type: type });
+            }
+            case TENANT_DIAGNOSTICS_TABS_IDS.hotKeys: {
+                return _jsx(HotKeys, { type: type });
+            }
+            case TENANT_DIAGNOSTICS_TABS_IDS.graph: {
+                return _jsx(Heatmap, { path: currentSchemaPath });
+            }
+            case TENANT_DIAGNOSTICS_TABS_IDS.consumers: {
+                return _jsx(Consumers, { path: currentSchemaPath, type: type });
+            }
+            case TENANT_DIAGNOSTICS_TABS_IDS.partitions: {
+                return _jsx(Partitions, { path: currentSchemaPath });
+            }
+            default: {
+                return _jsx("div", { children: "No data..." });
+            }
+        }
+    };
+    const renderTabs = () => {
+        return (_jsx("div", Object.assign({ className: b('header-wrapper') }, { children: _jsxs("div", Object.assign({ className: b('tabs') }, { children: [_jsx(Tabs, { size: "l", items: pages, activeTab: activeTab, wrapTo: ({ id }, node) => {
+                            const path = createHref(routes.tenant, undefined, Object.assign(Object.assign({}, queryParams), { [TenantTabsGroups.diagnosticsTab]: id }));
+                            return (_jsx(Link, Object.assign({ to: path, className: b('tab') }, { children: node }), id));
+                        }, allowNotSelected: true }), _jsx(Switch, { checked: autorefresh, onUpdate: onAutorefreshToggle, content: "Autorefresh" })] })) })));
+    };
+    // Loader prevents incorrect loading of tabs
+    // After tabs are initially loaded it is no longer needed
+    // Thus there is no also "loading" check as in other parts of the project
+    if (!wasLoaded) {
+        return _jsx(Loader, { size: "l" });
+    }
+    return (_jsxs("div", Object.assign({ className: b(), ref: container }, { children: [renderTabs(), _jsx("div", Object.assign({ className: b('page-wrapper') }, { children: renderTabContent() }))] })));
+}
+export default Diagnostics;

package/dist/containers/Tenant/Diagnostics/DiagnosticsPages.d.ts

@@ -0,0 +1,114 @@
+import type { TenantDiagnosticsTab } from '../../../store/reducers/tenant/types';
+import { EPathType } from '../../../types/api/schema';
+declare type Page = {
+    id: TenantDiagnosticsTab;
+    title: string;
+};
+export declare const DATABASE_PAGES: ({
+    id: "overview";
+    title: string;
+} | {
+    id: "topQueries";
+    title: string;
+} | {
+    id: "topShards";
+    title: string;
+} | {
+    id: "nodes";
+    title: string;
+} | {
+    id: "tablets";
+    title: string;
+} | {
+    id: "storage";
+    title: string;
+} | {
+    id: "network";
+    title: string;
+} | {
+    id: "describe";
+    title: string;
+})[];
+export declare const TABLE_PAGES: ({
+    id: "overview";
+    title: string;
+} | {
+    id: "topShards";
+    title: string;
+} | {
+    id: "nodes";
+    title: string;
+} | {
+    id: "tablets";
+    title: string;
+} | {
+    id: "describe";
+    title: string;
+} | {
+    id: "hotKeys";
+    title: string;
+} | {
+    id: "graph";
+    title: string;
+})[];
+export declare const DIR_PAGES: ({
+    id: "overview";
+    title: string;
+} | {
+    id: "topShards";
+    title: string;
+} | {
+    id: "nodes";
+    title: string;
+} | {
+    id: "describe";
+    title: string;
+})[];
+export declare const CDC_STREAM_PAGES: ({
+    id: "overview";
+    title: string;
+} | {
+    id: "nodes";
+    title: string;
+} | {
+    id: "describe";
+    title: string;
+} | {
+    id: "consumers";
+    title: string;
+} | {
+    id: "partitions";
+    title: string;
+})[];
+export declare const TOPIC_PAGES: ({
+    id: "overview";
+    title: string;
+} | {
+    id: "nodes";
+    title: string;
+} | {
+    id: "describe";
+    title: string;
+} | {
+    id: "consumers";
+    title: string;
+} | {
+    id: "partitions";
+    title: string;
+})[];
+export declare const EXTERNAL_DATA_SOURCE_PAGES: ({
+    id: "overview";
+    title: string;
+} | {
+    id: "describe";
+    title: string;
+})[];
+export declare const EXTERNAL_TABLE_PAGES: ({
+    id: "overview";
+    title: string;
+} | {
+    id: "describe";
+    title: string;
+})[];
+export declare const getPagesByType: (type?: EPathType | undefined) => Page[];
+export {};

package/dist/containers/Tenant/Diagnostics/DiagnosticsPages.js

@@ -0,0 +1,83 @@
+import { TENANT_DIAGNOSTICS_TABS_IDS } from '../../../store/reducers/tenant/constants';
+import { EPathType } from '../../../types/api/schema';
+const overview = {
+    id: TENANT_DIAGNOSTICS_TABS_IDS.overview,
+    title: 'Info',
+};
+const topQueries = {
+    id: TENANT_DIAGNOSTICS_TABS_IDS.topQueries,
+    title: 'Top queries',
+};
+const topShards = {
+    id: TENANT_DIAGNOSTICS_TABS_IDS.topShards,
+    title: 'Top shards',
+};
+const nodes = {
+    id: TENANT_DIAGNOSTICS_TABS_IDS.nodes,
+    title: 'Nodes',
+};
+const tablets = {
+    id: TENANT_DIAGNOSTICS_TABS_IDS.tablets,
+    title: 'Tablets',
+};
+const storage = {
+    id: TENANT_DIAGNOSTICS_TABS_IDS.storage,
+    title: 'Storage',
+};
+const network = {
+    id: TENANT_DIAGNOSTICS_TABS_IDS.network,
+    title: 'Network',
+};
+const describe = {
+    id: TENANT_DIAGNOSTICS_TABS_IDS.describe,
+    title: 'Describe',
+};
+const hotKeys = {
+    id: TENANT_DIAGNOSTICS_TABS_IDS.hotKeys,
+    title: 'Hot keys',
+};
+const graph = {
+    id: TENANT_DIAGNOSTICS_TABS_IDS.graph,
+    title: 'Graph',
+};
+const consumers = {
+    id: TENANT_DIAGNOSTICS_TABS_IDS.consumers,
+    title: 'Consumers',
+};
+const partitions = {
+    id: TENANT_DIAGNOSTICS_TABS_IDS.partitions,
+    title: 'Partitions',
+};
+export const DATABASE_PAGES = [
+    overview,
+    topQueries,
+    topShards,
+    nodes,
+    tablets,
+    storage,
+    network,
+    describe,
+];
+export const TABLE_PAGES = [overview, topShards, nodes, graph, tablets, hotKeys, describe];
+export const DIR_PAGES = [overview, topShards, nodes, describe];
+export const CDC_STREAM_PAGES = [overview, consumers, partitions, nodes, describe];
+export const TOPIC_PAGES = [overview, consumers, partitions, nodes, describe];
+export const EXTERNAL_DATA_SOURCE_PAGES = [overview, describe];
+export const EXTERNAL_TABLE_PAGES = [overview, describe];
+// verbose mapping to guarantee correct tabs for new path types
+// TS will error when a new type is added but not mapped here
+const pathTypeToPages = {
+    [EPathType.EPathTypeInvalid]: undefined,
+    [EPathType.EPathTypeSubDomain]: DATABASE_PAGES,
+    [EPathType.EPathTypeExtSubDomain]: DATABASE_PAGES,
+    [EPathType.EPathTypeColumnStore]: DATABASE_PAGES,
+    [EPathType.EPathTypeTable]: TABLE_PAGES,
+    [EPathType.EPathTypeColumnTable]: TABLE_PAGES,
+    [EPathType.EPathTypeDir]: DIR_PAGES,
+    [EPathType.EPathTypeTableIndex]: DIR_PAGES,
+    [EPathType.EPathTypeCdcStream]: CDC_STREAM_PAGES,
+    [EPathType.EPathTypePersQueueGroup]: TOPIC_PAGES,
+    [EPathType.EPathTypeExternalDataSource]: EXTERNAL_DATA_SOURCE_PAGES,
+    [EPathType.EPathTypeExternalTable]: EXTERNAL_TABLE_PAGES,
+};
+export const getPagesByType = (type) => (type && pathTypeToPages[type]) || DIR_PAGES;

package/dist/containers/Tenant/Diagnostics/HotKeys/HotKeys.d.ts

@@ -0,0 +1,25 @@
+declare var _default: import("react-redux").ConnectedComponent<typeof HotKeys, import("react-redux").Omit<{
+    getHotKeys: any;
+    currentSchemaPath: any;
+    loading: any;
+    wasLoaded: any;
+    error: any;
+    data: any;
+    autorefresh: any;
+    setHotKeysOptions: any;
+    currentSchema: any;
+    type: any;
+}, "data" | "error" | "loading" | "wasLoaded" | "currentSchemaPath" | "autorefresh" | "currentSchema" | "getHotKeys" | "setHotKeysOptions">>;
+export default _default;
+declare function HotKeys({ getHotKeys, currentSchemaPath, loading, wasLoaded, error, data, autorefresh, setHotKeysOptions, currentSchema, type, }: {
+    getHotKeys: any;
+    currentSchemaPath: any;
+    loading: any;
+    wasLoaded: any;
+    error: any;
+    data: any;
+    autorefresh: any;
+    setHotKeysOptions: any;
+    currentSchema: any;
+    type: any;
+}): JSX.Element;