ydb-embedded-ui 6.7.0 → 6.9.0

package/dist/types/api/schema/schema.d.ts

@@ -0,0 +1,258 @@
+import type { TMetrics } from '../tenant';
+import type { TCdcStreamDescription } from './cdcStream';
+import type { TColumnStoreDescription, TColumnTableDescription } from './columnEntity';
+import type { TExternalDataSourceDescription } from './externalDataSource';
+import type { TExternalTableDescription } from './externalTable';
+import type { TPersQueueGroupDescription } from './persQueueGroup';
+import type { TReplicationDescription } from './replication';
+import type { TTableDescription, TTableStats } from './table';
+import type { TIndexDescription } from './tableIndex';
+import type { TViewDescription } from './view';
+/**
+ * source: https://github.com/ydb-platform/ydb/blob/main/ydb/core/protos/flat_tx_scheme.proto
+ */
+export interface TEvDescribeSchemeResult {
+    Status?: EStatus;
+    Reason?: string;
+    Path?: string;
+    PathDescription?: TPathDescription;
+    /** fixed64 */
+    PathOwner?: string;
+    /** fixed64 */
+    PathId?: string;
+    LastExistedPrefixPath?: string;
+    /** fixed64 */
+    LastExistedPrefixPathId?: string;
+    LastExistedPrefixDescription?: TPathDescription;
+    /** fixed64 */
+    PathOwnerId?: string;
+}
+declare enum EStatus {
+    StatusSuccess = "StatusSuccess",
+    StatusAccepted = "StatusAccepted",
+    StatusPathDoesNotExist = "StatusPathDoesNotExist",
+    StatusPathIsNotDirectory = "StatusPathIsNotDirectory",
+    StatusAlreadyExists = "StatusAlreadyExists",
+    StatusSchemeError = "StatusSchemeError",
+    StatusNameConflict = "StatusNameConflict",
+    StatusInvalidParameter = "StatusInvalidParameter",
+    StatusMultipleModifications = "StatusMultipleModifications",
+    StatusReadOnly = "StatusReadOnly",
+    StatusTxIdNotExists = "StatusTxIdNotExists",
+    StatusTxIsNotCancellable = "StatusTxIsNotCancellable",
+    StatusAccessDenied = "StatusAccessDenied",
+    StatusNotAvailable = "StatusNotAvailable",
+    StatusPreconditionFailed = "StatusPreconditionFailed",
+    StatusRedirectDomain = "StatusRedirectDomain",
+    StatusQuotaExceeded = "StatusQuotaExceeded",
+    StatusResourceExhausted = "StatusResourceExhausted"
+}
+/**
+ * source: https://github.com/ydb-platform/ydb/blob/main/ydb/core/protos/flat_scheme_op.proto
+ *
+ * incomplete interface, only currently used fields are covered
+ */
+export interface TPathDescription {
+    /** info about the path itself */
+    Self?: TDirEntry;
+    DomainDescription?: TDomainDescription;
+    UserAttributes?: TUserAttribute[];
+    Children?: TDirEntry[];
+    Table?: TTableDescription;
+    TableStats?: TTableStats;
+    TabletMetrics?: TMetrics;
+    TablePartitions?: TTablePartition[];
+    TablePartitionStats?: TTableStats[];
+    TablePartitionMetrics?: TMetrics[];
+    ColumnStoreDescription?: TColumnStoreDescription;
+    ColumnTableDescription?: TColumnTableDescription;
+    TableIndex?: TIndexDescription;
+    CdcStreamDescription?: TCdcStreamDescription;
+    PersQueueGroup?: TPersQueueGroupDescription;
+    ExternalTableDescription?: TExternalTableDescription;
+    ExternalDataSourceDescription?: TExternalDataSourceDescription;
+    ViewDescription?: TViewDescription;
+    ReplicationDescription?: TReplicationDescription;
+}
+export interface TDirEntry {
+    Name?: string;
+    /** uint64 */
+    PathId?: string;
+    /** uint64 */
+    SchemeshardId?: string;
+    PathType?: EPathType;
+    CreateFinished?: boolean;
+    /** uint64 */
+    CreateTxId?: string;
+    /** uint64 */
+    CreateStep?: string;
+    /** uint64 */
+    ParentPathId?: string;
+    PathState?: EPathState;
+    Owner?: string;
+    ACL?: string;
+    EffectiveACL?: string;
+    /** uint64 */
+    PathVersion?: string;
+    PathSubType?: EPathSubType;
+    Version?: TPathVersion;
+}
+interface TDomainDescription {
+    ProcessingParams?: TProcessingParams;
+    DomainKey?: TDomainKey;
+    StoragePools?: TStoragePool[];
+    /** uint64 */
+    PathsInside?: string;
+    /** uint64 */
+    PathsLimit?: string;
+    /** uint64 */
+    ShardsInside?: string;
+    /** uint64 */
+    ShardsLimit?: string;
+    ResourcesDomainKey?: TDomainKey;
+    DiskSpaceUsage?: TDiskSpaceUsage;
+    /** uint64 */
+    PQPartitionsInside?: string;
+    /** uint64 */
+    PQPartitionsLimit?: string;
+    DomainState?: TDomainState;
+    DeclaredSchemeQuotas?: TSchemeQuotas;
+    DatabaseQuotas?: DatabaseQuotas;
+    SecurityState?: TSecurityState;
+}
+interface TDomainKey {
+    /** fixed64 */
+    SchemeShard?: string;
+    /** fixed64 */
+    PathId?: string;
+}
+interface TProcessingParams {
+    Version?: number;
+    /** uint64 */
+    PlanResolution?: string;
+    /** fixed64 */
+    Coordinators?: string[];
+    /** uint64 */
+    TimeCastBucketsPerMediator?: string;
+    /** fixed64 */
+    Mediators?: string[];
+    /** fixed64 */
+    SchemeShard?: string;
+    /** fixed64 */
+    Hive?: string;
+    /** fixed64 */
+    SysViewProcessor?: string;
+}
+interface TDomainState {
+    DiskQuotaExceeded?: boolean;
+}
+interface TDiskSpaceUsage {
+    Tables?: TTables;
+}
+interface TTables {
+    /** uint64 */
+    TotalSize?: string;
+    /** uint64 */
+    DataSize?: string;
+    /** uint64 */
+    IndexSize?: string;
+}
+interface TStoragePool {
+    Name?: string;
+    Kind?: string;
+}
+interface TSchemeQuotas {
+    SchemeQuotas?: TSchemeQuota[];
+}
+interface TSchemeQuota {
+    /** double */
+    BucketSize?: number;
+    /** uint64 */
+    BucketSeconds?: string;
+}
+interface TSecurityState {
+    PublicKeys?: TPublicKey[];
+    Sids?: TSid[];
+    Audience: string;
+}
+interface TPublicKey {
+    /** uint64 */
+    KeyId: string;
+    KeyDataPEM: string;
+    /** uint64 */
+    ExpiresAt: string;
+}
+interface TSid {
+    Name: string;
+    Type: SidType;
+    Hash: string;
+    Members?: string[];
+}
+declare enum SidType {
+    'UNKNOWN' = "UNKNOWN",
+    'USER' = "USER",
+    'GROUP' = "GROUP"
+}
+interface DatabaseQuotas {
+    /** uint64 */
+    data_size_hard_quota: string;
+    /** uint64 */
+    data_size_soft_quota: string;
+    /** uint64 */
+    data_stream_shards_quota: string;
+    /** uint64 */
+    data_stream_reserved_storage_quota: string;
+    ttl_min_run_internal_seconds: number;
+}
+export declare enum EPathType {
+    EPathTypeInvalid = "EPathTypeInvalid",
+    EPathTypeDir = "EPathTypeDir",
+    EPathTypeTable = "EPathTypeTable",
+    EPathTypePersQueueGroup = "EPathTypePersQueueGroup",
+    EPathTypeSubDomain = "EPathTypeSubDomain",
+    EPathTypeTableIndex = "EPathTypeTableIndex",
+    EPathTypeExtSubDomain = "EPathTypeExtSubDomain",
+    EPathTypeColumnStore = "EPathTypeColumnStore",
+    EPathTypeColumnTable = "EPathTypeColumnTable",
+    EPathTypeCdcStream = "EPathTypeCdcStream",
+    EPathTypeExternalDataSource = "EPathTypeExternalDataSource",
+    EPathTypeExternalTable = "EPathTypeExternalTable",
+    EPathTypeView = "EPathTypeView",
+    EPathTypeReplication = "EPathTypeReplication"
+}
+export declare enum EPathSubType {
+    EPathSubTypeEmpty = "EPathSubTypeEmpty",
+    EPathSubTypeSyncIndexImplTable = "EPathSubTypeSyncIndexImplTable",
+    EPathSubTypeAsyncIndexImplTable = "EPathSubTypeAsyncIndexImplTable",
+    EPathSubTypeStreamImpl = "EPathSubTypeStreamImpl"
+}
+declare enum EPathState {
+    EPathStateNotExist = "EPathStateNotExist",
+    EPathStateNoChanges = "EPathStateNoChanges",
+    EPathStateCreate = "EPathStateCreate",
+    EPathStateAlter = "EPathStateAlter",
+    EPathStateDrop = "EPathStateDrop",
+    EPathStateCopying = "EPathStateCopying",
+    EPathStateBackup = "EPathStateBackup",
+    EPathStateUpgrade = "EPathStateUpgrade",
+    EPathStateMigrated = "EPathStateMigrated",
+    EPathStateRestore = "EPathStateRestore",
+    EPathStateMoving = "EPathStateMoving"
+}
+interface TPathVersion {
+    /** uint64 */
+    GeneralVersion?: string;
+}
+interface TTablePartition {
+    /** bytes */
+    EndOfRangeKeyPrefix?: unknown;
+    IsPoint?: boolean;
+    IsInclusive?: boolean;
+    /** uint64 */
+    DatashardId?: string;
+}
+interface TUserAttribute {
+    Key?: string;
+    Value?: string;
+}
+export {};

