ydb-embedded-ui 5.2.1 → 5.3.0

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

@@ -1,4 +1,4 @@
-export declare const createDeveloperUILinkWithNodeId: (nodeId: number | string, host?: any) => string;
+export declare const createDeveloperUILinkWithNodeId: (nodeId: number | string, host?: string | undefined) => string;
 interface PDiskDeveloperUILinkParams {
     nodeId: number | string;
     pDiskId: number | string;

package/dist/utils/diagnostics.d.ts

@@ -12,8 +12,8 @@ declare const TOP_QUERIES_SORT_VALUES: {
     readonly UserSID: "UserSID";
     readonly Duration: "Duration";
 };
-declare type TopShardsSortValue = ValueOf<typeof TOP_SHARDS_SORT_VALUES>;
-declare type TopQueriesSortValue = ValueOf<typeof TOP_QUERIES_SORT_VALUES>;
+type TopShardsSortValue = ValueOf<typeof TOP_SHARDS_SORT_VALUES>;
+type TopQueriesSortValue = ValueOf<typeof TOP_QUERIES_SORT_VALUES>;
 export declare const isSortableTopShardsProperty: (value: string) => value is TopShardsSortValue;
 export declare const isSortableTopQueriesProperty: (value: string) => value is TopQueriesSortValue;
 export {};

package/dist/utils/disks/__test__/calculatePDiskSeverity.test.d.ts

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

package/dist/utils/disks/__test__/calculatePDiskSeverity.test.js

@@ -0,0 +1,36 @@
+import { TPDiskState } from '../../../types/api/pdisk';
+import { calculatePDiskSeverity } from '../calculatePDiskSeverity';
+import { DISK_COLOR_STATE_TO_NUMERIC_SEVERITY } from '../constants';
+describe('PDisk state', () => {
+    it('Should determine severity based on State if space severity is OK', () => {
+        const normalDiskSeverity = calculatePDiskSeverity({ State: TPDiskState.Normal });
+        const erroredDiskSeverity = calculatePDiskSeverity({ State: TPDiskState.ChunkQuotaError });
+        expect(normalDiskSeverity).not.toEqual(erroredDiskSeverity);
+    });
+    it('Should determine severity based on space utilization if state severity is OK', () => {
+        const severity1 = calculatePDiskSeverity({ State: TPDiskState.Normal }, 0);
+        const severity2 = calculatePDiskSeverity({ State: TPDiskState.Normal }, 86);
+        const severity3 = calculatePDiskSeverity({ State: TPDiskState.Normal }, 96);
+        expect(severity1).toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Green);
+        expect(severity2).toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Yellow);
+        expect(severity3).toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Red);
+    });
+    it('Should determine severity based on max severity of state and space utilization ', () => {
+        const severity1 = calculatePDiskSeverity({ State: TPDiskState.ChunkQuotaError }, 0);
+        const severity2 = calculatePDiskSeverity({ State: TPDiskState.Normal }, 96);
+        expect(severity1).toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Red);
+        expect(severity2).toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Red);
+    });
+    it('Should display as unavailabe when no State is provided', () => {
+        const severity1 = calculatePDiskSeverity({});
+        const severity2 = calculatePDiskSeverity({ State: TPDiskState.ChunkQuotaError });
+        expect(severity1).toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Grey);
+        expect(severity2).not.toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Grey);
+    });
+    it('Should display as unavailabe when no State is provided event if space severity is not OK', () => {
+        const severity1 = calculatePDiskSeverity({}, 86);
+        const severity2 = calculatePDiskSeverity({}, 96);
+        expect(severity1).toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Grey);
+        expect(severity2).toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Grey);
+    });
+});

package/dist/utils/disks/__test__/calculateVDiskSeverity.test.d.ts

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

package/dist/utils/disks/__test__/calculateVDiskSeverity.test.js

