ydb-embedded-ui 5.4.0 → 5.5.0

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

@@ -0,0 +1,11 @@
+import type { TEvPDiskStateResponse } from '../../../types/api/pdisk';
+import type { TStorageInfo } from '../../../types/api/storage';
+import type { TEvSystemStateResponse } from '../../../types/api/systemState';
+import type { TEvVDiskStateResponse } from '../../../types/api/vdisk';
+import type { VDiskData } from './types';
+export declare function prepareVDiskDataResponse([vDiskResponse, pDiskResponse, nodeResponse]: [
+    TEvVDiskStateResponse,
+    TEvPDiskStateResponse,
+    TEvSystemStateResponse
+]): VDiskData;
+export declare function prepareVDiskGroupResponse(data: TStorageInfo, poolName: string, groupId: number): import("../storage/types").PreparedStorageGroup | undefined;

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

@@ -0,0 +1,33 @@
+import { preparePDiskData, prepareVDiskData } from '../../../utils/disks/prepareDisks';
+import { prepareNodeSystemState } from '../../../utils/nodes';
+import { prepareStorageGroupData } from '../storage/utils';
+export function prepareVDiskDataResponse([vDiskResponse, pDiskResponse, nodeResponse]) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const rawVDisk = (_a = vDiskResponse.VDiskStateInfo) === null || _a === void 0 ? void 0 : _a[0];
+    const preparedVDisk = prepareVDiskData(rawVDisk);
+    const rawPDisk = (_b = pDiskResponse.PDiskStateInfo) === null || _b === void 0 ? void 0 : _b[0];
+    const preparedPDisk = preparePDiskData(rawPDisk);
+    const rawNode = (_c = nodeResponse.SystemStateInfo) === null || _c === void 0 ? void 0 : _c[0];
+    const preparedNode = prepareNodeSystemState(rawNode);
+    const NodeId = (_e = (_d = preparedVDisk.NodeId) !== null && _d !== void 0 ? _d : preparedPDisk.NodeId) !== null && _e !== void 0 ? _e : preparedNode.NodeId;
+    const NodeHost = preparedNode.Host;
+    const NodeType = (_f = preparedNode.Roles) === null || _f === void 0 ? void 0 : _f[0];
+    const NodeDC = preparedNode.DC;
+    const PDiskId = (_g = preparedVDisk.PDiskId) !== null && _g !== void 0 ? _g : preparedPDisk.PDiskId;
+    const PDiskType = preparedPDisk.Type;
+    return Object.assign(Object.assign({}, preparedVDisk), { NodeId,
+        NodeHost,
+        NodeType,
+        NodeDC,
+        PDiskId,
+        PDiskType });
+}
+export function prepareVDiskGroupResponse(data, poolName, groupId) {
+    var _a, _b;
+    const rawPoolData = (_a = data.StoragePools) === null || _a === void 0 ? void 0 : _a.find((pool) => pool.Name === poolName);
+    const rawGroupData = (_b = rawPoolData === null || rawPoolData === void 0 ? void 0 : rawPoolData.Groups) === null || _b === void 0 ? void 0 : _b.find((group) => group.GroupID === groupId);
+    if (rawGroupData && rawPoolData) {
+        return prepareStorageGroupData(rawGroupData, rawPoolData);
+    }
+    return undefined;
+}

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