package/dist/utils/bytesParsers/formatBytes.js

@@ -0,0 +1,92 @@
+import { GIGABYTE, KILOBYTE, MEGABYTE, TERABYTE } from '../constants';
+import { formatNumber, roundToPrecision } from '../dataFormatters/dataFormatters';
+import { isNumeric } from '../utils';
+import i18n from './i18n';
+const sizes = {
+    b: {
+        value: 1,
+        label: i18n('b'),
+    },
+    kb: {
+        value: KILOBYTE,
+        label: i18n('kb'),
+    },
+    mb: {
+        value: MEGABYTE,
+        label: i18n('mb'),
+    },
+    gb: {
+        value: GIGABYTE,
+        label: i18n('gb'),
+    },
+    tb: {
+        value: TERABYTE,
+        label: i18n('tb'),
+    },
+};
+/**
+ * This function is needed to keep more than 3 digits of the same size.
+ *
+ * @param significantDigits - number of digits above 3
+ * @returns size to format value to get required number of digits
+ *
+ * By default value converted to the next size when it's above 1000,
+ * so we have 900mb and 1gb. To extend it additional significantDigits could be set
+ *
+ * significantDigits value added above default 3
+ *
+ * significantDigits = 1 - 9 000 mb and 10 gb
+ *
+ * significantDigits = 2 - 90 000 mb and 100 gb
+ *
+ * significantDigits = 3 - 900 000 mb and 1000 gb
+ */
+export const getSizeWithSignificantDigits = (value, significantDigits) => {
+    const multiplier = 10 ** significantDigits;
+    const tbLevel = sizes.tb.value * multiplier;
+    const gbLevel = sizes.gb.value * multiplier;
+    const mbLevel = sizes.mb.value * multiplier;
+    const kbLevel = sizes.kb.value * multiplier;
+    let size = 'b';
+    if (value >= kbLevel) {
+        size = 'kb';
+    }
+    if (value >= mbLevel) {
+        size = 'mb';
+    }
+    if (value >= gbLevel) {
+        size = 'gb';
+    }
+    if (value >= tbLevel) {
+        size = 'tb';
+    }
+    return size;
+};
+const formatToSize = ({ value, size = 'mb', precision = 0 }) => {
+    const result = roundToPrecision(Number(value) / sizes[size].value, precision);
+    return formatNumber(result);
+};
+const addSizeLabel = (result, size) => {
+    return result + ` ${sizes[size].label}`;
+};
+const addSpeedLabel = (result, size) => {
+    return addSizeLabel(result, size) + i18n('perSecond');
+};
+/**
+ * @param significantDigits - number of digits above 3
+ */
+export const formatBytes = ({ value, size, withSpeedLabel = false, withSizeLabel = true, significantDigits = 0, ...params }) => {
+    if (!isNumeric(value)) {
+        return '';
+    }
+    const numValue = Number(value);
+    const sizeToConvert = size !== null && size !== void 0 ? size : getSizeWithSignificantDigits(numValue, significantDigits);
+    const result = formatToSize({ value: numValue, size: sizeToConvert, ...params });
+    if (withSpeedLabel) {
+        return addSpeedLabel(result, sizeToConvert);
+    }
+    if (withSizeLabel) {
+        return addSizeLabel(result, sizeToConvert);
+    }
+    return result;
+};

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

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

