ydb-embedded-ui 4.33.0 → 5.1.0

package/dist/utils/timeParsers/formatDuration.js

@@ -0,0 +1,63 @@
+import { DAY_IN_SECONDS, HOUR_IN_SECONDS } from '../constants';
+import { formatNumber } from '../dataFormatters/dataFormatters';
+import i18n from './i18n';
+/**
+ * Process time difference in ms and returns formated time.
+ * By default only two major values are returned (days & hours, hours & minutes, minutes & seconds, etc.).
+ * It can be altered with valuesCount arg
+ *
+ * value - duration in ms
+ */
+export const formatDurationToShortTimeFormat = (value, valuesCount = 2) => {
+    const ms = value % 1000;
+    let remain = Math.floor(value / 1000);
+    const days = Math.floor(remain / DAY_IN_SECONDS);
+    remain = remain % DAY_IN_SECONDS;
+    const hours = Math.floor(remain / HOUR_IN_SECONDS);
+    remain = remain % HOUR_IN_SECONDS;
+    const minutes = Math.floor(remain / 60);
+    remain = remain % 60;
+    const seconds = remain;
+    const duration = {
+        days,
+        hours,
+        minutes,
+        seconds,
+        ms,
+    };
+    if (valuesCount === 2) {
+        if (days > 0) {
+            return i18n('daysHours', duration);
+        }
+        if (hours > 0) {
+            return i18n('hoursMin', duration);
+        }
+        if (minutes > 0) {
+            return i18n('minSec', duration);
+        }
+        if (seconds > 0) {
+            return i18n('secMs', duration);
+        }
+    }
+    if (valuesCount === 1) {
+        if (days > 0) {
+            return i18n('days', duration);
+        }
+        if (hours > 0) {
+            return i18n('hours', duration);
+        }
+        if (minutes > 0) {
+            return i18n('min', duration);
+        }
+        if (seconds > 0) {
+            return i18n('sec', duration);
+        }
+    }
+    return i18n('ms', duration);
+};
+/**
+ * Parse ms duration to string
+ */
+export const formatToMs = (value) => {
+    return i18n('ms', { ms: formatNumber(value) });
+};

package/dist/utils/timeParsers/i18n/en.json

@@ -1,11 +1,11 @@
 {
-  "daysHours": "{{days}}\u00a0d\u00a0{{hours}}\u00a0h",
-  "hoursMin": "{{hours}}\u00a0h\u00a0{{minutes}}\u00a0m",
-  "minSec": "{{minutes}}\u00a0m\u00a0{{seconds}}\u00a0s",
-  "secMs": "{{seconds}}\u00a0s\u00a0{{ms}}\u00a0ms",
-  "days": "{{days}}\u00a0d",
-  "hours": "{{hours}}\u00a0h",
-  "min": "{{minutes}}\u00a0m",
-  "sec": "{{seconds}}\u00a0s",
-  "ms": "{{ms}}\u00a0ms"
+    "daysHours": "{{days}}\u00a0d\u00a0{{hours}}\u00a0h",
+    "hoursMin": "{{hours}}\u00a0h\u00a0{{minutes}}\u00a0m",
+    "minSec": "{{minutes}}\u00a0m\u00a0{{seconds}}\u00a0s",
+    "secMs": "{{seconds}}\u00a0s\u00a0{{ms}}\u00a0ms",
+    "days": "{{days}}\u00a0d",
+    "hours": "{{hours}}\u00a0h",
+    "min": "{{minutes}}\u00a0m",
+    "sec": "{{seconds}}\u00a0s",
+    "ms": "{{ms}}\u00a0ms"
 }

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

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

package/dist/utils/timeParsers/i18n/index.js

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

package/dist/utils/timeParsers/i18n/ru.json