@@ -0,0 +1,100 @@
+import type { Reducer } from '@reduxjs/toolkit';
+import type { VDiskAction, VDiskState } from './types';
+export declare const FETCH_VDISK: {
+    readonly REQUEST: "vdisk/FETCH_VDISK_REQUEST";
+    readonly SUCCESS: "vdisk/FETCH_VDISK_SUCCESS";
+    readonly FAILURE: "vdisk/FETCH_VDISK_FAILURE";
+};
+declare const vdisk: Reducer<VDiskState, VDiskAction>;
+export declare const setVDiskDataWasNotLoaded: () => {
+    readonly type: "vdisk/SET_VDISK_DATA_WAS_NOT_LOADED";
+};
+interface VDiskDataRequestParams {
+    nodeId: number | string;
+    pDiskId: number | string;
+    vDiskSlotId: number | string;
+}
+export declare const getVDiskData: (params: VDiskDataRequestParams) => (dispatch: import("redux").Dispatch<import("redux").UnknownAction>, getState: () => {
+    singleClusterMode: boolean;
+    nodes: import("../nodes/types").NodesState;
+    topNodesByLoad: import("../tenantOverview/topNodesByLoad/types").TopNodesByLoadState;
+    topNodesByCpu: import("../tenantOverview/topNodesByCpu/types").TopNodesByCpuState;
+    topNodesByMemory: import("../tenantOverview/topNodesByMemory/types").TopNodesByMemoryState;
+    cluster: import("../cluster/types").ClusterState;
+    clusterNodes: import("../clusterNodes/types").ClusterNodesState;
+    tenant: import("../tenant/types").TenantState;
+    storage: import("../storage/types").StorageState;
+    topStorageGroups: import("../tenantOverview/topStorageGroups/types").TopStorageGroupsState;
+    node: import("../node/types").NodeState;
+    tooltip: import("../../../types/store/tooltip").ITooltipState;
+    tablets: import("../../../types/store/tablets").ITabletsState;
+    schema: import("../schema/types").SchemaState;
+    overview: import("../overview/types").OverviewState;
+    olapStats: import("../../../types/store/olapStats").OlapStatsState;
+    host: import("../../../types/store/host").IHostState;
+    network: import("../network/types").NetworkState;
+    tenants: import("../tenants/types").TenantsState;
+    tablet: import("../../../types/store/tablet").ITabletState;
+    topic: import("../../../types/store/topic").ITopicState;
+    partitions: import("../partitions/types").PartitionsState;
+    pDisk: import("../pdisk/types").PDiskState;
+    executeQuery: import("../../../types/store/executeQuery").ExecuteQueryState;
+    explainQuery: import("../../../types/store/explainQuery").ExplainQueryState;
+    tabletsFilters: {
+        loading: boolean;
+        requestTime: number;
+        data: undefined;
+        wasLoaded: boolean;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        tabletsData: any;
+        nodes: any;
+        loading: boolean;
+        wasLoaded: boolean;
+        timeoutForRequest: number;
+        error: undefined;
+        data: undefined;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        error: any;
+        loading: boolean;
+        data: undefined;
+        wasLoaded: boolean;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        stateFilter: any;
+        data: undefined;
+        loading: boolean;
+        wasLoaded: boolean;
+        typeFilter: never[];
+    } | {
+        typeFilter: any;
+        data: undefined;
+        loading: boolean;
+        wasLoaded: boolean;
+        stateFilter: never[];
+    };
+    heatmap: import("../../../types/store/heatmap").IHeatmapState;
+    settings: import("../settings/types").SettingsState;
+    preview: any;
+    nodesList: import("../../../types/store/nodesList").NodesListState;
+    describe: import("../../../types/store/describe").IDescribeState;
+    schemaAcl: import("../schemaAcl/types").SchemaAclState;
+    executeTopQueries: import("../executeTopQueries/types").ITopQueriesState;
+    executeTopTables: import("../tenantOverview/executeTopTables/types").TopTablesState;
+    tenantOverviewTopQueries: import("../tenantOverview/topQueries/types").TenantOverviewTopQueriesState;
+    healthcheckInfo: import("../healthcheckInfo/types").HealthcheckInfoState;
+    shardsWorkload: import("../shardsWorkload/types").IShardsWorkloadState;
+    tenantOverviewTopShards: import("../tenantOverview/topShards/types").TenantOverviewTopShardsState;
+    hotKeys: import("../hotKeys/types").HotKeysState;
+    authentication: import("../authentication/types").AuthenticationState;
+    header: import("../header/types").HeaderState;
+    saveQuery: string | null;
+    fullscreen: boolean;
+    clusters: import("../clusters/types").ClustersState;
+    vDisk: VDiskState;
+}) => Promise<unknown>;
+export default vdisk;

package/dist/store/reducers/vdisk/vdisk.js