package/dist/utils/clusterVersionColors.js

@@ -0,0 +1,54 @@
+import uniqBy from 'lodash/uniqBy';
+import { COLORS, GREY_COLOR, getMinorVersion, hashCode } from './versions';
+const UNDEFINED_COLOR_INDEX = '__no_color__';
+export const getVersionMap = (versions, initialMap = new Map()) => {
+    versions.forEach(({ version, version_base_color_index: versionBaseColorIndex = UNDEFINED_COLOR_INDEX }) => {
+        var _a;
+        const minorVersion = getMinorVersion(version);
+        if (!initialMap.has(versionBaseColorIndex)) {
+            initialMap.set(versionBaseColorIndex, new Set());
+        }
+        (_a = initialMap.get(versionBaseColorIndex)) === null || _a === void 0 ? void 0 : _a.add(minorVersion);
+    });
+    return initialMap;
+};
+export const getVersionColors = (versionMap) => {
+    const versionToColor = new Map();
+    for (const [baseColorIndex, item] of versionMap) {
+        Array.from(item)
+            // descending by version name: newer versions come first,
+            // so the newer version gets the brighter color
+            .sort((a, b) => hashCode(b) - hashCode(a))
+            .forEach((minor, minorIndex) => {
+            if (baseColorIndex === UNDEFINED_COLOR_INDEX) {
+                versionToColor.set(minor, GREY_COLOR);
+            }
+            else {
+                // baseColorIndex is numeric as we check if it is UNDEFINED_COLOR_INDEX before
+                const currentColorIndex = Number(baseColorIndex) % COLORS.length;
+                const minorQuantity = item.size;
+                const majorColor = COLORS[currentColorIndex];
+                const opacityPercent = Math.max(100 - minorIndex * (100 / minorQuantity), 20);
+                const hexOpacity = Math.round((opacityPercent * 255) / 100).toString(16);
+                const versionColor = `${majorColor}${hexOpacity}`;
+                versionToColor.set(minor, versionColor);
+            }
+        });
+    }
+    return versionToColor;
+};
+export const prepareClusterVersions = (clusterVersions = [], versionToColor) => {
+    const filteredVersions = clusterVersions.filter((item) => item.version);
+    const preparedVersions = uniqBy(filteredVersions, 'version').map((item) => {
+        return {
+            ...item,
+            minorVersion: getMinorVersion(item.version),
+        };
+    });
+    const versionsColors = preparedVersions.reduce((acc, item) => {
+        const color = versionToColor.get(item.minorVersion);
+        acc.push({ ...item, color });
+        return acc;
+    }, []);
+    return versionsColors;
+};