@@ -1,11 +1,11 @@
 {
-  "daysHours": "{{days}}\u00a0д\u00a0{{hours}}\u00a0ч",
-  "hoursMin": "{{hours}}\u00a0ч\u00a0{{minutes}}\u00a0м",
-  "minSec": "{{minutes}}\u00a0м\u00a0{{seconds}}\u00a0с",
-  "secMs": "{{seconds}}\u00a0с\u00a0{{ms}}\u00a0мс",
-  "days": "{{days}}\u00a0д",
-  "hours": "{{hours}}\u00a0ч",
-  "min": "{{minutes}}\u00a0м",
-  "sec": "{{seconds}}\u00a0с",
-  "ms": "{{ms}}\u00a0мс"
+    "daysHours": "{{days}}\u00a0д\u00a0{{hours}}\u00a0ч",
+    "hoursMin": "{{hours}}\u00a0ч\u00a0{{minutes}}\u00a0м",
+    "minSec": "{{minutes}}\u00a0м\u00a0{{seconds}}\u00a0с",
+    "secMs": "{{seconds}}\u00a0с\u00a0{{ms}}\u00a0мс",
+    "days": "{{days}}\u00a0д",
+    "hours": "{{hours}}\u00a0ч",
+    "min": "{{minutes}}\u00a0м",
+    "sec": "{{seconds}}\u00a0с",
+    "ms": "{{ms}}\u00a0мс"
 }

package/dist/utils/timeParsers/index.js

@@ -0,0 +1,3 @@
+export * from './formatDuration';
+export * from './protobufParsers';
+export * from './parsers';

package/dist/utils/timeParsers/parsers.d.ts

@@ -0,0 +1,4 @@
+import type { IProtobufTimeObject } from '../../types/api/common';
+export declare const parseLag: (value: string | IProtobufTimeObject | undefined) => number;
+export declare const parseTimestampToIdleTime: (value: string | IProtobufTimeObject | undefined) => number;
+export declare const parseUsToMs: (value: string | number | undefined) => number;

package/dist/utils/timeParsers/parsers.js

@@ -0,0 +1,18 @@
+import { isNumeric } from '../utils';
+import { parseProtobufDurationToMs, parseProtobufTimestampToMs } from '.';
+export const parseLag = (value) => value ? parseProtobufDurationToMs(value) : 0;
+export const parseTimestampToIdleTime = (value) => {
+    if (!value) {
+        return 0;
+    }
+    const duration = Date.now() - parseProtobufTimestampToMs(value);
+    // Duration could be negative because of the difference between server and local time
+    // Usually it below 100ms, so it could be omitted
+    return duration < 0 ? 0 : duration;
+};
+export const parseUsToMs = (value) => {
+    if (!value || !isNumeric(value)) {
+        return 0;
+    }
+    return Math.round(Number(value) / 1000);
+};

package/dist/utils/timeParsers/protobufParsers.d.ts

@@ -0,0 +1,15 @@
+import type { IProtobufTimeObject } from '../../types/api/common';
+/**
+ * Parses Google.protobuf Duration and Timestamp represented by objects
+ */
+export declare const parseProtobufTimeObjectToMs: (value: IProtobufTimeObject) => number;
+/**
+ * Parses Google.protobuf Timestamp to ms.
+ * Timestamp could be represented as object or as date string
+ */
+export declare const parseProtobufTimestampToMs: (value: string | IProtobufTimeObject) => number;
+/**
+ * Parses Google.protobuf Duration to ms.
+ * Duration could be represented as object or as string with format '12345s'
+ */
+export declare const parseProtobufDurationToMs: (value: string | IProtobufTimeObject) => number;

package/dist/utils/timeParsers/protobufParsers.js