@@ -0,0 +1,142 @@
+import { EFlag } from '../../../types/api/enums';
+import { EVDiskState } from '../../../types/api/vdisk';
+import { calculateVDiskSeverity } from '../calculateVDiskSeverity';
+import { DISK_COLOR_STATE_TO_NUMERIC_SEVERITY } from '../constants';
+describe('VDisk state', () => {
+    it('Should determine severity based on the highest value among VDiskState, DiskSpace and FrontQueues', () => {
+        const severity1 = calculateVDiskSeverity({
+            VDiskId: { Domain: 1 },
+            VDiskState: EVDiskState.OK,
+            DiskSpace: EFlag.Yellow,
+            FrontQueues: EFlag.Green, // severity 1, green
+        });
+        const severity2 = calculateVDiskSeverity({
+            VDiskId: { Domain: 2 },
+            VDiskState: EVDiskState.PDiskError,
+            DiskSpace: EFlag.Yellow,
+            FrontQueues: EFlag.Green, // severity 1, green
+        });
+        const severity3 = calculateVDiskSeverity({
+            VDiskId: { Domain: 3 },
+            VDiskState: EVDiskState.OK,
+            DiskSpace: EFlag.Yellow,
+            FrontQueues: EFlag.Orange, // severity 4, orange
+        });
+        expect(severity1).toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Yellow);
+        expect(severity2).toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Red);
+        expect(severity3).toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Orange);
+    });
+    it('Should not pick the highest severity based on FrontQueues value', () => {
+        const severity1 = calculateVDiskSeverity({
+            VDiskId: { Domain: 1 },
+            VDiskState: EVDiskState.OK,
+            DiskSpace: EFlag.Green,
+            FrontQueues: EFlag.Red, // severity 5, red
+        });
+        const severity2 = calculateVDiskSeverity({
+            VDiskId: { Domain: 2 },
+            VDiskState: EVDiskState.OK,
+            DiskSpace: EFlag.Red,
+            FrontQueues: EFlag.Red, // severity 5, red
+        });
+        expect(severity1).not.toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Red);
+        expect(severity2).toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Red);
+    });
+    // prettier-ignore
+    it('Should display as unavailable when no VDiskState is provided', () => {
+        const severity1 = calculateVDiskSeverity({
+            VDiskId: { Domain: 1 }
+        });
+        const severity2 = calculateVDiskSeverity({
+            VDiskId: { Domain: 2 }, VDiskState: EVDiskState.OK
+        });
+        const severity3 = calculateVDiskSeverity({
+            VDiskId: { Domain: 3 }, DiskSpace: EFlag.Green
+        });
+        const severity4 = calculateVDiskSeverity({
+            VDiskId: { Domain: 4 }, FrontQueues: EFlag.Green
+        });
+        const severity5 = calculateVDiskSeverity({
+            VDiskId: { Domain: 5 }, VDiskState: EVDiskState.OK, DiskSpace: EFlag.Green
+        });
+        const severity6 = calculateVDiskSeverity({
+            VDiskId: { Domain: 6 }, VDiskState: EVDiskState.OK, FrontQueues: EFlag.Green
+        });
+        const severity7 = calculateVDiskSeverity({
+            VDiskId: { Domain: 7 }, DiskSpace: EFlag.Green, FrontQueues: EFlag.Green
+        });
+        const severity8 = calculateVDiskSeverity({
+            VDiskId: { Domain: 8 }, VDiskState: EVDiskState.OK, DiskSpace: EFlag.Green, FrontQueues: EFlag.Green
+        });
+        // unavailable disks display with the grey color
+        expect(severity1).toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Grey);
+        expect(severity2).not.toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Grey);
+        expect(severity3).toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Grey);
+        expect(severity4).toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Grey);
+        expect(severity5).not.toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Grey);
+        expect(severity6).not.toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Grey);
+        expect(severity7).toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Grey);
+        expect(severity8).not.toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Grey);
+    });
+    it('Should display as unavailable when no VDiskState is provided even if DiskSpace or FrontQueues flags are not green', () => {
+        const severity1 = calculateVDiskSeverity({
+            VDiskId: { Domain: 1 },
+            DiskSpace: EFlag.Red,
+            FrontQueues: EFlag.Yellow,
+        });
+        // unavailable disks display with the grey color
+        expect(severity1).toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Grey);
+    });
+    it('Should display replicating VDisks in OK state with a distinct color', () => {
+        const severity1 = calculateVDiskSeverity({
+            VDiskId: { Domain: 1 },
+            VDiskState: EVDiskState.OK,
+            Replicated: false,
+        });
+        const severity2 = calculateVDiskSeverity({
+            VDiskId: { Domain: 2 },
+            VDiskState: EVDiskState.OK,
+            Replicated: true,
+        });
+        expect(severity1).toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Blue);
+        expect(severity2).not.toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Blue);
+    });
+    it('Should display replicating VDisks in a not-OK state with a regular color', () => {
+        const severity1 = calculateVDiskSeverity({
+            VDiskId: { Domain: 1 },
+            VDiskState: EVDiskState.Initial,
+            Replicated: false,
+        });
+        const severity2 = calculateVDiskSeverity({
+            VDiskId: { Domain: 2 },
+            VDiskState: EVDiskState.PDiskError,
+            Replicated: false,
+        });
+        expect(severity1).toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Yellow);
+        expect(severity2).toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Red);
+    });
+    it('Should always display donor VDisks with a regular color', () => {
+        const severity1 = calculateVDiskSeverity({
+            VDiskId: { Domain: 1 },
+            VDiskState: EVDiskState.OK,
+            Replicated: false,
+            DonorMode: true,
+        });
+        const severity2 = calculateVDiskSeverity({
+            VDiskId: { Domain: 2 },
+            VDiskState: EVDiskState.Initial,
+            Replicated: false,
+            DonorMode: true,
+        });
+        const severity3 = calculateVDiskSeverity({
+            VDiskId: { Domain: 3 },
+            VDiskState: EVDiskState.PDiskError,
+            Replicated: false,
+            DonorMode: true,
+        });
+        expect(severity1).not.toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Blue);
+        expect(severity1).toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Green);
+        expect(severity2).toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Yellow);
+        expect(severity3).toEqual(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Red);
+    });
+});

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

