ydb-embedded-ui 6.11.0 → 6.13.0

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

@@ -2,12 +2,7 @@ import type { TVDiskID, TVSlotId } from '../../types/api/vdisk';
 import type { BytesSizes } from '../bytesParsers/formatBytes';
 export declare const formatBytes: (bytes?: string | number) => string;
 export declare const formatBps: (bytes?: string | number) => string;
-export declare const formatBytesToGigabyte: (bytes: number | string) => string;
 export declare const stringifyVdiskId: (id?: TVDiskID | TVSlotId) => 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) => string | 0 | undefined;
 export declare const formatStorageValues: (value?: number, total?: number, size?: BytesSizes) => string[];

package/dist/utils/dataFormatters/dataFormatters.js

@@ -1,6 +1,6 @@
 import { dateTimeParse } from '@gravity-ui/date-utils';
 import { formatBytes as formatBytesCustom, getSizeWithSignificantDigits, } from '../bytesParsers/formatBytes';
-import { DAY_IN_SECONDS, GIGABYTE, HOUR_IN_SECONDS } from '../constants';
+import { DAY_IN_SECONDS, HOUR_IN_SECONDS } from '../constants';
 import { configuredNumeral } from '../numeral';
 import { isNumeric } from '../utils';
 import i18n from './i18n';
@@ -20,15 +20,9 @@ export const formatBps = (bytes) => {
     }
     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;
@@ -103,13 +97,10 @@ export const formatCPUWithLabel = (value) => {
     const localizedCores = configuredNumeral(cores).format('0.[000]');
     return `${localizedCores} ${i18n('format-cpu.cores', { count: cores })}`;
 };