@@ -0,0 +1,33 @@
+import { MS_IN_NANOSECONDS } from '../constants';
+/**
+ * Parses Google.protobuf Duration and Timestamp represented by objects
+ */
+export const parseProtobufTimeObjectToMs = (value) => {
+    const secondsInMs = value.seconds ? Number(value.seconds) * 1000 : 0;
+    const nanosecondsInMs = value.nanos ? value.nanos / MS_IN_NANOSECONDS : 0;
+    return secondsInMs + nanosecondsInMs;
+};
+/**
+ * Parses Google.protobuf Timestamp to ms.
+ * Timestamp could be represented as object or as date string
+ */
+export const parseProtobufTimestampToMs = (value) => {
+    if (typeof value === 'string') {
+        return Date.parse(value);
+    }
+    else {
+        return parseProtobufTimeObjectToMs(value);
+    }
+};
+/**
+ * Parses Google.protobuf Duration to ms.
+ * Duration could be represented as object or as string with format '12345s'
+ */
+export const parseProtobufDurationToMs = (value) => {
+    if (typeof value === 'string') {
+        return parseInt(value, 10) * 1000;
+    }
+    else {
+        return parseProtobufTimeObjectToMs(value);
+    }
+};

package/dist/utils/timeframes.d.ts

@@ -0,0 +1,7 @@
+export declare const TIMEFRAMES: {
+    readonly '30m': number;
+    readonly '1h': number;
+    readonly '1d': number;
+    readonly '1w': number;
+};
+export declare type TimeFrame = keyof typeof TIMEFRAMES;

package/dist/utils/timeframes.js

@@ -0,0 +1,7 @@
+import { DAY_IN_SECONDS, HOUR_IN_SECONDS, MINUTE_IN_SECONDS } from './constants';
+export const TIMEFRAMES = {
+    '30m': 30 * MINUTE_IN_SECONDS,
+    '1h': HOUR_IN_SECONDS,
+    '1d': DAY_IN_SECONDS,
+    '1w': 7 * DAY_IN_SECONDS,
+};

package/dist/utils/tooltip.d.ts

@@ -0,0 +1,10 @@
+export namespace tooltipTemplates {
+    function pool(data: any): JSX.Element;
+    function tablet(data: any): JSX.Element;
+    function node(data: any): JSX.Element;
+    function nodeEndpoints(data: any): JSX.Element;
+    function tabletsOverall(data: any): JSX.Element;
+    function histogram(data: any): JSX.Element;
+    function cell(data: any): JSX.Element;
+    function json(data: any): JSX.Element;
+}

package/dist/utils/tooltip.js

@@ -1,128 +1,42 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import cn from 'bem-cn-lite';
 import JSONTree from 'react-json-inspector';
-
-import {
-    NodeEndpointsTooltipContent,
-    TabletTooltipContent,
-    PoolTooltipContent,
-} from '../components/TooltipsContent';
-
+import { NodeEndpointsTooltipContent, TabletTooltipContent, PoolTooltipContent, } from '../components/TooltipsContent';
 const nodeB = cn('node-tootltip');
-
 const NodeTooltip = (props) => {
-    const {data} = props;
-    return (
-        data && (
-            <div className={nodeB()}>
-                <table>
-                    <tbody>
-                        <tr>
-                            <td className={nodeB('label')}>ID</td>
-                            <td className={nodeB('value')}>{data.nodeId || '?'}</td>
-                        </tr>
-                        <tr>
-                            <td className={nodeB('label')}>Rack</td>
-                            <td className={nodeB('value')}>{data.rack || '?'}</td>
-                        </tr>
-                        {data.connected && data.capacity && (
-                            <tr>
-                                <td className={nodeB('label')}>Net</td>
-                                <td className={nodeB('value')}>
-                                    {`${data.connected} / ${data.capacity}`}
-                                </td>
-                            </tr>
-                        )}
-                    </tbody>
-                </table>
-            </div>
-        )
-    );
+    const { data } = props;
+    return (data && (_jsx("div", Object.assign({ className: nodeB() }, { children: _jsx("table", { children: _jsxs("tbody", { children: [_jsxs("tr", { children: [_jsx("td", Object.assign({ className: nodeB('label') }, { children: "ID" })), _jsx("td", Object.assign({ className: nodeB('value') }, { children: data.nodeId || '?' }))] }), _jsxs("tr", { children: [_jsx("td", Object.assign({ className: nodeB('label') }, { children: "Rack" })), _jsx("td", Object.assign({ className: nodeB('value') }, { children: data.rack || '?' }))] }), data.connected && data.capacity && (_jsxs("tr", { children: [_jsx("td", Object.assign({ className: nodeB('label') }, { children: "Net" })), _jsx("td", Object.assign({ className: nodeB('value') }, { children: `${data.connected} / ${data.capacity}` }))] }))] }) }) }))));
 };