@@ -0,0 +1,64 @@
+import { EVersion } from '../../../types/api/storage';
+import { valueIsDefined } from '../../../utils';
+import { createRequestActionTypes, createApiRequest } from '../../utils';
+import { prepareVDiskDataResponse, prepareVDiskGroupResponse } from './utils';
+export const FETCH_VDISK = createRequestActionTypes('vdisk', 'FETCH_VDISK');
+const SET_VDISK_DATA_WAS_NOT_LOADED = 'vdisk/SET_VDISK_DATA_WAS_NOT_LOADED';
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+    vDiskData: {},
+};
+const vdisk = (state = initialState, action) => {
+    switch (action.type) {
+        case FETCH_VDISK.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_VDISK.SUCCESS: {
+            const { vDiskData, groupData } = action.data;
+            return Object.assign(Object.assign({}, state), { vDiskData,
+                groupData, loading: false, wasLoaded: true, error: undefined });
+        }
+        case FETCH_VDISK.FAILURE: {
+            return Object.assign(Object.assign({}, state), { error: action.error, loading: false });
+        }
+        case SET_VDISK_DATA_WAS_NOT_LOADED: {
+            return Object.assign(Object.assign({}, state), { wasLoaded: false });
+        }
+        default:
+            return state;
+    }
+};
+export const setVDiskDataWasNotLoaded = () => {
+    return {
+        type: SET_VDISK_DATA_WAS_NOT_LOADED,
+    };
+};
+const requestVDiskData = async ({ nodeId, pDiskId, vDiskSlotId }) => {
+    const vDiskDataResponse = await Promise.all([
+        window.api.getVdiskInfo({ nodeId, pDiskId, vDiskSlotId }),
+        window.api.getPdiskInfo(nodeId, pDiskId),
+        window.api.getNodeInfo(nodeId),
+    ]);
+    const vDiskData = prepareVDiskDataResponse(vDiskDataResponse);
+    const { StoragePoolName, VDiskId = {} } = vDiskData;
+    const { GroupID } = VDiskId;
+    let groupData;
+    if (valueIsDefined(StoragePoolName) && valueIsDefined(GroupID)) {
+        const groupResponse = await window.api.getStorageInfo({
+            nodeId,
+            poolName: StoragePoolName,
+            groupId: GroupID,
+            version: EVersion.v1,
+        });
+        groupData = prepareVDiskGroupResponse(groupResponse, StoragePoolName, GroupID);
+    }
+    return { vDiskData, groupData };
+};
+export const getVDiskData = (params) => {
+    return createApiRequest({
+        request: requestVDiskData(params),
+        actions: FETCH_VDISK,
+    });
+};
+export default vdisk;

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

@@ -1,7 +1,9 @@
 import { __rest } from "tslib";
 import { createReduxLocationActions } from 'redux-location-state';
 import qs from 'qs';
-import _ from 'lodash';
+import each from 'lodash/each';
+import keys from 'lodash/keys';
+import merge from 'lodash/merge';
 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';