@@ -0,0 +1,2 @@
+import type { TPDiskStateInfo } from '../../types/api/pdisk';
+export declare function calculatePDiskSeverity(pDisk: TPDiskStateInfo, allocatedPercent?: number): number;

package/dist/utils/disks/calculatePDiskSeverity.js

@@ -0,0 +1,18 @@
+import { EFlag } from '../../types/api/enums';
+import { generateEvaluator } from '../generateEvaluator';
+import { DISK_COLOR_STATE_TO_NUMERIC_SEVERITY, NOT_AVAILABLE_SEVERITY, PDISK_STATE_SEVERITY, } from './constants';
+const getUsageSeverityForPDisk = generateEvaluator(85, 95, [EFlag.Green, EFlag.Yellow, EFlag.Red]);
+export function calculatePDiskSeverity(pDisk, allocatedPercent = 0) {
+    const stateSeverity = getStateSeverity(pDisk.State);
+    const spaceSeverityFlag = getUsageSeverityForPDisk(allocatedPercent);
+    if (stateSeverity === NOT_AVAILABLE_SEVERITY || !spaceSeverityFlag) {
+        return stateSeverity;
+    }
+    return Math.max(stateSeverity, DISK_COLOR_STATE_TO_NUMERIC_SEVERITY[spaceSeverityFlag]);
+}
+function getStateSeverity(pDiskState) {
+    return isSeverityKey(pDiskState) ? PDISK_STATE_SEVERITY[pDiskState] : NOT_AVAILABLE_SEVERITY;
+}
+function isSeverityKey(key) {
+    return key !== undefined && key in PDISK_STATE_SEVERITY;
+}

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

@@ -0,0 +1,2 @@
+import { type TVDiskStateInfo } from '../../types/api/vdisk';
+export declare function calculateVDiskSeverity(vDisk: TVDiskStateInfo): number;

package/dist/utils/disks/calculateVDiskSeverity.js