-
 const tabletsOverallB = cn('tabletsOverall-tooltip');
-
 const TabletsOverallTooltip = (props) => {
-    const {data} = props;
-    return (
-        data && (
-            <div className={tabletsOverallB()}>
-                <table>
-                    <tbody>
-                        {data.map((colorInfo, key) => {
-                            return (
-                                <tr key={key}>
-                                    <td className={tabletsOverallB('label')}>{colorInfo.color}:</td>
-                                    <td className={tabletsOverallB('value')}>
-                                        {`${colorInfo.value}/${
-                                            colorInfo.total
-                                        } (${colorInfo.percents.toFixed(2)}%)`}
-                                    </td>
-                                </tr>
-                            );
-                        })}
-                    </tbody>
-                </table>
-            </div>
-        )
-    );
+    const { data } = props;
+    return (data && (_jsx("div", Object.assign({ className: tabletsOverallB() }, { children: _jsx("table", { children: _jsx("tbody", { children: data.map((colorInfo, key) => {
+                    return (_jsxs("tr", { children: [_jsxs("td", Object.assign({ className: tabletsOverallB('label') }, { children: [colorInfo.color, ":"] })), _jsx("td", Object.assign({ className: tabletsOverallB('value') }, { children: `${colorInfo.value}/${colorInfo.total} (${colorInfo.percents.toFixed(2)}%)` }))] }, key));
+                }) }) }) }))));
 };
-
 const histogramB = cn('histogram-tooltip');
-
 const HistogramTooltip = (props) => {
-    const {data} = props;
-    return (
-        data && (
-            <div className={histogramB()}>
-                <table>
-                    <tbody>
-                        <tr>
-                            <td className={histogramB('label')}>Count</td>
-                            <td className={histogramB('value')}>{data.count || '?'}</td>
-                        </tr>
-                        <tr>
-                            <td className={histogramB('label')}>From</td>
-                            <td className={histogramB('value')}>{data.leftBound || '?'}</td>
-                        </tr>
-                        <tr>
-                            <td className={histogramB('label')}>To</td>
-                            <td className={histogramB('value')}>{data.rightBound || '?'}</td>
-                        </tr>
-                    </tbody>
-                </table>
-            </div>
-        )
-    );
+    const { data } = props;
+    return (data && (_jsx("div", Object.assign({ className: histogramB() }, { children: _jsx("table", { children: _jsxs("tbody", { children: [_jsxs("tr", { children: [_jsx("td", Object.assign({ className: histogramB('label') }, { children: "Count" })), _jsx("td", Object.assign({ className: histogramB('value') }, { children: data.count || '?' }))] }), _jsxs("tr", { children: [_jsx("td", Object.assign({ className: histogramB('label') }, { children: "From" })), _jsx("td", Object.assign({ className: histogramB('value') }, { children: data.leftBound || '?' }))] }), _jsxs("tr", { children: [_jsx("td", Object.assign({ className: histogramB('label') }, { children: "To" })), _jsx("td", Object.assign({ className: histogramB('value') }, { children: data.rightBound || '?' }))] })] }) }) }))));
 };
-
 const cellB = cn('cell-tooltip');
 const jsonB = cn('json-tooltip');