-export const formatDateTime = (value, defaultValue = 'N/A') => {
+export const formatDateTime = (value, defaultValue = '') => {
     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 : defaultValue;
+    return formattedData !== null && formattedData !== void 0 ? formattedData : defaultValue;
 };
 export const calcUptimeInSeconds = (milliseconds) => {
     const currentDate = new Date();

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

@@ -9,4 +9,5 @@ interface VDiskDeveloperUILinkParams extends PDiskDeveloperUILinkParams {
     vDiskSlotId: number | string;
 }
 export declare const createVDiskDeveloperUILink: ({ nodeId, pDiskId, vDiskSlotId, host, }: VDiskDeveloperUILinkParams) => string;
+export declare function createTabletDeveloperUIHref(tabletId: number | string, host?: string | undefined): string;
 export {};

package/dist/utils/developerUI/developerUI.js

@@ -18,3 +18,6 @@ export const createVDiskDeveloperUILink = ({ nodeId, pDiskId, vDiskSlotId, host,
     const vdiskPath = 'actors/vdisks/vdisk' + pad9(pDiskId) + '_' + pad9(vDiskSlotId);
     return createDeveloperUILinkWithNodeId(nodeId, host) + vdiskPath;
 };
+export function createTabletDeveloperUIHref(tabletId, host = backend) {
+    return `${host}/tablets?TabletID=${tabletId}`;
+}

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

@@ -1,7 +1,7 @@
 import type { PDiskType } from './types';
 export declare const PDISK_TYPES: {
-    HDD: string;
-    SSD: string;
-    MVME: string;
+    readonly HDD: "HDD";
+    readonly SSD: "SSD";
+    readonly MVME: "NVME";
 };
 export declare function getPDiskType(category?: string): PDiskType | undefined;

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

@@ -1,3 +1,4 @@
 import type { TVDiskStateInfo, TVSlotId } from '../../types/api/vdisk';
 export declare function isFullVDiskData(disk: TVDiskStateInfo | TVSlotId): disk is TVDiskStateInfo;
 export declare function getSeverityColor(severity: number | undefined): import("../../types/api/enums").EFlag;
+export declare function getPDiskId(nodeId: string | number, pDiskId: string | number): string;

package/dist/utils/disks/helpers.js

@@ -8,3 +8,6 @@ export function getSeverityColor(severity) {
     }
     return DISK_NUMERIC_SEVERITY_TO_STATE_COLOR[severity] || NOT_AVAILABLE_SEVERITY_COLOR;
 }
+export function getPDiskId(nodeId, pDiskId) {
+    return `${nodeId}-${pDiskId}`;
+}

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

@@ -1,5 +1,5 @@
-import type { TPDiskStateInfo } from '../../types/api/pdisk';
+import type { TPDiskInfo, TPDiskStateInfo } from '../../types/api/pdisk';
 import type { TVDiskStateInfo } from '../../types/api/vdisk';
 import type { PreparedPDisk, PreparedVDisk } from './types';
 export declare function prepareVDiskData(vdiskState?: TVDiskStateInfo): PreparedVDisk;
-export declare function preparePDiskData(pdiskState?: TPDiskStateInfo): PreparedPDisk;
+export declare function preparePDiskData(pdiskState?: TPDiskStateInfo, bscPDiskInfo?: TPDiskInfo): PreparedPDisk;

package/dist/utils/disks/prepareDisks.js

@@ -1,14 +1,16 @@
-import { isNumeric } from '../utils';
 import { calculatePDiskSeverity } from './calculatePDiskSeverity';
 import { calculateVDiskSeverity } from './calculateVDiskSeverity';
 import { getPDiskType } from './getPDiskType';
 export function prepareVDiskData(vdiskState = {}) {
-    var _a, _b;
+    var _a, _b, _c;
     // Prepare PDisk only if it is present
     const PDisk = vdiskState.PDisk ? preparePDiskData(vdiskState.PDisk) : undefined;
     const PDiskId = (_a = vdiskState.PDiskId) !== null && _a !== void 0 ? _a : PDisk === null || PDisk === void 0 ? void 0 : PDisk.PDiskId;
-    const AllocatedPercent = calculateVDiskAllocatedPercent(vdiskState.AllocatedSize, vdiskState.AvailableSize, PDisk === null || PDisk === void 0 ? void 0 : PDisk.AvailableSize);
-    const Donors = (_b = vdiskState.Donors) === null || _b === void 0 ? void 0 : _b.map((donor) => {
+    const available = Number((_b = vdiskState.AvailableSize) !== null && _b !== void 0 ? _b : PDisk === null || PDisk === void 0 ? void 0 : PDisk.AvailableSize);
+    const allocated = Number(vdiskState.AllocatedSize);
+    const total = allocated + available;
+    const allocatedPercent = Math.round((allocated * 100) / total);
+    const Donors = (_c = vdiskState.Donors) === null || _c === void 0 ? void 0 : _c.map((donor) => {
         return prepareVDiskData({ ...donor, DonorMode: true });
     });
     const Severity = calculateVDiskSeverity(vdiskState);
@@ -16,33 +18,26 @@ export function prepareVDiskData(vdiskState = {}) {
         ...vdiskState,
         PDisk,
         PDiskId,
-        AllocatedPercent,
         Donors,
         Severity,
+        TotalSize: total,
+        AllocatedPercent: allocatedPercent,
     };
 }
-export function preparePDiskData(pdiskState = {}) {
+export function preparePDiskData(pdiskState = {}, bscPDiskInfo = {}) {
     const { AvailableSize, TotalSize, Category } = pdiskState;
     const Type = getPDiskType(Category);
-    const AllocatedPercent = calculatePDiskAllocatedPercent(AvailableSize, TotalSize);
-    const Severity = calculatePDiskSeverity(pdiskState, AllocatedPercent);
+    const available = Number(AvailableSize);
+    const total = Number(TotalSize);
+    const allocated = total - available;
+    const allocatedPercent = Math.round((allocated * 100) / total);
+    const Severity = calculatePDiskSeverity(pdiskState, allocatedPercent);
     return {
+        ...bscPDiskInfo,
         ...pdiskState,
         Type,
-        AllocatedPercent,
         Severity,
+        AllocatedSize: allocated,
+        AllocatedPercent: allocatedPercent,
     };
 }
-function calculatePDiskAllocatedPercent(available, total) {
-    if (!isNumeric(available) || !isNumeric(total)) {
-        return undefined;
-    }
-    return Math.round(((Number(total) - Number(available)) * 100) / Number(total));
-}
-function calculateVDiskAllocatedPercent(allocated, availableOnVDisk, availableOnPDisk) {
-    const available = availableOnVDisk !== null && availableOnVDisk !== void 0 ? availableOnVDisk : availableOnPDisk;
-    if (!isNumeric(allocated) || !isNumeric(available)) {
-        return undefined;
-    }
-    return Math.round((Number(allocated) * 100) / (Number(allocated) + Number(available)));
-}

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

@@ -1,16 +1,18 @@
-import type { TPDiskStateInfo } from '../../types/api/pdisk';
+import type { TPDiskInfo, TPDiskStateInfo } from '../../types/api/pdisk';
 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 {
+export type PreparedPDisk = TPDiskStateInfo & Omit<Partial<TPDiskInfo>, 'Type'> & {
     Type?: PDiskType;
-    AllocatedPercent?: number;
     Severity?: number;
-}
+    AllocatedSize?: number;
+    AllocatedPercent?: number;
+};
 export interface PreparedVDisk extends TVDiskStateInfo {
     PDisk?: PreparedPDisk;
-    AllocatedPercent?: number;
     Severity?: number;
+    TotalSize?: number;
+    AllocatedPercent?: number;
 }
 export type PDiskType = ValueOf<typeof PDISK_TYPES>;
 export interface UnavailableDonor extends TVSlotId {

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

@@ -1,7 +1,8 @@
 export * from './useTypedSelector';
 export * from './useTypedDispatch';
 export * from './useSetting';
-export * from './useQueryModes';
+export * from './useQueryExecutionSettings';
 export * from './useTableSort';
 export * from './useSearchQuery';
 export * from './useAutoRefreshInterval';
+export * from './useEventHandler';

package/dist/utils/hooks/index.js

@@ -1,7 +1,8 @@
 export * from './useTypedSelector';
 export * from './useTypedDispatch';
 export * from './useSetting';
-export * from './useQueryModes';
+export * from './useQueryExecutionSettings';
 export * from './useTableSort';
 export * from './useSearchQuery';
 export * from './useAutoRefreshInterval';
+export * from './useEventHandler';

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

@@ -0,0 +1,10 @@
+export declare const useChangedQuerySettings: () => {
+    isBannerShown: boolean;
+    isIndicatorShown: boolean | 0 | undefined;
+    closeBanner: () => void;
+    resetBanner: () => void;
+    changedCurrentSettings: (keyof import("../../types/store/query").QuerySettings)[];
+    changedCurrentSettingsDescriptions: Record<string, string>;
+    changedLastExucutionSettings: (keyof import("../../types/store/query").QuerySettings)[];
+    changedLastExecutionSettingsDescriptions: Record<string, string>;
+};

package/dist/utils/hooks/useChangedQuerySettings.js

@@ -0,0 +1,46 @@
+import getChangedQueryExecutionSettings from '../../containers/Tenant/Query/QueryEditorControls/utils/getChangedQueryExecutionSettings';
+import getChangedQueryExecutionSettingsDescription from '../../containers/Tenant/Query/QueryEditorControls/utils/getChangedQueryExecutionSettingsDescription';
+import { DEFAULT_QUERY_SETTINGS, QUERY_SETTINGS_BANNER_LAST_CLOSED_KEY, WEEK_IN_SECONDS, } from '../constants';
+import { useLastQueryExecutionSettings } from './useLastQueryExecutionSettings';
+import { useQueryExecutionSettings } from './useQueryExecutionSettings';
+import { useSetting } from './useSetting';
+export const useChangedQuerySettings = () => {
+    const [bannerLastClosedTimestamp, setBannerLastClosedTimestamp] = useSetting(QUERY_SETTINGS_BANNER_LAST_CLOSED_KEY);
+    const [lastQuerySettings] = useLastQueryExecutionSettings();
+    const [currentQuerySettings] = useQueryExecutionSettings();
+    const changedLastExucutionSettings = lastQuerySettings
+        ? getChangedQueryExecutionSettings(lastQuerySettings, DEFAULT_QUERY_SETTINGS)
+        : [];
+    const changedCurrentSettings = currentQuerySettings
+        ? getChangedQueryExecutionSettings(currentQuerySettings, DEFAULT_QUERY_SETTINGS)
+        : [];
+    const hasChangedLastExucutionSettings = changedLastExucutionSettings.length > 0;
+    const changedLastExecutionSettingsDescriptions = lastQuerySettings
+        ? getChangedQueryExecutionSettingsDescription({
+            currentSettings: lastQuerySettings,
+            defaultSettings: DEFAULT_QUERY_SETTINGS,
+        })
+        : {};
+    const changedCurrentSettingsDescriptions = currentQuerySettings
+        ? getChangedQueryExecutionSettingsDescription({
+            currentSettings: currentQuerySettings,
+            defaultSettings: DEFAULT_QUERY_SETTINGS,
+        })
+        : {};
+    const isClosedRecently = bannerLastClosedTimestamp &&
+        Date.now() - bannerLastClosedTimestamp < WEEK_IN_SECONDS * 1000;
+    const isBannerShown = hasChangedLastExucutionSettings && !isClosedRecently;
+    const isIndicatorShown = hasChangedLastExucutionSettings && isClosedRecently;
+    const closeBanner = () => setBannerLastClosedTimestamp(Date.now());
+    const resetBanner = () => setBannerLastClosedTimestamp(undefined);
+    return {
+        isBannerShown,
+        isIndicatorShown,
+        closeBanner,
+        resetBanner,
+        changedCurrentSettings,
+        changedCurrentSettingsDescriptions,
+        changedLastExucutionSettings,
+        changedLastExecutionSettingsDescriptions,
+    };
+};

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

@@ -0,0 +1 @@
+export declare function useDelayed(delay?: number): boolean;

package/dist/utils/hooks/useDelayed.js

@@ -0,0 +1,13 @@
+import React from 'react';
+export function useDelayed(delay = 600) {
+    const [show, setShow] = React.useState(false);
+    React.useEffect(() => {
+        const timerId = setTimeout(() => {
+            setShow(true);
+        }, delay);
+        return () => {
+            clearTimeout(timerId);
+        };
+    }, []);
+    return show;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * The hook returns a stable function (an empty list of dependencies),
+ * but this function always calls the actual function associated with the last render.
+ * The returned function should be used as an event handler or inside a useEffect.
+ */
+export declare function useEventHandler<T extends Function>(handler?: T): T;

package/dist/utils/hooks/useEventHandler.js

@@ -0,0 +1,17 @@
+import React from 'react';
+/**
+ * The hook returns a stable function (an empty list of dependencies),
+ * but this function always calls the actual function associated with the last render.
+ * The returned function should be used as an event handler or inside a useEffect.
+ */
+export function useEventHandler(handler) {
+    const ref = React.useRef(handler);
+    React.useLayoutEffect(() => {
+        ref.current = handler;
+    }, [handler]);
+    // @ts-expect-error
+    return React.useCallback((...args) => {
+        var _a;
+        return (_a = ref.current) === null || _a === void 0 ? void 0 : _a.call(ref, ...args);
+    }, []);
+}

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

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

package/dist/utils/hooks/useLastQueryExecutionSettings.js

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

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

@@ -0,0 +1,8 @@
+import type { QuerySettings } from '../../types/store/query';
+export declare const useQueryExecutionSettings: () => readonly [{
+    readonly tracingLevel: import("../../types/store/query").TracingLevel | undefined;
+    readonly queryMode: import("../../types/store/query").QueryMode;
+    readonly isolationLevel: import("../../types/store/query").IsolationLevel;
+    readonly timeout?: string;
+    readonly statisticsMode?: import("../../types/store/query").StatisticsMode;
+}, (value: QuerySettings) => void];

package/dist/utils/hooks/useQueryExecutionSettings.js

@@ -0,0 +1,15 @@
+import { DEFAULT_QUERY_SETTINGS, ENABLE_TRACING_LEVEL_KEY, QUERY_EXECUTION_SETTINGS_KEY, } from '../constants';
+import { useSetting } from './useSetting';
+export const useQueryExecutionSettings = () => {
+    const [enableTracingLevel] = useSetting(ENABLE_TRACING_LEVEL_KEY);
+    const [setting, setSetting] = useSetting(QUERY_EXECUTION_SETTINGS_KEY);
+    return [
+        {
+            ...setting,
+            tracingLevel: enableTracingLevel
+                ? setting.tracingLevel
+                : DEFAULT_QUERY_SETTINGS.tracingLevel,
+        },
+        setSetting,
+    ];
+};

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

@@ -0,0 +1,2 @@
+export declare const S_EXPRESSION_LANGUAGE_ID = "s-expression";
+export declare const YQL_LANGUAGE_ID = "yql";

package/dist/utils/monaco/constats.js

@@ -0,0 +1,2 @@
+export const S_EXPRESSION_LANGUAGE_ID = 's-expression';
+export const YQL_LANGUAGE_ID = 'yql';

package/dist/utils/monaco/yql/constants.d.ts

@@ -1,5 +1,4 @@
 import type { YQLEntity } from '@gravity-ui/websql-autocomplete';
-export declare const LANGUAGE_YQL_ID = "yql";
 export declare const SimpleTypes: string[];
 export declare const SimpleFunctions: string[];
 export declare const AggregateFunctions: string[];

package/dist/utils/monaco/yql/constants.js

@@ -1,4 +1,3 @@
-export const LANGUAGE_YQL_ID = 'yql';
 export const SimpleTypes = [
     'String',
     'Bool',

package/dist/utils/monaco/yql/yql.completionItemProvider.js

@@ -1,5 +1,5 @@
 import * as monaco from 'monaco-editor';
-import { LANGUAGE_YQL_ID } from './constants';
+import { LANGUAGE_ID } from 'monaco-yql-languages/build/yql/yql.contribution';
 import { createProvideSuggestionsFunction } from './yqlSuggestions';
 let completionProvider;
 function disableCodeSuggestions() {
@@ -9,7 +9,7 @@ function disableCodeSuggestions() {
 }
 export function registerYQLCompletionItemProvider(database) {
     disableCodeSuggestions();
-    completionProvider = monaco.languages.registerCompletionItemProvider(LANGUAGE_YQL_ID, {
+    completionProvider = monaco.languages.registerCompletionItemProvider(LANGUAGE_ID, {
         triggerCharacters: [' ', '.', '`', '(', '/'],
         provideCompletionItems: createProvideSuggestionsFunction(database),
     });

package/dist/utils/prepareQueryExplain.d.ts

@@ -1,6 +1,8 @@
 import type { ExplainPlanNodeData, GraphNode, Link } from '@gravity-ui/paranoid';
-import type { PlanNode } from '../types/api/query';
+import type { SimplifiedPlanItem } from '../store/reducers/explainQuery/types';
+import type { PlanNode, SimplifiedNode } from '../types/api/query';
 export declare function preparePlan(plan: PlanNode): {
     nodes: GraphNode<ExplainPlanNodeData>[];
     links: Link[];
 };
+export declare function prepareSimplifiedPlan(plans: SimplifiedNode[]): SimplifiedPlanItem[];

package/dist/utils/prepareQueryExplain.js

@@ -9,7 +9,7 @@ function prepareStats(plan) {
                 if (name === 'Name') {
                     continue;
                 }
-                const value = Array.isArray(data) ? data.join(', ') : data;
+                const value = typeof data === 'string' ? data : JSON.stringify(data);
                 section.items.push({ name, value });
             }
             operatorsSections.push(section);
@@ -25,7 +25,10 @@ function prepareStats(plan) {
             if (CONNECTION_NODE_META_FIELDS.has(key)) {
                 continue;
             }
-            attrStats.push({ name: key, value: String(value) });
+            attrStats.push({
+                name: key,
+                value: typeof value === 'string' ? value : JSON.stringify(value),
+            });
         }
         if (attrStats.length > 0) {
             stats.push({
@@ -34,6 +37,19 @@ function prepareStats(plan) {
             });
         }
     }
+    if (plan.Stats) {
+        const attrStats = [];
+        for (const [key, value] of Object.entries(plan.Stats)) {
+            attrStats.push({
+                name: key,
+                value: typeof value === 'string' ? value : JSON.stringify(value),
+            });
+        }
+        stats.push({
+            group: 'Stats',
+            stats: attrStats,
+        });
+    }
     return stats;
 }
 function getNodeType(plan) {
@@ -86,3 +102,39 @@ export function preparePlan(plan) {
         links,
     };
 }
+export function prepareSimplifiedPlan(plans) {
+    var _a;
+    const result = [];
+    const stack = plans.map((plan) => ({ node: plan }));
+    while (stack.length > 0) {
+        const { node, subNodes } = stack.pop();
+        const plans = node['Plans'];
+        const operator = (_a = node['Operators']) === null || _a === void 0 ? void 0 : _a[0];
+        const children = subNodes || result;
+        if (operator) {
+            const { ['A-Cpu']: aCpu, ['A-Rows']: aRows, ['E-Cost']: eCost, ['E-Rows']: eRows, ['E-Size']: eSize, ['SsaProgram']: _ssaProgram, ['Name']: name, ...rest } = operator;
+            const newNode = {
+                name,
+                operationParams: rest,
+                aCpu,
+                aRows,
+                eCost,
+                eRows,
+                eSize,
+                children: [],
+            };
+            children.push(newNode);
+            if (plans) {
+                for (let i = plans.length - 1; i >= 0; i--) {
+                    stack.push({ node: plans[i], subNodes: newNode.children });
+                }
+            }
+        }
+        else if (plans) {
+            for (let i = plans.length - 1; i >= 0; i--) {
+                stack.push({ node: plans[i], subNodes: children });
+            }
+        }
+    }
+    return result;
+}

package/dist/utils/query.d.ts

@@ -1,5 +1,28 @@
 import type { AnyExecuteResponse, AnyExplainResponse, ErrorResponse, KeyValueRow, QueryPlan, ScriptPlan } from '../types/api/query';
-import type { IQueryResult, QueryMode } from '../types/store/query';
+import type { IQueryResult, IsolationLevel, QueryMode, StatisticsMode, TracingLevel } from '../types/store/query';
+export declare const ISOLATION_LEVELS: {
+    readonly serializable: "serializable-read-write";
+    readonly stalero: "stale-read-only";
+    readonly onlinero: "online-read-only";
+    readonly snapshot: "snapshot-read-only";
+};
+export declare const ISOLATION_LEVELS_TITLES: Record<IsolationLevel, string>;
+export declare const STATISTICS_MODES: {
+    readonly none: "none";
+    readonly basic: "basic";
+    readonly full: "full";
+    readonly profile: "profile";
+};
+export declare const STATISTICS_MODES_TITLES: Record<StatisticsMode, string>;
+export declare const TRACING_LEVELS: {
+    readonly off: "off";
+    readonly toplevel: "toplevel";
+    readonly basic: "basic";
+    readonly detailed: "detailed";
+    readonly diagnostic: "diagnostic";
+    readonly trace: "trace";
+};
+export declare const TRACING_LEVELS_TITLES: Record<TracingLevel, string>;
 export declare const QUERY_ACTIONS: {
     readonly execute: "execute";
     readonly explain: "explain";

package/dist/utils/query.js

@@ -1,5 +1,45 @@
 import { YQLType } from '../types';
 import { isAxiosResponse, isNetworkError } from './response';
+export const ISOLATION_LEVELS = {
+    serializable: 'serializable-read-write',
+    stalero: 'stale-read-only',
+    onlinero: 'online-read-only',
+    snapshot: 'snapshot-read-only',
+};
+export const ISOLATION_LEVELS_TITLES = {
+    [ISOLATION_LEVELS.serializable]: 'Serializable',
+    [ISOLATION_LEVELS.stalero]: 'Stale Read-Only',
+    [ISOLATION_LEVELS.onlinero]: 'Online Read-Only',
+    [ISOLATION_LEVELS.snapshot]: 'Snapshot Read-Only',
+};
+export const STATISTICS_MODES = {
+    none: 'none',
+    basic: 'basic',
+    full: 'full',
+    profile: 'profile',
+};
+export const STATISTICS_MODES_TITLES = {
+    [STATISTICS_MODES.none]: 'None',
+    [STATISTICS_MODES.full]: 'Full',
+    [STATISTICS_MODES.basic]: 'Basic',
+    [STATISTICS_MODES.profile]: 'Profile',
+};
+export const TRACING_LEVELS = {
+    off: 'off',
+    toplevel: 'toplevel',
+    basic: 'basic',
+    detailed: 'detailed',
+    diagnostic: 'diagnostic',
+    trace: 'trace',
+};
+export const TRACING_LEVELS_TITLES = {
+    [TRACING_LEVELS.off]: 'Off',
+    [TRACING_LEVELS.toplevel]: 'TopLevel',
+    [TRACING_LEVELS.basic]: 'Basic',
+    [TRACING_LEVELS.detailed]: 'Detailed',
+    [TRACING_LEVELS.diagnostic]: 'Diagnostic',
+    [TRACING_LEVELS.trace]: 'Trace',
+};
 export const QUERY_ACTIONS = {
     execute: 'execute',
     explain: 'explain',
@@ -147,6 +187,7 @@ export const parseQueryExplainPlan = (plan) => {
             Plan: plan.queries[0].Plan,
             tables: plan.queries[0].tables,
             meta: plan.meta,
+            SimplifiedPlan: plan.queries[0].SimplifiedPlan,
         };
     }
     return plan;

package/dist/utils/query.test.js

@@ -131,6 +131,7 @@ describe('API utils', () => {
         describe('parseQueryExplainPlan', () => {
             it('should parse explain script plan to explain scan', () => {
                 const plan = {};
+                const simplifiedPlan = {};
                 const tables = [];
                 const meta = { version: '0.2', type: 'script' };
                 const rawPlan = {
@@ -138,12 +139,14 @@ describe('API utils', () => {
                         {
                             Plan: plan,
                             tables,
+                            SimplifiedPlan: simplifiedPlan,
                         },
                     ],
                     meta,
                 };
                 const parsedPlan = parseQueryExplainPlan(rawPlan);
                 expect(parsedPlan.Plan).toEqual(plan);
+                expect(parsedPlan.SimplifiedPlan).toEqual(simplifiedPlan);
                 expect(parsedPlan.tables).toBe(tables);
                 expect(parsedPlan.meta).toEqual(meta);
             });

package/dist/utils/utils.d.ts

@@ -1,7 +1,8 @@
-export function parseJson(value: any): any;
-export function getValueFromLS(key: any, defaultValue: any): any;
-export function bytesToSize(bytes: any): string;
-export function bytesToSpeed(bytes: any): string;
-export function bytesToGB(bytes: any, shouldRound: any): string;
-export function pad9(val: any): any;
-export function isNumeric(value: any): boolean;
+export declare function parseJson(value?: string | null): any;
+export declare function getValueFromLS(key: string, defaultValue: string): string | undefined;
+export declare function bytesToSize(bytes: number): string;
+export declare function bytesToSpeed(bytes?: number | string): string;
+export declare function bytesToGB(bytes?: number | string, shouldRound?: boolean): string;
+export declare function pad9(val: number | string): string;
+export declare function isNumeric(value?: unknown): value is number | string;
+export declare function toExponential(value: number, precision?: number): string;