@@ -81,7 +83,7 @@ const paramSetup = {
     },
 };
 function mergeLocationToState(state, location) {
-    return _.merge({}, state, location.query);
+    return merge({}, state, location.query);
 }
 function restoreUnknownParams(location, prevLocation) {
     const { search } = location, rest = __rest(location, ["search"]);
@@ -90,11 +92,11 @@ function restoreUnknownParams(location, prevLocation) {
     const declaredPath = getMatchingDeclaredPath(paramSetup, location);
     const entries = declaredPath && paramSetup[declaredPath];
     // remove params which are mapped for this page
-    _.each(_.keys(entries), (param) => {
+    each(keys(entries), (param) => {
         delete params[param];
     });
     // and globally
-    _.each(_.keys(paramSetup.global || {}), (param) => {
+    each(keys(paramSetup.global || {}), (param) => {
         delete params[param];
     });
     const restoredParams = qs.stringify(params, { encoder: encodeURIComponent });

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

@@ -31,10 +31,12 @@ export interface TStoragePoolInfo {
     MaximumThroughput?: string;
     /** uint64 */
     MaximumSize?: string;
+    MediaType?: string;
 }
 export interface TStorageGroupInfoV2 extends TStorageGroupInfo {
     PoolName?: string;
     Kind?: string;
+    MediaType?: string;
     /** uint64 */
     Degraded?: string;
     /** uint64 */

package/dist/utils/bytesParsers/__test__/formatBytes.test.js

@@ -8,21 +8,21 @@ describe('formatBytes', () => {
         expect(formatBytes({ value: 100000000000000 })).toBe('100 TB');
     });
     it('should convert to size', () => {
-        expect(formatBytes({ value: 100000, size: 'b' })).toBe('100,000 B');
-        expect(formatBytes({ value: 100000000000000, size: 'gb' })).toBe('100,000 GB');
+        expect(formatBytes({ value: 100000, size: 'b' })).toBe('100 000 B');
+        expect(formatBytes({ value: 100000000000000, size: 'gb' })).toBe('100 000 GB');
     });
     it('should convert without labels', () => {
-        expect(formatBytes({ value: 100000, size: 'b', withSizeLabel: false })).toBe('100,000');
-        expect(formatBytes({ value: 100000000000000, size: 'gb', withSizeLabel: false })).toBe('100,000');
+        expect(formatBytes({ value: 100000, size: 'b', withSizeLabel: false })).toBe('100 000');
+        expect(formatBytes({ value: 100000000000000, size: 'gb', withSizeLabel: false })).toBe('100 000');
     });
     it('should convert to speed', () => {
         expect(formatBytes({ value: 100000, withSpeedLabel: true })).toBe('100 KB/s');
-        expect(formatBytes({ value: 100000, size: 'b', withSpeedLabel: true })).toBe('100,000 B/s');
+        expect(formatBytes({ value: 100000, size: 'b', withSpeedLabel: true })).toBe('100 000 B/s');
     });
     it('should return fixed amount of significant digits', () => {
-        expect(formatBytes({ value: 99000, significantDigits: 2 })).toEqual('99,000 B');
+        expect(formatBytes({ value: 99000, significantDigits: 2 })).toEqual('99 000 B');
         expect(formatBytes({ value: 100000, significantDigits: 2 })).toEqual('100 KB');
-        expect(formatBytes({ value: 99000000000000, significantDigits: 2 })).toEqual('99,000 GB');
+        expect(formatBytes({ value: 99000000000000, significantDigits: 2 })).toEqual('99 000 GB');
         expect(formatBytes({ value: 100000000000000, significantDigits: 2 })).toEqual('100 TB');
     });
     it('should return empty string on invalid data', () => {

package/dist/utils/clusterVersionColors.js

@@ -1,4 +1,4 @@
-import { uniqBy } from 'lodash';
+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()) => {

package/dist/utils/dataFormatters/dataFormatters.js

@@ -68,6 +68,7 @@ export const formatNumber = (number) => {
     if (!isNumeric(number)) {
         return '';
     }
+    // "," in format is delimiter sign, not delimiter itself
     return configuredNumeral(number).format('0,0.[00000]');
 };
 export const roundToPrecision = (value, precision = 0) => {

package/dist/utils/disks/constants.js

@@ -13,12 +13,12 @@ export const DISK_NUMERIC_SEVERITY_TO_STATE_COLOR = Object.entries(DISK_COLOR_ST
 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.SyncGuidRecovery]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Yellow,
     [EVDiskState.PDiskError]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Red,
-    [EVDiskState.OK]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Green,
 };
 export const PDISK_STATE_SEVERITY = {
     [TPDiskState.Initial]: DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Grey,

package/dist/utils/disks/types.d.ts

@@ -1,5 +1,5 @@
 import type { TPDiskStateInfo } from '../../types/api/pdisk';
-import type { TVDiskStateInfo } from '../../types/api/vdisk';
+import type { TVDiskStateInfo, TVSlotId } from '../../types/api/vdisk';
 import type { ValueOf } from '../../types/common';
 import type { PDISK_TYPES } from './getPDiskType';
 export interface PreparedPDisk extends TPDiskStateInfo {
@@ -13,3 +13,7 @@ export interface PreparedVDisk extends TVDiskStateInfo {
     Severity?: number;
 }
 export type PDiskType = ValueOf<typeof PDISK_TYPES>;
+export interface UnavailableDonor extends TVSlotId {
+    DonorMode?: boolean;
+    StoragePoolName?: string;
+}

package/dist/utils/filters.js

@@ -1,4 +1,4 @@
-import { escapeRegExp } from 'lodash';
+import escapeRegExp from 'lodash/escapeRegExp';
 import { DESCENDING } from '@gravity-ui/react-data-table/build/esm/lib/constants';
 export const prepareSortValue = (sortValue, sortOrder = DESCENDING) => {
     if (!sortValue) {

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

@@ -1,5 +1,5 @@
 import type { Column as DataTableColumn } from '@gravity-ui/react-data-table';
-import type { Column as VirtualTableColumn } from '../../components/VirtualTable';
+import { type Column as VirtualTableColumn } from '../../components/VirtualTable';
 export type Column<T> = VirtualTableColumn<T> & DataTableColumn<T>;
 export type TableColumnsWidthSetup = Record<string, number>;
 export type HandleTableColumnsResize = (newSetup: TableColumnsWidthSetup) => void;

package/dist/utils/hooks/useTableResize.js

@@ -1,12 +1,14 @@
 import { useCallback, useState } from 'react';
+import { DEFAULT_RESIZEABLE } from '../../components/VirtualTable';
 import { settingsManager } from '../../services/settings';
 export const updateColumnsWidth = (columns, columnsWidthSetup) => {
     return columns.map((column) => {
-        var _a;
-        if (!column.resizeable) {
+        var _a, _b;
+        const resizeable = (_a = column.resizeable) !== null && _a !== void 0 ? _a : DEFAULT_RESIZEABLE;
+        if (!resizeable) {
             return column;
         }
-        return Object.assign(Object.assign({}, column), { width: (_a = columnsWidthSetup[column.name]) !== null && _a !== void 0 ? _a : column.width });
+        return Object.assign(Object.assign({}, column), { width: (_b = columnsWidthSetup[column.name]) !== null && _b !== void 0 ? _b : column.width });
     });
 };
 export const useTableResize = (localStorageKey) => {

package/dist/utils/lazyComponent.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+export declare function lazyComponent<TExports extends {
+    [key: string]: any;
+}, TKey extends keyof TExports>(moduleLoader: () => Promise<TExports>, exportName: TKey, loader?: React.ReactNode): React.ForwardRefExoticComponent<React.PropsWithoutRef<React.ComponentProps<TExports[TKey]>> & React.RefAttributes<TExports[TKey]>>;

package/dist/utils/lazyComponent.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from 'react';
+import { Loader } from '@gravity-ui/uikit';
+import { ErrorBoundaryFallback } from '../components/ErrorBoundary/ErrorBoundary';
+import { useComponent } from '../components/ComponentsProvider/ComponentsProvider';
+export function lazyComponent(moduleLoader, exportName, loader) {
+    const Component = React.lazy(() => moduleLoader()
+        .then((module) => ({ default: module[exportName] }))
+        .catch((error) => ({ default: () => _jsx(ErrorBoundaryFallback, { error: error }) })));
+    const LazyComponent = (props, ref) => {
+        const ErrorBoundary = useComponent('ErrorBoundary');
+        return (_jsx(ErrorBoundary, { children: _jsx(React.Suspense, Object.assign({ fallback: loader !== null && loader !== void 0 ? loader : _jsx(DefaultLoader, {}) }, { children: _jsx(Component, Object.assign({ ref: ref }, props)) })) }));
+    };
+    LazyComponent.displayName = exportName;
+    return React.forwardRef(LazyComponent);
+}
+function DefaultLoader() {
+    return (_jsx("div", Object.assign({ style: {
+            width: '100%',
+            height: '100%',
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'center',
+        } }, { children: _jsx(Loader, { size: "l" }) })));
+}

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

@@ -0,0 +1 @@
+export declare function registerLanguages(): void;

package/dist/utils/monaco/index.js

@@ -0,0 +1,4 @@
+import { registerSExpressionLanguage } from './s-expression/registerLanguage';
+export function registerLanguages() {
+    registerSExpressionLanguage();
+}

package/dist/utils/monaco/s-expression/constants.d.ts

@@ -0,0 +1 @@
+export declare const LANGUAGE_S_EXPRESSION_ID = "s-expression";

package/dist/utils/monaco/s-expression/constants.js

@@ -0,0 +1 @@
+export const LANGUAGE_S_EXPRESSION_ID = 's-expression';

package/dist/utils/monaco/s-expression/registerLanguage.d.ts

@@ -0,0 +1 @@
+export declare function registerSExpressionLanguage(): void;

package/dist/utils/{monaco.js → monaco/s-expression/registerLanguage.js}

@@ -1,7 +1,6 @@
 import * as monaco from 'monaco-editor';
-import { createProvideSuggestionsFunction } from './yqlSuggestions/yqlSuggestions';
-export const LANGUAGE_S_EXPRESSION_ID = 's-expression';
-function registerSExpressionLanguage() {
+import { LANGUAGE_S_EXPRESSION_ID } from './constants';
+export function registerSExpressionLanguage() {
     monaco.languages.register({ id: LANGUAGE_S_EXPRESSION_ID });
     monaco.languages.setMonarchTokensProvider(LANGUAGE_S_EXPRESSION_ID, {
         defaultToken: 'text',
@@ -58,19 +57,3 @@ function registerSExpressionLanguage() {
         },
     });
 }
-let completionProvider;
-function disableCodeSuggestions() {
-    if (completionProvider) {
-        completionProvider.dispose();
-    }
-}
-export function registerYQLCompletionItemProvider(database) {
-    disableCodeSuggestions();
-    completionProvider = monaco.languages.registerCompletionItemProvider('sql', {
-        triggerCharacters: [' ', '\n', '', ',', '.', '`', '('],
-        provideCompletionItems: createProvideSuggestionsFunction(database),
-    });
-}
-export function registerLanguages() {
-    registerSExpressionLanguage();
-}

package/dist/utils/{yqlSuggestions → monaco/yqlSuggestions}/generateSuggestions.d.ts

@@ -1,5 +1,5 @@
-import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
-import { ColumnAliasSuggestion, KeywordSuggestion, YqlAutocompleteResult } from '@gravity-ui/websql-autocomplete';
+import type * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+import type { ColumnAliasSuggestion, KeywordSuggestion, YqlAutocompleteResult } from '@gravity-ui/websql-autocomplete';
 export declare function generateColumnsSuggestion(rangeToInsertSuggestion: monaco.IRange, suggestColumns: YqlAutocompleteResult['suggestColumns'] | undefined, database: string): Promise<monaco.languages.CompletionItem[]>;
 export declare function generateColumnAliasesSuggestion(rangeToInsertSuggestion: monaco.IRange, suggestColumnAliases?: ColumnAliasSuggestion[]): {
     label: string;

package/dist/utils/{yqlSuggestions → monaco/yqlSuggestions}/generateSuggestions.js

@@ -1,5 +1,34 @@
-import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 import { AggregateFunctions, Pragmas, SimpleFunctions, SimpleTypes, TableFunction, Udfs, WindowFunctions, } from './constants';
+const CompletionItemKind = {
+    Method: 0,
+    Function: 1,
+    Constructor: 2,
+    Field: 3,
+    Variable: 4,
+    Class: 5,
+    Struct: 6,
+    Interface: 7,
+    Module: 8,
+    Property: 9,
+    Event: 10,
+    Operator: 11,
+    Unit: 12,
+    Value: 13,
+    Constant: 14,
+    Enum: 15,
+    EnumMember: 16,
+    Keyword: 17,
+    Text: 18,
+    Color: 19,
+    File: 20,
+    Reference: 21,
+    Customcolor: 22,
+    Folder: 23,
+    TypeParameter: 24,
+    User: 25,
+    Issue: 26,
+    Snippet: 27,
+};
 const re = /[\s'"-/@]/;
 function wrapStringToBackticks(value) {
     let result = value;
@@ -124,7 +153,7 @@ export async function generateColumnsSuggestion(rangeToInsertSuggestion, suggest
             suggestions.push({
                 label: columnNameSuggestion,
                 insertText: columnNameSuggestion,
-                kind: monaco.languages.CompletionItemKind.Field,
+                kind: CompletionItemKind.Field,
                 detail: 'Column',
                 range: rangeToInsertSuggestion,
                 sortText: suggestionIndexToWeight(getSuggestionIndex('suggestColumns')),
@@ -140,7 +169,7 @@ export function generateColumnAliasesSuggestion(rangeToInsertSuggestion, suggest
     return suggestColumnAliases === null || suggestColumnAliases === void 0 ? void 0 : suggestColumnAliases.map((columnAliasSuggestion) => ({
         label: columnAliasSuggestion.name,
         insertText: columnAliasSuggestion.name,
-        kind: monaco.languages.CompletionItemKind.Field,
+        kind: CompletionItemKind.Field,
         detail: 'Column alias',
         range: rangeToInsertSuggestion,
         sortText: suggestionIndexToWeight(getSuggestionIndex('suggestColumnAliases')),
@@ -153,7 +182,7 @@ export function generateKeywordsSuggestion(rangeToInsertSuggestion, suggestKeywo
     return suggestKeywords === null || suggestKeywords === void 0 ? void 0 : suggestKeywords.map((keywordSuggestion) => ({
         label: keywordSuggestion.value,
         insertText: keywordSuggestion.value,
-        kind: monaco.languages.CompletionItemKind.Keyword,
+        kind: CompletionItemKind.Keyword,
         detail: 'Keyword',
         range: rangeToInsertSuggestion,
         sortText: suggestionIndexToWeight(getSuggestionIndex('suggestKeywords')),
@@ -167,7 +196,7 @@ export async function generateSimpleFunctionsSuggestion(rangeToInsertSuggestion)
     return functions.map((el) => ({
         label: el,
         insertText: el,
-        kind: monaco.languages.CompletionItemKind.Function,
+        kind: CompletionItemKind.Function,
         detail: 'Function',
         range: rangeToInsertSuggestion,
         sortText: suggestionIndexToWeight(getSuggestionIndex('suggestFunctions')),
@@ -178,7 +207,7 @@ export async function generateSimpleTypesSuggestion(rangeToInsertSuggestion) {
     return simpleTypes.map((el) => ({
         label: el,
         insertText: el,
-        kind: monaco.languages.CompletionItemKind.TypeParameter,
+        kind: CompletionItemKind.TypeParameter,
         detail: 'Type',
         range: rangeToInsertSuggestion,
         sortText: suggestionIndexToWeight(getSuggestionIndex('suggestSimpleTypes')),
@@ -189,7 +218,7 @@ export async function generateUdfSuggestion(rangeToInsertSuggestion) {
     return udfs.map((el) => ({
         label: el,
         insertText: el,
-        kind: monaco.languages.CompletionItemKind.Function,
+        kind: CompletionItemKind.Function,
         detail: 'UDF',
         range: rangeToInsertSuggestion,
         sortText: suggestionIndexToWeight(getSuggestionIndex('suggestUdfs')),
@@ -200,7 +229,7 @@ export async function generateWindowFunctionsSuggestion(rangeToInsertSuggestion)
     return windowFunctions.map((el) => ({
         label: el,
         insertText: el,
-        kind: monaco.languages.CompletionItemKind.Function,
+        kind: CompletionItemKind.Function,
         detail: 'Window function',
         range: rangeToInsertSuggestion,
         sortText: suggestionIndexToWeight(getSuggestionIndex('suggestWindowFunctions')),
@@ -211,7 +240,7 @@ export async function generateTableFunctionsSuggestion(rangeToInsertSuggestion)
     return tableFunctions.map((el) => ({
         label: el,
         insertText: el,
-        kind: monaco.languages.CompletionItemKind.Function,
+        kind: CompletionItemKind.Function,
         detail: 'Table function',
         range: rangeToInsertSuggestion,
         sortText: suggestionIndexToWeight(getSuggestionIndex('suggestTableFunctions')),
@@ -222,7 +251,7 @@ export async function generateAggregateFunctionsSuggestion(rangeToInsertSuggesti
     return aggreagteFunctions.map((el) => ({
         label: el,
         insertText: el,
-        kind: monaco.languages.CompletionItemKind.Function,
+        kind: CompletionItemKind.Function,
         detail: 'Aggregate function',
         range: rangeToInsertSuggestion,
         sortText: suggestionIndexToWeight(getSuggestionIndex('suggestAggregateFunctions')),
@@ -233,7 +262,7 @@ export async function generatePragmasSuggestion(rangeToInsertSuggestion) {
     return pragmas.map((el) => ({
         label: el,
         insertText: el,
-        kind: monaco.languages.CompletionItemKind.Module,
+        kind: CompletionItemKind.Module,
         detail: 'Pragma',
         range: rangeToInsertSuggestion,
         sortText: suggestionIndexToWeight(getSuggestionIndex('suggestPragmas')),

package/dist/utils/monaco/yqlSuggestions/registerCompletionItemProvider.d.ts

@@ -0,0 +1 @@
+export declare function registerYQLCompletionItemProvider(database: string): void;

package/dist/utils/monaco/yqlSuggestions/registerCompletionItemProvider.js

@@ -0,0 +1,15 @@
+import * as monaco from 'monaco-editor';
+import { createProvideSuggestionsFunction } from './yqlSuggestions';
+let completionProvider;
+function disableCodeSuggestions() {
+    if (completionProvider) {
+        completionProvider.dispose();
+    }
+}
+export function registerYQLCompletionItemProvider(database) {
+    disableCodeSuggestions();
+    completionProvider = monaco.languages.registerCompletionItemProvider('sql', {
+        triggerCharacters: [' ', '\n', '', ',', '.', '`', '('],
+        provideCompletionItems: createProvideSuggestionsFunction(database),
+    });
+}

package/dist/utils/{yqlSuggestions → monaco/yqlSuggestions}/yqlSuggestions.js

@@ -1,4 +1,3 @@
-import { parseYqlQuery } from '@gravity-ui/websql-autocomplete';
 import { generateAggregateFunctionsSuggestion, generateColumnAliasesSuggestion, generateColumnsSuggestion, generateEntitiesSuggestion, generateKeywordsSuggestion, generatePragmasSuggestion, generateSimpleFunctionsSuggestion, generateSimpleTypesSuggestion, generateTableFunctionsSuggestion, generateUdfSuggestion, generateWindowFunctionsSuggestion, } from './generateSuggestions';
 export function createProvideSuggestionsFunction(database) {
     return async (model, monacoCursorPosition, _context, _token) => {
@@ -12,6 +11,7 @@ export function createProvideSuggestionsFunction(database) {
     };
 }
 async function getSuggestions(model, cursorPosition, rangeToInsertSuggestion, database) {
+    const { parseYqlQuery } = await import('@gravity-ui/websql-autocomplete');
     const parseResult = parseYqlQuery(model.getValue(), cursorPosition);
     let entitiesSuggestions = [];
     let functionsSuggestions = [];

package/dist/utils/numeral.js

@@ -1,5 +1,11 @@
 import numeral from 'numeral';
 import 'numeral/locales'; // Without this numeral will throw an error when using not 'en' locale
-import { i18n } from './i18n';
+import { Lang, i18n } from './i18n';
+// Set space delimiter for all locales possible in project
+Object.values(Lang).forEach((value) => {
+    if (numeral.locales[value]) {
+        numeral.locales[value].delimiters.thousands = ' ';
+    }
+});
 numeral.locale(i18n.lang);
 export const configuredNumeral = numeral;

package/dist/utils/storage.d.ts

@@ -12,6 +12,7 @@ export declare const getUsage: <T extends EntityWithUsage>(data: T, step?: numbe
 export declare const STORAGE_SORT_VALUES: {
     readonly PoolName: "PoolName";
     readonly Kind: "Kind";
+    readonly MediaType: "MediaType";
     readonly Erasure: "Erasure";
     readonly Degraded: "Degraded";
     readonly Usage: "Usage";