-
 export const tooltipTemplates = {
     // eslint-disable-next-line react/display-name
-    pool: (data) => <PoolTooltipContent data={data} />,
+    pool: (data) => _jsx(PoolTooltipContent, { data: data }),
     // eslint-disable-next-line react/display-name
-    tablet: (data) => <TabletTooltipContent data={data} />,
+    tablet: (data) => _jsx(TabletTooltipContent, { data: data }),
     // eslint-disable-next-line react/display-name
-    node: (data) => <NodeTooltip data={data} />,
-    nodeEndpoints: (data) => <NodeEndpointsTooltipContent data={data} />,
+    node: (data) => _jsx(NodeTooltip, { data: data }),
+    nodeEndpoints: (data) => _jsx(NodeEndpointsTooltipContent, { data: data }),
     // eslint-disable-next-line react/display-name
-    tabletsOverall: (data) => <TabletsOverallTooltip data={data} />,
+    tabletsOverall: (data) => _jsx(TabletsOverallTooltip, { data: data }),
     // eslint-disable-next-line react/display-name
-    histogram: (data) => <HistogramTooltip data={data} />,
+    histogram: (data) => _jsx(HistogramTooltip, { data: data }),
     // eslint-disable-next-line react/display-name
-    cell: (data) => <div className={cellB()}>{data}</div>,
+    cell: (data) => _jsx("div", Object.assign({ className: cellB() }, { children: data })),
     // eslint-disable-next-line react/display-name
     json: (data) => {
-        return (
-            <div className={jsonB()}>
-                <JSONTree
-                    data={data}
-                    search={false}
-                    isExpanded={() => true}
-                    className={jsonB('inspector')}
-                />
-            </div>
-        );
+        return (_jsx("div", Object.assign({ className: jsonB() }, { children: _jsx(JSONTree, { data: data, search: false, isExpanded: () => true, className: jsonB('inspector') }) })));
     },
 };

package/dist/utils/typecheckers.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Intended to typecheck enums, but also checks if the value is any of the arbitrary object values
+ */
+export declare const isEnumMember: <T extends Object>(object: T, value: any) => value is T[keyof T];

package/dist/utils/typecheckers.js

@@ -0,0 +1,4 @@
+/**
+ * Intended to typecheck enums, but also checks if the value is any of the arbitrary object values
+ */
+export const isEnumMember = (object, value) => Object.values(object).includes(value);

package/dist/utils/utils.d.ts

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

package/dist/utils/utils.js

@@ -4,28 +4,29 @@ export function parseJson(value) {
     }
     try {
         return JSON.parse(value);
-    } catch (err) {
+    }
+    catch (err) {
         return value;
     }
 }
-
 export function getValueFromLS(key, defaultValue) {
+    var _a;
     try {
-        return localStorage.getItem(key) ?? defaultValue;
-    } catch (err) {
+        return (_a = localStorage.getItem(key)) !== null && _a !== void 0 ? _a : defaultValue;
+    }
+    catch (err) {
         console.log(err);
     }
     return;
 }
-
 const sizes = [' B', ' KB', ' MB', ' GB', ' TB', ' PB', ' EB'];
 const base = 1000;