package/dist/utils/constants.d.ts

@@ -0,0 +1,106 @@
+import type { Settings } from '@gravity-ui/react-data-table';
+export declare const AUTO_RELOAD_INTERVAL: number;
+export declare const DEFAULT_POLLING_INTERVAL: number;
+export declare const KILOBYTE = 1000;
+export declare const MEGABYTE = 1000000;
+export declare const GIGABYTE = 1000000000;
+export declare const TERABYTE = 1000000000000;
+export declare const MINUTE_IN_SECONDS = 60;
+export declare const HOUR_IN_SECONDS: number;
+export declare const DAY_IN_SECONDS: number;
+export declare const MS_IN_NANOSECONDS = 1000000;
+export declare const TABLET_COLORS: {
+    Created: string;
+    ResolveStateStorage: string;
+    Candidate: string;
+    BlockBlobStorage: string;
+    RebuildGraph: string;
+    Restored: string;
+    Discover: string;
+    Lock: string;
+    Dead: string;
+    Active: string;
+};
+export declare const TABLET_SYMBOLS: {
+    OldTxProxy: string;
+    TxProxy: string;
+    BSController: string;
+    Dummy: string;
+    RTMRPartition: string;
+    PersQueueReadBalancer: string;
+    Cms: string;
+    BlockStorePartition: string;
+    BlockStoreVolume: string;
+    Console: string;
+    TenantSlotBroker: string;
+    BlockStoreDiskRegistry: string;
+};
+export declare const getTabletLabel: (type?: string) => string | undefined;
+export declare const LOAD_AVERAGE_TIME_INTERVALS: string[];
+export declare const COLORS_PRIORITY: {
+    green: number;
+    yellow: number;
+    orange: number;
+    red: number;
+    blue: number;
+    grey: number;
+};
+export declare const TENANT_OVERVIEW_TABLES_LIMIT = 5;
+export declare const EMPTY_DATA_PLACEHOLDER = "\u2014";
+export declare const DEVELOPER_UI_TITLE = "Developer UI";
+export declare const CLUSTER_DEFAULT_TITLE = "Cluster";
+export declare const TENANT_DEFAULT_TITLE = "Database";
+export declare const THEME_KEY = "theme";
+export declare const LANGUAGE_KEY = "language";
+export declare const INVERTED_DISKS_KEY = "invertedDisks";
+export declare const USE_NODES_ENDPOINT_IN_DIAGNOSTICS_KEY = "useNodesEndpointInDiagnostics";
+export declare const SAVED_QUERIES_KEY = "saved_queries";
+export declare const ASIDE_HEADER_COMPACT_KEY = "asideHeaderCompact";
+export declare const QUERIES_HISTORY_KEY = "queries_history";
+export declare const DATA_QA_TUNE_COLUMNS_POPUP = "tune-columns-popup";
+export declare const BINARY_DATA_IN_PLAIN_TEXT_DISPLAY = "binaryDataInPlainTextDisplay";
+export declare const AUTO_REFRESH_INTERVAL = "auto-refresh-interval";
+export declare const DEFAULT_SIZE_RESULT_PANE_KEY = "default-size-result-pane";
+export declare const DEFAULT_SIZE_TENANT_SUMMARY_KEY = "default-size-tenant-summary-pane";
+export declare const DEFAULT_SIZE_TENANT_KEY = "default-size-tenant-pane";
+export declare const DEFAULT_IS_TENANT_SUMMARY_COLLAPSED = "default-is-tenant-summary-collapsed";
+export declare const DEFAULT_IS_TENANT_COMMON_INFO_COLLAPSED = "default-is-tenant-common-info-collapsed";
+export declare const DEFAULT_IS_QUERY_RESULT_COLLAPSED = "default-is-query-result-collapsed";
+export declare const DEFAULT_CLUSTER_TAB_KEY = "default-cluster-tab";
+export declare const DEFAULT_TABLE_SETTINGS: Settings;
+export declare const TENANT_OVERVIEW_TABLES_SETTINGS: {
+    readonly stickyHead: "fixed";
+    readonly dynamicRender: false;
+    readonly displayIndices?: boolean;
+    readonly stickyTop?: "auto" | number;
+    readonly syncHeadOnResize?: boolean;
+    readonly stickyFooter?: import("@gravity-ui/react-data-table").HeadPosition;
+    readonly stickyBottom?: "auto" | number;
+    readonly dynamicInnerRef?: import("react").Ref<import("@gravity-ui/react-data-table").DynamicInnerRefT>;
+    readonly dynamicRenderType?: "simple" | "uniform" | "variable";
+    readonly dynamicItemSizeEstimator?: any;
+    readonly dynamicItemSizeGetter?: any;
+    readonly dynamicRenderMinSize?: number;
+    readonly dynamicRenderUseStaticSize?: boolean;
+    readonly dynamicRenderThreshold?: number;
+    readonly dynamicRenderScrollParentGetter?: any;
+    readonly dynamicRenderScrollParentViewportSizeGetter?: () => number;
+    readonly sortable?: boolean;
+    readonly externalSort?: boolean;
+    readonly disableSortReset?: boolean;
+    readonly defaultOrder?: import("@gravity-ui/react-data-table").OrderType;
+    readonly defaultResizeable?: boolean;
+    readonly highlightRows?: boolean;
+    readonly stripedRows?: boolean;
+    readonly headerMod?: "multiline" | "pre";
+};
+export declare const QUERY_INITIAL_MODE_KEY = "query_initial_mode";
+export declare const LAST_USED_QUERY_ACTION_KEY = "last_used_query_action";
+export declare const PARTITIONS_HIDDEN_COLUMNS_KEY = "partitionsHiddenColumns";
+export declare const TENANT_INITIAL_PAGE_KEY = "saved_tenant_initial_tab";
+export declare const USE_BACKEND_PARAMS_FOR_TABLES_KEY = "useBackendParamsForTables";
+export declare const QUERY_USE_MULTI_SCHEMA_KEY = "queryUseMultiSchema";
+export declare const USE_CLUSTER_BALANCER_AS_BACKEND_KEY = "useClusterBalancerAsBacked";
+export declare const ENABLE_AUTOCOMPLETE = "enableAutocomplete";
+export declare const AUTOCOMPLETE_ON_ENTER = "autocompleteOnEnter";
+export declare const IS_HOTKEYS_HELP_HIDDEN_KEY = "isHotKeysHelpHidden";