@@ -0,0 +1,36 @@
+import { DISK_COLOR_STATE_TO_NUMERIC_SEVERITY, NOT_AVAILABLE_SEVERITY, VDISK_STATE_SEVERITY, } from './constants';
+import { isFullVDiskData } from './helpers';
+export function calculateVDiskSeverity(vDisk) {
+    if (!isFullVDiskData(vDisk)) {
+        return NOT_AVAILABLE_SEVERITY;
+    }
+    const { DiskSpace, VDiskState, FrontQueues, Replicated, DonorMode } = vDisk;
+    // if the disk is not available, this determines its status severity regardless of other features
+    if (!VDiskState) {
+        return NOT_AVAILABLE_SEVERITY;
+    }
+    const DiskSpaceSeverity = getColorSeverity(DiskSpace);
+    const VDiskSpaceSeverity = getStateSeverity(VDiskState);
+    const FrontQueuesSeverity = Math.min(DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Orange, getColorSeverity(FrontQueues));
+    let severity = Math.max(DiskSpaceSeverity, VDiskSpaceSeverity, FrontQueuesSeverity);
+    // donors are always in the not replicated state since they are leftovers
+    // painting them blue is useless
+    if (!Replicated && !DonorMode && severity === DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Green) {
+        severity = DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Blue;
+    }
+    return severity;
+}
+function getStateSeverity(vDiskState) {
+    var _a;
+    if (!vDiskState) {
+        return NOT_AVAILABLE_SEVERITY;
+    }
+    return (_a = VDISK_STATE_SEVERITY[vDiskState]) !== null && _a !== void 0 ? _a : NOT_AVAILABLE_SEVERITY;
+}
+function getColorSeverity(color) {
+    var _a;
+    if (!color) {
+        return NOT_AVAILABLE_SEVERITY;
+    }
+    return (_a = DISK_COLOR_STATE_TO_NUMERIC_SEVERITY[color]) !== null && _a !== void 0 ? _a : NOT_AVAILABLE_SEVERITY;
+}

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