-
 export function bytesToSize(bytes) {
     if (isNaN(bytes)) {
         return '';
     }
-    if (bytes < base) return String(bytes);
+    if (bytes < base)
+        return String(bytes);
     let i = parseInt(Math.floor(Math.log(bytes) / Math.log(base)));
     if (i >= sizes.length) {
         i = sizes.length - 1;
@@ -37,7 +38,6 @@ export function bytesToSize(bytes) {
     }
     return val.toPrecision(3) + sizes[i];
 }
-
 function bytesToMB(bytes) {
     if (isNaN(bytes)) {
         return '';
@@ -45,17 +45,17 @@ function bytesToMB(bytes) {
     const val = bytes / base ** 2;
     if (val < 10) {
         return val.toFixed(2) + sizes[2];
-    } else if (val < 100) {
+    }
+    else if (val < 100) {
         return val.toFixed(1) + sizes[2];
-    } else {
+    }
+    else {
         return val.toFixed() + sizes[2];
     }
 }
-
 export function bytesToSpeed(bytes) {
     return `${bytesToMB(bytes)}${bytes ? 'ps' : ''}`;
 }
-
 export function bytesToGB(bytes, shouldRound) {
     if (isNaN(bytes)) {
         return 'N/A';
@@ -66,13 +66,14 @@ export function bytesToGB(bytes, shouldRound) {
     }
     if (val < 10) {
         return val.toFixed(2) + sizes[3];
-    } else if (val < 100) {
+    }
+    else if (val < 100) {
         return val.toFixed(1) + sizes[3];
-    } else {
+    }
+    else {
         return val.toFixed() + sizes[3];
     }
 }
-
 export function pad9(val) {
     const len = String(val).length;
     let result = val;
@@ -81,7 +82,6 @@ export function pad9(val) {
     }
     return result;
 }
-
 export function isNumeric(value) {
     // need both isNaN and isNaN(parseFloat):
     // - isNaN treats true/false/''/etc. as numbers, parseFloat fixes this

package/dist/utils/versions/getVersionsColors.d.ts

@@ -0,0 +1,7 @@
+import type { VersionToColorMap, VersionsMap } from '../../types/versions';
+export declare const hashCode: (s: string) => number;
+export declare const COLORS: string[];
+export declare const GRAY_COLOR = "#bfbfbf";
+export declare const getVersionsMap: (versions: string[], initialMap?: VersionsMap) => VersionsMap;
+export declare const getVersionToColorMap: (versionsMap: VersionsMap) => VersionToColorMap;
+export declare const parseVersionsToVersionToColorMap: (versions?: string[]) => VersionToColorMap;

package/dist/utils/versions/getVersionsColors.js

@@ -0,0 +1,84 @@
+import { getMajorVersion, getMinorVersion } from './parseVersion';
+export const hashCode = (s) => {
+    return s.split('').reduce((a, b) => {
+        const num = (a << 5) - a + b.charCodeAt(0); // eslint-disable-line
+        return num & num; // eslint-disable-line
+    }, 0);
+};
+// TODO: colors used in charts as well, need to move to constants
+// 11 distinct colors from https://mokole.com/palette.html
+export const COLORS = [
+    '#008000',
+    '#4169e1',
+    '#ffd700',
+    '#ff8c00',
+    '#808000',
+    '#e9967a',
+    '#ff1493',
+    '#00bfff',
+    '#da70d6',
+    '#3cb371',
+    '#b22222', // firebrick
+];
+export const GRAY_COLOR = '#bfbfbf';
+export const getVersionsMap = (versions, initialMap = new Map()) => {
+    versions.forEach((version) => {
+        var _a;
+        const majorVersion = getMajorVersion(version);
+        const minorVersion = getMinorVersion(version);
+        if (!initialMap.has(majorVersion)) {
+            initialMap.set(majorVersion, new Set());
+        }
+        (_a = initialMap.get(majorVersion)) === null || _a === void 0 ? void 0 : _a.add(minorVersion);
+    });
+    return initialMap;
+};
+export const getVersionToColorMap = (versionsMap) => {
+    const clustersVersions = Array.from(versionsMap.keys()).map((version) => {
+        return {
+            version,
+            hash: hashCode(version),
+        };
+    });
+    const versionToColor = new Map();
+    // not every version is colored, therefore iteration index can't be used consistently
+    // init with the colors length to put increment right after condition for better readability
+    let currentColorIndex = COLORS.length - 1;
+    clustersVersions
+        // ascending by version name, just for consistency
+        // sorting only impacts color choose for a version
+        .sort((a, b) => a.hash - b.hash)
+        .forEach((item) => {
+        if (/^(\w+-)?stable/.test(item.version)) {
+            currentColorIndex = (currentColorIndex + 1) % COLORS.length;
+            versionToColor.set(item.version, COLORS[currentColorIndex]);
+            const minors = Array.from(versionsMap.get(item.version) || [])
+                .filter((v) => v !== item.version)
+                .map((v) => {
+                return {
+                    version: v,
+                    hash: hashCode(v),
+                };
+            });
+            const minorQuantity = minors.length;
+            minors
+                // descending by version name: newer versions come first,
+                // so the newer version gets the brighter color
+                .sort((a, b) => b.hash - a.hash)
+                .forEach((minor, minorIndex) => {
+                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.version, versionColor);
+            });
+        }
+        else {
+            versionToColor.set(item.version, GRAY_COLOR);
+        }
+    });
+    return versionToColor;
+};
+export const parseVersionsToVersionToColorMap = (versions = []) => {
+    return getVersionToColorMap(getVersionsMap(versions));
+};

package/dist/utils/versions/index.js

@@ -0,0 +1,3 @@
+export * from './getVersionsColors';
+export * from './parseVersion';
+export * from './parseNodesToVersionsValues';

package/dist/utils/versions/parseNodesToVersionsValues.d.ts

@@ -0,0 +1,3 @@
+import type { TSystemStateInfo } from '../../types/api/nodes';
+import type { VersionToColorMap, VersionValue } from '../../types/versions';
+export declare const parseNodesToVersionsValues: (nodes?: TSystemStateInfo[], versionsToColor?: VersionToColorMap | undefined) => VersionValue[];

package/dist/utils/versions/parseNodesToVersionsValues.js

@@ -0,0 +1,22 @@
+import { getMinorVersion } from './parseVersion';
+export const parseNodesToVersionsValues = (nodes = [], versionsToColor) => {
+    const versionsCount = nodes.reduce((acc, node) => {
+        if (node.Version) {
+            if (acc[node.Version]) {
+                acc[node.Version] = acc[node.Version] + 1;
+            }
+            else {
+                acc[node.Version] = 1;
+            }
+        }
+        return acc;
+    }, {});
+    return Object.keys(versionsCount).map((version) => {
+        return {
+            title: version,
+            version: version,
+            color: versionsToColor === null || versionsToColor === void 0 ? void 0 : versionsToColor.get(getMinorVersion(version)),
+            value: (versionsCount[version] / nodes.length) * 100,
+        };
+    });
+};

package/dist/utils/versions/parseVersion.d.ts

@@ -0,0 +1,2 @@
+export declare const getMinorVersion: (version: string) => string;
+export declare const getMajorVersion: (version: string) => string;

package/dist/utils/versions/parseVersion.js

@@ -0,0 +1,17 @@
+export const getMinorVersion = (version) => {
+    const regexp = /\d{1,}-\d{1,}(-\d){0,}(-hotfix-\d{1,}(-\d{1,})?)?\.[0-9a-zA-Z]+$/;
+    let result = version;
+    if (regexp.test(version)) {
+        result = result.replace(/(-hotfix-\d{1,}(-\d{1,})?)?\.[0-9a-zA-Z]+$/, ''); // stable-19-2-18.bfa368f -> stable-19-2-18
+    }
+    const buildVersionRegexp = /\d{1,}-\d{1,}-\d{1,}-\d{1,}$/;
+    if (buildVersionRegexp.test(version)) {
+        result = result.replace(/-\d{1,}$/, ''); // stable-19-2-18-1 -> stable-19-2-18
+    }
+    return result;
+};
+export const getMajorVersion = (version) => {
+    const minorVersion = getMinorVersion(version);
+    const regexp = /\d{1,}-\d{1,}-\d{1,}/; // to check versions that have minor part
+    return regexp.test(minorVersion) ? minorVersion.replace(/-\d{1,}$/, '') : minorVersion;
+};