package/dist/utils/constants.js

@@ -0,0 +1,109 @@
+import DataTable from '@gravity-ui/react-data-table';
+import { EType } from '../types/api/tablet';
+const SECOND = 1000;
+export const AUTO_RELOAD_INTERVAL = 10 * SECOND;
+export const DEFAULT_POLLING_INTERVAL = 30 * 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: 'grey',
+    ResolveStateStorage: 'lightgrey',
+    Candidate: 'lightgrey',
+    BlockBlobStorage: 'lightgrey',
+    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 BINARY_DATA_IN_PLAIN_TEXT_DISPLAY = 'binaryDataInPlainTextDisplay';
+export const AUTO_REFRESH_INTERVAL = 'auto-refresh-interval';
+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_CLUSTER_TAB_KEY = 'default-cluster-tab';
+export const DEFAULT_TABLE_SETTINGS = {
+    displayIndices: false,
+    stickyHead: DataTable.MOVING,
+    syncHeadOnResize: true,
+    dynamicRender: true,
+    highlightRows: true,
+};
+export const TENANT_OVERVIEW_TABLES_SETTINGS = {
+    ...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';
+// 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';
+export const ENABLE_AUTOCOMPLETE = 'enableAutocomplete';
+export const AUTOCOMPLETE_ON_ENTER = 'autocompleteOnEnter';
+export const IS_HOTKEYS_HELP_HIDDEN_KEY = 'isHotKeysHelpHidden';

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

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

package/dist/utils/disks/constants.js

@@ -0,0 +1,38 @@
+import { TPDiskState } from '../../types/api/pdisk';
+import { EVDiskState } from '../../types/api/vdisk';
+// state to numbers to allow ordinal comparison
+export const DISK_COLOR_STATE_TO_NUMERIC_SEVERITY = {
+    Grey: 0,
+    Green: 1,
+    Blue: 2,
+    Yellow: 3,
+    Orange: 4,
+    Red: 5,
+};
+export const DISK_NUMERIC_SEVERITY_TO_STATE_COLOR = Object.entries(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY).reduce((acc, [color, severity]) => ({ ...acc, [severity]: color }), {});
+export const NOT_AVAILABLE_SEVERITY = DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Grey;
+export const NOT_AVAILABLE_SEVERITY_COLOR = DISK_NUMERIC_SEVERITY_TO_STATE_COLOR[NOT_AVAILABLE_SEVERITY];
+export const VDISK_STATE_SEVERITY = {
+    [EVDiskState.OK]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Green,
+    [EVDiskState.Initial]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Yellow,
+    [EVDiskState.SyncGuidRecovery]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Yellow,
+    [EVDiskState.LocalRecoveryError]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Red,
+    [EVDiskState.SyncGuidRecoveryError]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Red,
+    [EVDiskState.PDiskError]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Red,
+};
+export const PDISK_STATE_SEVERITY = {
+    [TPDiskState.Initial]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Grey,
+    [TPDiskState.Normal]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Green,
+    [TPDiskState.InitialFormatRead]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Yellow,
+    [TPDiskState.InitialSysLogRead]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Yellow,
+    [TPDiskState.InitialCommonLogRead]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Yellow,
+    [TPDiskState.InitialFormatReadError]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Red,
+    [TPDiskState.InitialSysLogReadError]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Red,
+    [TPDiskState.InitialSysLogParseError]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Red,
+    [TPDiskState.InitialCommonLogReadError]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Red,
+    [TPDiskState.InitialCommonLogParseError]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Red,
+    [TPDiskState.CommonLoggerInitError]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Red,
+    [TPDiskState.OpenFileError]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Red,
+    [TPDiskState.ChunkQuotaError]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Red,
+    [TPDiskState.DeviceIoError]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Red,
+};