@@ -0,0 +1,25 @@
+import type { EFlag } from '../../types/api/enums';
+import { EVDiskState } from '../../types/api/vdisk';
+export declare const DISK_COLOR_STATE_TO_NUMERIC_SEVERITY: Record<EFlag, number>;
+type SeverityToColor = Record<number, keyof typeof DISK_COLOR_STATE_TO_NUMERIC_SEVERITY>;
+export declare const DISK_NUMERIC_SEVERITY_TO_STATE_COLOR: SeverityToColor;
+export declare const NOT_AVAILABLE_SEVERITY: number;
+export declare const NOT_AVAILABLE_SEVERITY_COLOR: EFlag;
+export declare const VDISK_STATE_SEVERITY: Record<EVDiskState, number>;
+export declare const PDISK_STATE_SEVERITY: {
+    Initial: number;
+    Normal: number;
+    InitialFormatRead: number;
+    InitialSysLogRead: number;
+    InitialCommonLogRead: number;
+    InitialFormatReadError: number;
+    InitialSysLogReadError: number;
+    InitialSysLogParseError: number;
+    InitialCommonLogReadError: number;
+    InitialCommonLogParseError: number;
+    CommonLoggerInitError: number;
+    OpenFileError: number;
+    ChunkQuotaError: number;
+    DeviceIoError: number;
+};
+export {};

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]) => (Object.assign(Object.assign({}, 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.Initial]: 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,
+    [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,
+};

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

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

package/dist/utils/{pdisk.js → disks/getPDiskType.js}

@@ -1,4 +1,3 @@
-// TODO: move to utils or index after converting them to TS
 /**
  * Parses a binary string containing a bit field into an object with binary values.
  * This is an implementation based on string manipulation, since JS can only perform
@@ -8,7 +7,7 @@
  * @param bitFieldStruct - bit field description, <field => size in bits>, in order starting from the rightmost bit
  * @returns object with binary values
  */
-export const parseBitField = (binaryString, bitFieldStruct) => {
+function parseBitField(binaryString, bitFieldStruct) {
     const fields = {};
     Object.entries(bitFieldStruct).reduce((prefixSize, [field, size]) => {
         const end = binaryString.length - prefixSize;
@@ -17,13 +16,12 @@ export const parseBitField = (binaryString, bitFieldStruct) => {
         return prefixSize + size;
     }, 0);
     return fields;
+}
+export const PDISK_TYPES = {
+    HDD: 'HDD',
+    SSD: 'SSD',
+    MVME: 'NVME',
 };
-export var IPDiskType;
-(function (IPDiskType) {
-    IPDiskType["HDD"] = "HDD";
-    IPDiskType["SSD"] = "SSD";
-    IPDiskType["MVME"] = "NVME";
-})(IPDiskType || (IPDiskType = {}));
 // Bear with me.
 // Disk type is determined by the field Category.
 // Category is a bit field defined as follows:
@@ -37,12 +35,12 @@ export var IPDiskType;
 // SSD  -> IsSolidState# 1, TypeExt# 0
 // NVME -> IsSolidState# 1, TypeExt# 2
 // Reference on bit fields: https://en.cppreference.com/w/c/language/bit_field
-export const getPDiskType = (data) => {
-    if (!data.Category) {
+export function getPDiskType(category) {
+    if (!category) {
         return undefined;
     }
     // Category is uint64, too big for Number or bitwise operators, thus BigInt and a custom parser
-    const categotyBin = BigInt(data.Category).toString(2);
+    const categotyBin = BigInt(category).toString(2);
     const categoryBitField = parseBitField(categotyBin, {
         isSolidState: 1,
         kind: 55,
@@ -51,13 +49,13 @@ export const getPDiskType = (data) => {
     if (categoryBitField.isSolidState === '1') {
         switch (parseInt(categoryBitField.typeExt, 2)) {
             case 0:
-                return IPDiskType.SSD;
+                return PDISK_TYPES.SSD;
             case 2:
-                return IPDiskType.MVME;
+                return PDISK_TYPES.MVME;
         }
     }
     else if (categoryBitField.typeExt === '0') {
-        return IPDiskType.HDD;
+        return PDISK_TYPES.HDD;
     }
     return undefined;
-};
+}

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

@@ -0,0 +1,3 @@
+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;

package/dist/utils/disks/helpers.js

@@ -0,0 +1,10 @@
+import { DISK_NUMERIC_SEVERITY_TO_STATE_COLOR, NOT_AVAILABLE_SEVERITY_COLOR } from './constants';
+export function isFullVDiskData(disk) {
+    return 'VDiskId' in disk;
+}
+export function getSeverityColor(severity) {
+    if (severity === undefined) {
+        return NOT_AVAILABLE_SEVERITY_COLOR;
+    }
+    return DISK_NUMERIC_SEVERITY_TO_STATE_COLOR[severity] || NOT_AVAILABLE_SEVERITY_COLOR;
+}

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

@@ -0,0 +1,5 @@
+import type { 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;

package/dist/utils/disks/prepareDisks.js

@@ -0,0 +1,40 @@
+import { isNumeric } from '../utils';
+import { calculatePDiskSeverity } from './calculatePDiskSeverity';
+import { calculateVDiskSeverity } from './calculateVDiskSeverity';
+import { getPDiskType } from './getPDiskType';
+export function prepareVDiskData(vdiskState = {}) {
+    var _a;
+    // Prepare PDisk only if it is present
+    const PDisk = vdiskState.PDisk ? preparePDiskData(vdiskState.PDisk) : undefined;
+    const AllocatedPercent = calculateVDiskAllocatedPercent(vdiskState.AllocatedSize, vdiskState.AvailableSize, PDisk === null || PDisk === void 0 ? void 0 : PDisk.AvailableSize);
+    const Donors = (_a = vdiskState.Donors) === null || _a === void 0 ? void 0 : _a.map((donor) => {
+        return prepareVDiskData(Object.assign(Object.assign({}, donor), { DonorMode: true }));
+    });
+    const Severity = calculateVDiskSeverity(vdiskState);
+    return Object.assign(Object.assign({}, vdiskState), { PDisk,
+        AllocatedPercent,
+        Donors,
+        Severity });
+}
+export function preparePDiskData(pdiskState = {}) {
+    const { AvailableSize, TotalSize, Category } = pdiskState;
+    const Type = getPDiskType(Category);
+    const AllocatedPercent = calculatePDiskAllocatedPercent(AvailableSize, TotalSize);
+    const Severity = calculatePDiskSeverity(pdiskState, AllocatedPercent);
+    return Object.assign(Object.assign({}, pdiskState), { Type,
+        AllocatedPercent,
+        Severity });
+}
+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

@@ -0,0 +1,15 @@
+import type { TPDiskStateInfo } from '../../types/api/pdisk';
+import type { TVDiskStateInfo } from '../../types/api/vdisk';
+import type { ValueOf } from '../../types/common';
+import type { PDISK_TYPES } from './getPDiskType';
+export interface PreparedPDisk extends TPDiskStateInfo {
+    Type?: PDiskType;
+    AllocatedPercent?: number;
+    Severity?: number;
+}
+export interface PreparedVDisk extends TVDiskStateInfo {
+    PDisk?: PreparedPDisk;
+    AllocatedPercent?: number;
+    Severity?: number;
+}
+export type PDiskType = ValueOf<typeof PDISK_TYPES>;

package/dist/utils/disks/types.js

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

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

@@ -1,5 +1,6 @@
 export * from './useAutofetcher';
 export * from './useTypedSelector';
+export * from './useTypedDispatch';
 export * from './useSetting';
 export * from './useQueryModes';
 export * from './useTableSort';

package/dist/utils/hooks/index.js

@@ -1,5 +1,6 @@
 export * from './useAutofetcher';
 export * from './useTypedSelector';
+export * from './useTypedDispatch';
 export * from './useSetting';
 export * from './useQueryModes';
 export * from './useTableSort';

package/dist/utils/hooks/useSetting.js

@@ -1,9 +1,9 @@
 import { useCallback } from 'react';
-import { useDispatch } from 'react-redux';
 import { getSettingValue, setSettingValue } from '../../store/reducers/settings/settings';
 import { useTypedSelector } from './useTypedSelector';
+import { useTypedDispatch } from './useTypedDispatch';
 export const useSetting = (key, defaultValue) => {
-    const dispatch = useDispatch();
+    const dispatch = useTypedDispatch();
     const settingValue = useTypedSelector((state) => {
         var _a;
         // Since we type setter value as T, we assume that received value is also T

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

@@ -1,7 +1,7 @@
 import type { Column as DataTableColumn } from '@gravity-ui/react-data-table';
 import type { Column as VirtualTableColumn } from '../../components/VirtualTable';
-export declare type Column<T> = VirtualTableColumn<T> & DataTableColumn<T>;
-export declare type TableColumnsWidthSetup = Record<string, number>;
-export declare type HandleTableColumnsResize = (newSetup: TableColumnsWidthSetup) => void;
+export type Column<T> = VirtualTableColumn<T> & DataTableColumn<T>;
+export type TableColumnsWidthSetup = Record<string, number>;
+export type HandleTableColumnsResize = (newSetup: TableColumnsWidthSetup) => void;
 export declare const updateColumnsWidth: <T>(columns: Column<T>[], columnsWidthSetup: TableColumnsWidthSetup) => Column<T>[];
 export declare const useTableResize: (localStorageKey: string) => [TableColumnsWidthSetup, HandleTableColumnsResize];

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

@@ -3,6 +3,6 @@ interface SortParams {
     sortValue: string | undefined;
     sortOrder: OrderType | undefined;
 }
-export declare type HandleSort = (rawValue: SortOrder | SortOrder[] | undefined) => void;
+export type HandleSort = (rawValue: SortOrder | SortOrder[] | undefined) => void;
 export declare const useTableSort: ({ sortValue, sortOrder }: SortParams, onSort: (params: SortParams) => void) => [SortOrder | undefined, HandleSort];
 export {};

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

@@ -0,0 +1,2 @@
+import type { AppDispatch } from '../../store';
+export declare const useTypedDispatch: () => AppDispatch;

package/dist/utils/hooks/useTypedDispatch.js

@@ -0,0 +1,2 @@
+import { useDispatch } from 'react-redux';
+export const useTypedDispatch = useDispatch;

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

@@ -1,3 +1,3 @@
 import { TypedUseSelectorHook } from 'react-redux';
-import { RootState } from '../../store';
+import type { RootState } from '../../store';
 export declare const useTypedSelector: TypedUseSelectorHook<RootState>;

package/dist/utils/index.d.ts

@@ -1 +1,2 @@
 export declare const getArray: (arrayLength: number) => number[];
+export declare function valueIsDefined<T>(value: T | null | undefined): value is T;

package/dist/utils/index.js

@@ -1,3 +1,6 @@
 export const getArray = (arrayLength) => {
     return [...Array(arrayLength).keys()];
 };
+export function valueIsDefined(value) {
+    return value !== null && value !== undefined;
+}

package/dist/utils/monaco.d.ts

@@ -1,2 +1,3 @@
 export declare const LANGUAGE_S_EXPRESSION_ID = "s-expression";
+export declare function registerYQLCompletionItemProvider(database: string): void;
 export declare function registerLanguages(): void;

package/dist/utils/monaco.js

@@ -1,4 +1,5 @@
 import * as monaco from 'monaco-editor';
+import { createProvideSuggestionsFunction } from './yqlSuggestions/yqlSuggestions';
 export const LANGUAGE_S_EXPRESSION_ID = 's-expression';
 function registerSExpressionLanguage() {
     monaco.languages.register({ id: LANGUAGE_S_EXPRESSION_ID });
@@ -57,6 +58,19 @@ 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/monitoring.d.ts

@@ -1,4 +1,4 @@
-export declare type ParsedMonitoringData = {
+export type ParsedMonitoringData = {
     monitoring_url: string;
     serverless_dashboard: string;
     dedicated_dashboard: string;
@@ -12,8 +12,8 @@ export interface GetMonitoringLinkProps {
     dbType: string;
     clusterName?: string;
 }
-export declare type GetMonitoringLink = typeof getMonitoringLink;
+export type GetMonitoringLink = typeof getMonitoringLink;
 export declare function getMonitoringLink({ monitoring, dbName, dbType, clusterName, }: GetMonitoringLinkProps): string;
-export declare type GetMonitoringClusterLink = typeof getMonitoringClusterLink;
+export type GetMonitoringClusterLink = typeof getMonitoringClusterLink;
 export declare function getMonitoringClusterLink(monitoring: string): string;
 export declare function parseMonitoringData(monitoring: string): ParsedMonitoringData | undefined;

package/dist/utils/nodes.d.ts

@@ -13,7 +13,7 @@ export declare const NodesUptimeFilterTitles: {
     SmallUptime: string;
 };
 export declare const isUnavailableNode: (node: NodesPreparedEntity | TSystemStateInfo) => boolean;
-export declare const prepareNodesMap: (nodesList?: TNodeInfo[] | undefined) => NodesMap | undefined;
+export declare const prepareNodesMap: (nodesList?: TNodeInfo[]) => NodesMap | undefined;
 export interface PreparedNodeSystemState extends TSystemStateInfo {
     Rack?: string;
     DC?: string;
@@ -40,5 +40,5 @@ export declare const NODES_SORT_VALUES: {
     readonly CPU: "CPU";
     readonly LoadAverage: "LoadAverage";
 };
-export declare type NodesSortValue = ValueOf<typeof NODES_SORT_VALUES>;
+export type NodesSortValue = ValueOf<typeof NODES_SORT_VALUES>;
 export declare const isSortableNodesProperty: (value: string) => value is NodesSortValue;