@alauda-fe/common 1.0.0-next.0

package/esm2022/metric-chart/metric-time-pick.mjs

@@ -0,0 +1,114 @@
+import { IconComponent, SelectModule } from '@alauda/ui';
+import { NgForOf, NgIf } from '@angular/common';
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { EffectDirectiveModule } from '../effect-directive/module';
+import { TranslateModule } from '../translate/translate.module';
+import { SelectPrefixLabelDirective } from '../widget/select-prefix-label/directive';
+import { PICKER_TIME_RANGES } from './helpers';
+import * as i0 from "@angular/core";
+import * as i1 from "../translate/translate.pipe";
+import * as i2 from "@alauda/ui";
+import * as i3 from "@angular/forms";
+function MetricTimePickComponent_ng_template_0_ng_container_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelement(1, "aui-icon", 5);
+    i0.ɵɵelementContainerEnd();
+} }
+function MetricTimePickComponent_ng_template_0_ng_template_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵtext(0);
+    i0.ɵɵpipe(1, "translate");
+} if (rf & 2) {
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(1, 1, "time_range"), ":");
+} }
+function MetricTimePickComponent_ng_template_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵtemplate(0, MetricTimePickComponent_ng_template_0_ng_container_0_Template, 2, 0, "ng-container", 3);
+    i0.ɵɵtemplate(1, MetricTimePickComponent_ng_template_0_ng_template_1_Template, 2, 3, "ng-template", null, 4, i0.ɵɵtemplateRefExtractor);
+} if (rf & 2) {
+    const _r4 = i0.ɵɵreference(2);
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("ngIf", ctx_r1.icon)("ngIfElse", _r4);
+} }
+function MetricTimePickComponent_aui_option_3_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "aui-option", 6);
+    i0.ɵɵpipe(1, "translate");
+    i0.ɵɵtext(2);
+    i0.ɵɵpipe(3, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const item_r6 = ctx.$implicit;
+    i0.ɵɵproperty("label", i0.ɵɵpipeBind1(1, 3, item_r6.name))("value", item_r6);
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(3, 5, item_r6.name), " ");
+} }
+export class MetricTimePickComponent {
+    constructor() {
+        this.icon = true;
+        this.time = PICKER_TIME_RANGES[1];
+        this.timeRange = PICKER_TIME_RANGES;
+        this.timeSelected = new EventEmitter();
+    }
+    changeTime() {
+        this.timeSelected.emit(this.time);
+    }
+    static { this.ɵfac = function MetricTimePickComponent_Factory(t) { return new (t || MetricTimePickComponent)(); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: MetricTimePickComponent, selectors: [["acl-metric-time-pick"]], inputs: { icon: "icon", time: "time", timeRange: "timeRange" }, outputs: { timeSelected: "timeSelected" }, standalone: true, features: [i0.ɵɵStandaloneFeature], decls: 4, vars: 3, consts: [["iconWrapper", ""], [3, "aclPrefixLabel", "ngModel", "ngModelChange"], [3, "label", "value", 4, "ngFor", "ngForOf"], [4, "ngIf", "ngIfElse"], ["elseTemplate", ""], ["icon", "clock"], [3, "label", "value"]], template: function MetricTimePickComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵtemplate(0, MetricTimePickComponent_ng_template_0_Template, 3, 2, "ng-template", null, 0, i0.ɵɵtemplateRefExtractor);
+            i0.ɵɵelementStart(2, "aui-select", 1);
+            i0.ɵɵlistener("ngModelChange", function MetricTimePickComponent_Template_aui_select_ngModelChange_2_listener($event) { return ctx.time = $event; })("ngModelChange", function MetricTimePickComponent_Template_aui_select_ngModelChange_2_listener() { return ctx.changeTime(); });
+            i0.ɵɵtemplate(3, MetricTimePickComponent_aui_option_3_Template, 4, 7, "aui-option", 2);
+            i0.ɵɵelementEnd();
+        } if (rf & 2) {
+            const _r0 = i0.ɵɵreference(1);
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("aclPrefixLabel", _r0)("ngModel", ctx.time);
+            i0.ɵɵadvance(1);
+            i0.ɵɵproperty("ngForOf", ctx.timeRange);
+        } }, dependencies: [NgIf,
+            IconComponent,
+            TranslateModule, i1.TranslatePipe, SelectModule, i2.SelectComponent, i2.OptionComponent, EffectDirectiveModule,
+            SelectPrefixLabelDirective,
+            FormsModule, i3.NgControlStatus, i3.NgModel, NgForOf], styles: ["[_nghost-%COMP%] > aui-select[_ngcontent-%COMP%]{font-weight:400}"], changeDetection: 0 }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MetricTimePickComponent, [{
+        type: Component,
+        args: [{ selector: 'acl-metric-time-pick', template: `
+    <ng-template #iconWrapper>
+      <ng-container *ngIf="icon; else elseTemplate">
+        <aui-icon icon="clock"></aui-icon>
+      </ng-container>
+      <ng-template #elseTemplate> {{ 'time_range' | translate }}:</ng-template>
+    </ng-template>
+    <aui-select
+      [aclPrefixLabel]="iconWrapper"
+      [(ngModel)]="time"
+      (ngModelChange)="changeTime()"
+    >
+      <aui-option
+        *ngFor="let item of timeRange"
+        [label]="item.name | translate"
+        [value]="item"
+      >
+        {{ item.name | translate }}
+      </aui-option>
+    </aui-select>
+  `, changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [
+                    NgIf,
+                    IconComponent,
+                    TranslateModule,
+                    SelectModule,
+                    EffectDirectiveModule,
+                    SelectPrefixLabelDirective,
+                    FormsModule,
+                    NgForOf,
+                ], styles: [":host>aui-select{font-weight:400}\n"] }]
+    }], null, { icon: [{
+            type: Input
+        }], time: [{
+            type: Input
+        }], timeRange: [{
+            type: Input
+        }], timeSelected: [{
+            type: Output
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/metric-chart/public-api.mjs

@@ -0,0 +1,14 @@
+/**
+ * [[include:metric-chart/README.md]]
+ * @module view-chart
+ * @preferred
+ */
+export * from './common-chart.service';
+export * from './helpers';
+export * from './metric-chart.component';
+export * from './metric-chart.module';
+export * from './metric-time-pick';
+export * from './types';
+export * from './utils';
+export * from './range-util';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9tZXRyaWMtY2hhcnQvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBQ0gsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLFNBQVMsQ0FBQztBQUN4QixjQUFjLFNBQVMsQ0FBQztBQUN4QixjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogW1tpbmNsdWRlOm1ldHJpYy1jaGFydC9SRUFETUUubWRdXVxuICogQG1vZHVsZSB2aWV3LWNoYXJ0XG4gKiBAcHJlZmVycmVkXG4gKi9cbmV4cG9ydCAqIGZyb20gJy4vY29tbW9uLWNoYXJ0LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9oZWxwZXJzJztcbmV4cG9ydCAqIGZyb20gJy4vbWV0cmljLWNoYXJ0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL21ldHJpYy1jaGFydC5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9tZXRyaWMtdGltZS1waWNrJztcbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMnO1xuZXhwb3J0ICogZnJvbSAnLi91dGlscyc7XG5leHBvcnQgKiBmcm9tICcuL3JhbmdlLXV0aWwnO1xuIl19

package/esm2022/metric-chart/range-util.mjs

@@ -0,0 +1,35 @@
+export function roundInterval(start, end) {
+    const interval = ('' + start).length < 13
+        ? Math.abs(end - start)
+        : Math.abs(end - start) / 1000;
+    switch (true) {
+        // 30m
+        case interval <= 1800: {
+            return 30;
+        }
+        // 24h
+        case interval <= 86400: {
+            return 60;
+        }
+        // 2d
+        case interval <= 172800: {
+            return 60 * 2;
+        }
+        // 7d
+        case interval <= 604800: {
+            return 60 * 10;
+        }
+        // 30d
+        case interval <= 2592000: {
+            return 60 * 50;
+        }
+        // 60d
+        case interval <= 6480000: {
+            return 60 * 130;
+        }
+        default: {
+            return 60 * 10;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/metric-chart/types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/metric-chart/utils.mjs

@@ -0,0 +1,220 @@
+import dayjs from 'dayjs';
+import { FIELD_NOT_AVAILABLE_PLACEHOLDER } from '../core';
+export const CHART_LIMIT_MAX_UNIT_VALUE = 800;
+export function dependOnIndicatorSeries(res, indicator) {
+    return indicator?.reduce((acc, pre) => {
+        const values = res?.find(item => item.id === pre.id)?.result[0]?.values || [];
+        return [
+            ...acc,
+            {
+                name: pre.name || pre.id,
+                color: pre.color,
+                values: values.map(item => ({
+                    x: item[0],
+                    y: +item[1],
+                })),
+            },
+        ];
+    }, []);
+}
+export function dependOnDataSeries(res, indicators) {
+    const indicator = indicators[0];
+    return res?.reduce((acc, pre) => {
+        if ([indicator.id, indicator.name].includes(pre.id)) {
+            // eslint-disable-next-line unicorn/better-regex
+            const keys = indicator?.legend?.match(/\{\{\.(.+?)\}\}/) || [
+                null,
+                indicator?.legend,
+            ];
+            return [
+                ...acc,
+                ...pre.result.map(item => ({
+                    name: getMetricName(keys?.[1] || indicator.metricSourceKey, item.metric),
+                    values: item.values.map(d => ({
+                        x: d[0],
+                        y: +d[1],
+                    })),
+                })),
+            ];
+        }
+        return acc;
+    }, []);
+}
+export function getMetricName(metricKey, metric) {
+    if (!metricKey && !Object.keys(metric || {})?.length) {
+        return FIELD_NOT_AVAILABLE_PLACEHOLDER;
+    }
+    if (!metricKey && metric) {
+        return JSON.stringify(metric);
+    }
+    const metricKeys = metricKey?.split(',');
+    if (metricKeys?.length > 1) {
+        const value = metric?.[metricKeys.find(item => metric[item])];
+        return value || metricKey;
+    }
+    return metric[metricKey || '__query_id__'] || metricKey;
+}
+// 填充空数据
+// eslint-disable-next-line sonarjs/cognitive-complexity
+export function fillNullChartData({ start, end, step }, res = [], stepLine = false) {
+    if (!+start || !+end) {
+        return res;
+    }
+    const curStart = +start;
+    const curEnd = start + (end - start);
+    const preX = stepLine
+        ? {
+            preX: dayjs(curStart)
+                .subtract((end - start) / 6, 's')
+                .valueOf(),
+        }
+        : {};
+    const result = [
+        ...(curStart === res[0]?.x ? [] : [{ x: curStart, y: null, ...preX }]),
+        ...res,
+        ...(res.at(-1)?.x === curEnd ? [] : [{ x: curEnd, y: null }]),
+    ];
+    // query 返回数据可能存在某个时间段无数据情况，会导致前端bug
+    // 通过 step 计算出 总数据。
+    // 在出现一开始数据缺失情况，先给数据添加开始时间数据，和结束时间数据。
+    // 在进行遍历，判读当前数据和下一跳数据事件差 是否是这个 step,
+    // 如果不是计算出两者相差 几条数据，然后进行填充
+    const data = result.reduce((acc, prev, index) => {
+        const diff = result[index + 1] && result[index + 1].x * 1000 - prev.x * 1000;
+        const stepM = step * 1000;
+        // 后端可能出现 +Ifn 导致成 NaN，设置为 null
+        const curValue = {
+            ...prev,
+            y: isNaN(prev.y) ? null : prev.y,
+        };
+        if (diff && diff !== stepM) {
+            const total = Math.ceil(diff / stepM - 1);
+            const data = Array.from({ length: total || 0 })
+                .fill(0)
+                .reduce((old, _curr, i) => {
+                const x = i === 0 ? prev.x * 1000 + stepM : old[i - 1].x * 1000 + stepM;
+                return [
+                    ...old,
+                    {
+                        x: x / 1000,
+                        y: null,
+                        ...(stepLine
+                            ? { preX: i === 0 ? result[index].x : old[i - 1].x }
+                            : {}),
+                    },
+                ];
+            }, []);
+            return [...acc, curValue, ...data];
+        }
+        return [...acc, curValue];
+    }, []);
+    return data.sort((a, b) => a.x - b.x);
+}
+export function unitDealWith(data) {
+    return data.some(item => Math.max(...item.result.map(res => Math.max(...res.values.map(d => +d[1])))) >= CHART_LIMIT_MAX_UNIT_VALUE);
+}
+export function checkInterval(time, cacheTime) {
+    if (!time) {
+        return false;
+    }
+    const lastDiff = cacheTime.end - cacheTime.start;
+    const currDiff = time.end - time.start;
+    if (lastDiff === currDiff) {
+        const diffS = currDiff / (currDiff / time.step);
+        return time.end - cacheTime.end >= diffS;
+    }
+    return true;
+}
+export const ChartUnitType = {
+    CPU: 'cpu',
+    MEMORY: 'memory',
+    TIME: 'time',
+    MEASURE: 'measure',
+    Rate: 'rate',
+};
+export const CHART_UNIT_MAP = {
+    [ChartUnitType.CPU]: {
+        medium: {
+            value: 0,
+            unit: 'unit_m',
+        },
+        big: {
+            value: 1000,
+            unit: 'unit_core',
+        },
+    },
+    [ChartUnitType.MEMORY]: {
+        medium: {
+            value: 0,
+            unit: 'unit_Mi',
+        },
+        big: {
+            value: 1024,
+            unit: 'unit_Gi',
+        },
+    },
+    [ChartUnitType.TIME]: {
+        medium: {
+            value: 0,
+            unit: 'ms',
+        },
+        big: {
+            value: 1000,
+            unit: 's',
+        },
+    },
+    [ChartUnitType.MEASURE]: {
+        medium: {
+            value: 0,
+            unit: 'unit_KB',
+        },
+        big: {
+            value: 1024,
+            unit: 'unit_MB',
+        },
+    },
+    [ChartUnitType.Rate]: {
+        medium: {
+            value: 0,
+            unit: 'Bps',
+        },
+        big: {
+            value: 1000,
+            unit: 'Kbps',
+        },
+    },
+};
+export function generateMetricQueryParams({ id, value, }) {
+    return {
+        aggregator: '',
+        id,
+        labels: [
+            { name: '__name__', value: 'custom' },
+            { name: 'expr', value },
+        ],
+    };
+}
+export function generateMetricQuery(expression) {
+    return expression.map(generateMetricQueryParams);
+}
+export function handleChartUnit(metrics, type) {
+    const data = CHART_UNIT_MAP[type];
+    const dealWith = unitDealWith(metrics);
+    if (dealWith) {
+        return {
+            unit: data.big.unit,
+            handleCb: (value) => +(value / data.big.value || 0).toFixed(2),
+            dealWith,
+        };
+    }
+    return {
+        ...data.medium,
+        dealWith,
+    };
+}
+export function hasNoData(res) {
+    return (!res ||
+        res?.length === 0 ||
+        res?.every(item => !item?.values?.length || item.values.every(d => d.y === null)));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../libs/common/src/metric-chart/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import dayjs from 'dayjs';\n\nimport { FIELD_NOT_AVAILABLE_PLACEHOLDER, StringMap } from '../core';\nimport { ChartData, ChartDataItem } from '../view-chart/public-api';\n\nimport {\n  ExpressionItem,\n  Indicator,\n  MetricApiParams,\n  MetricQueryItem,\n  MetricResult,\n} from './types';\n\nexport const CHART_LIMIT_MAX_UNIT_VALUE = 800;\n\nexport function dependOnIndicatorSeries(\n  res: MetricResult[],\n  indicator: Indicator[],\n): ChartData[] {\n  return indicator?.reduce((acc, pre) => {\n    const values =\n      res?.find(item => item.id === pre.id)?.result[0]?.values || [];\n    return [\n      ...acc,\n      {\n        name: pre.name || pre.id,\n        color: pre.color,\n        values: values.map(item => ({\n          x: item[0],\n          y: +item[1],\n        })),\n      },\n    ];\n  }, []);\n}\n\nexport function dependOnDataSeries(\n  res: MetricResult[],\n  indicators: Indicator[],\n): ChartData[] {\n  const indicator = indicators[0];\n  return res?.reduce((acc, pre) => {\n    if ([indicator.id, indicator.name].includes(pre.id)) {\n      // eslint-disable-next-line unicorn/better-regex\n      const keys = indicator?.legend?.match(/\\{\\{\\.(.+?)\\}\\}/) || [\n        null,\n        indicator?.legend,\n      ];\n      return [\n        ...acc,\n        ...pre.result.map(item => ({\n          name: getMetricName(\n            keys?.[1] || indicator.metricSourceKey,\n            item.metric,\n          ),\n          values: item.values.map(d => ({\n            x: d[0],\n            y: +d[1],\n          })),\n        })),\n      ];\n    }\n    return acc;\n  }, []);\n}\n\nexport function getMetricName(metricKey: string, metric: StringMap) {\n  if (!metricKey && !Object.keys(metric || {})?.length) {\n    return FIELD_NOT_AVAILABLE_PLACEHOLDER;\n  }\n  if (!metricKey && metric) {\n    return JSON.stringify(metric);\n  }\n  const metricKeys = metricKey?.split(',');\n  if (metricKeys?.length > 1) {\n    const value = metric?.[metricKeys.find(item => metric[item])];\n    return value || metricKey;\n  }\n  return metric[metricKey || '__query_id__'] || metricKey;\n}\n\n// 填充空数据\n// eslint-disable-next-line sonarjs/cognitive-complexity\nexport function fillNullChartData(\n  { start, end, step }: MetricApiParams,\n  res: Array<ChartDataItem<{ x: number; y: number }>> = [],\n  stepLine = false,\n) {\n  if (!+start || !+end) {\n    return res;\n  }\n\n  const curStart = +start;\n  const curEnd = start + (end - start);\n  const preX = stepLine\n    ? {\n        preX: dayjs(curStart)\n          .subtract((end - start) / 6, 's')\n          .valueOf(),\n      }\n    : {};\n  const result = [\n    ...(curStart === res[0]?.x ? [] : [{ x: curStart, y: null, ...preX }]),\n    ...res,\n    ...(res.at(-1)?.x === curEnd ? [] : [{ x: curEnd, y: null }]),\n  ];\n\n  // query 返回数据可能存在某个时间段无数据情况，会导致前端bug\n  // 通过 step 计算出 总数据。\n  // 在出现一开始数据缺失情况，先给数据添加开始时间数据，和结束时间数据。\n  // 在进行遍历，判读当前数据和下一跳数据事件差 是否是这个 step,\n  // 如果不是计算出两者相差 几条数据，然后进行填充\n  const data = result.reduce((acc, prev, index) => {\n    const diff =\n      result[index + 1] && result[index + 1].x * 1000 - prev.x * 1000;\n    const stepM = step * 1000;\n    // 后端可能出现 +Ifn 导致成 NaN，设置为 null\n    const curValue = {\n      ...prev,\n      y: isNaN(prev.y) ? null : prev.y,\n    };\n    if (diff && diff !== stepM) {\n      const total = Math.ceil(diff / stepM - 1);\n      const data = Array.from<number>({ length: total || 0 })\n        .fill(0)\n        .reduce((old, _curr, i) => {\n          const x =\n            i === 0 ? prev.x * 1000 + stepM : old[i - 1].x * 1000 + stepM;\n          return [\n            ...old,\n            {\n              x: x / 1000,\n              y: null,\n              ...(stepLine\n                ? { preX: i === 0 ? result[index].x : old[i - 1].x }\n                : {}),\n            },\n          ];\n        }, []);\n      return [...acc, curValue, ...data];\n    }\n    return [...acc, curValue];\n  }, []);\n  return data.sort((a, b) => a.x - b.x);\n}\n\nexport function unitDealWith(data: MetricResult[]) {\n  return data.some(\n    item =>\n      Math.max(\n        ...item.result.map(res => Math.max(...res.values.map(d => +d[1]))),\n      ) >= CHART_LIMIT_MAX_UNIT_VALUE,\n  );\n}\n\nexport function checkInterval(\n  time: MetricApiParams,\n  cacheTime: MetricApiParams,\n) {\n  if (!time) {\n    return false;\n  }\n  const lastDiff = cacheTime.end - cacheTime.start;\n  const currDiff = time.end - time.start;\n  if (lastDiff === currDiff) {\n    const diffS = currDiff / (currDiff / time.step);\n    return time.end - cacheTime.end >= diffS;\n  }\n  return true;\n}\n\nexport const ChartUnitType = {\n  CPU: 'cpu',\n  MEMORY: 'memory',\n  TIME: 'time',\n  MEASURE: 'measure',\n  Rate: 'rate',\n} as const;\nexport type ChartUnitType = (typeof ChartUnitType)[keyof typeof ChartUnitType];\nexport const CHART_UNIT_MAP = {\n  [ChartUnitType.CPU]: {\n    medium: {\n      value: 0,\n      unit: 'unit_m',\n    },\n    big: {\n      value: 1000,\n      unit: 'unit_core',\n    },\n  },\n  [ChartUnitType.MEMORY]: {\n    medium: {\n      value: 0,\n      unit: 'unit_Mi',\n    },\n    big: {\n      value: 1024,\n      unit: 'unit_Gi',\n    },\n  },\n  [ChartUnitType.TIME]: {\n    medium: {\n      value: 0,\n      unit: 'ms',\n    },\n    big: {\n      value: 1000,\n      unit: 's',\n    },\n  },\n  [ChartUnitType.MEASURE]: {\n    medium: {\n      value: 0,\n      unit: 'unit_KB',\n    },\n    big: {\n      value: 1024,\n      unit: 'unit_MB',\n    },\n  },\n  [ChartUnitType.Rate]: {\n    medium: {\n      value: 0,\n      unit: 'Bps',\n    },\n    big: {\n      value: 1000,\n      unit: 'Kbps',\n    },\n  },\n};\n\nexport function generateMetricQueryParams({\n  id,\n  value,\n}: ExpressionItem): MetricQueryItem {\n  return {\n    aggregator: '',\n    id,\n    labels: [\n      { name: '__name__', value: 'custom' },\n      { name: 'expr', value },\n    ],\n  };\n}\n\nexport function generateMetricQuery(expression: ExpressionItem[]) {\n  return expression.map(generateMetricQueryParams);\n}\n\nexport function handleChartUnit(metrics: MetricResult[], type: ChartUnitType) {\n  const data = CHART_UNIT_MAP[type];\n  const dealWith = unitDealWith(metrics);\n  if (dealWith) {\n    return {\n      unit: data.big.unit,\n      handleCb: (value: number) => +(value / data.big.value || 0).toFixed(2),\n      dealWith,\n    };\n  }\n  return {\n    ...data.medium,\n    dealWith,\n  };\n}\n\nexport function hasNoData(res: ChartData[]) {\n  return (\n    !res ||\n    res?.length === 0 ||\n    res?.every(\n      item => !item?.values?.length || item.values.every(d => d.y === null),\n    )\n  );\n}\n"]}