@alauda-fe/common 1.0.0-hotfix-znx-3.16.1-1

package/esm2022/metric-chart/common-chart.service.mjs

@@ -0,0 +1,77 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs';
+import { API_GATEWAY, NOT_NOTIFY_ON_ERROR_HEADERS } from '../core/public-api';
+import { MATCH_UNIT_DEFAULT_BASE, adaptUnit } from './helpers';
+import { dependOnDataSeries, dependOnIndicatorSeries } from './utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+const GLOBAL = 'global';
+export class CommonChartService {
+    constructor(http) {
+        this.http = http;
+        this.handelChartData = (res, indicator, dependOnData) => dependOnData
+            ? dependOnDataSeries(res, indicator) // 一个indicator 对应 单条series
+            : dependOnIndicatorSeries(res, indicator); // 一个indicator 对应 多条series
+    }
+    requestChartData({ cluster = GLOBAL, ...rest }, indicator) {
+        return this.http.post(`${API_GATEWAY}/v2/metrics/${cluster}/query_range`, {
+            ...rest,
+            queries: indicator,
+        }, {
+            headers: NOT_NOTIFY_ON_ERROR_HEADERS,
+        });
+    }
+    getPrometheusStatus(cluster = '.*') {
+        return this.http
+            .post(`${API_GATEWAY}/v2/metrics/${GLOBAL}/query`, {
+            time: Math.floor(Date.now() / 1000),
+            queries: [
+                {
+                    id: 'notDeployed',
+                    indicator: 'platform.cluster.prometheus.not.deployed',
+                },
+                {
+                    id: 'abnormal',
+                    indicator: 'platform.cluster.prometheus.down',
+                },
+            ].map(item => ({
+                ...item,
+                variables: {
+                    cluster,
+                },
+            })),
+        }, {
+            headers: NOT_NOTIFY_ON_ERROR_HEADERS,
+        })
+            .pipe(map(res => res.reduce((acc, pre) => {
+            const notDeployed = res.find(d => d.id === 'notDeployed').result.length > 0;
+            return {
+                ...acc,
+                notDeployed,
+                ...(pre.id === 'abnormal' && !notDeployed
+                    ? { abnormal: pre.result.length > 0 }
+                    : {}),
+            };
+        }, {
+            notDeployed: false,
+            abnormal: false,
+        })));
+    }
+    adaptChartUnit(data, adaptUnitParams) {
+        let base = MATCH_UNIT_DEFAULT_BASE;
+        if (typeof adaptUnitParams === 'object' && adaptUnitParams?.base) {
+            base = adaptUnitParams.base;
+        }
+        const { unit, exponent, base: _base, } = adaptUnit(data, (adaptUnitParams === true
+            ? undefined
+            : adaptUnitParams));
+        return { base: _base || base, exponent, unit };
+    }
+    static { this.ɵfac = function CommonChartService_Factory(t) { return new (t || CommonChartService)(i0.ɵɵinject(i1.HttpClient)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: CommonChartService, factory: CommonChartService.ɵfac }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CommonChartService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.HttpClient }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/metric-chart/helpers.mjs

@@ -0,0 +1,111 @@
+import dayjs from 'dayjs';
+import { last, max } from 'lodash-es';
+import { DATE_FORMAT } from '../core/constants/public-api';
+import { UNITS } from '../core/utils/public-api';
+export const BASE_UNITS = ['K', 'M', 'G', 'T', 'P', 'E'];
+export const MEMORY_UNITS = BASE_UNITS.map(unit => unit + 'i');
+export var UnitType;
+(function (UnitType) {
+    UnitType["MEMORY"] = "memory";
+    UnitType["CAPACITY"] = "capacity";
+})(UnitType || (UnitType = {}));
+export const MATCH_UNIT_DEFAULT_BASE = 1024;
+export const UnitMap = {
+    [UnitType.MEMORY]: MEMORY_UNITS,
+    [UnitType.CAPACITY]: UNITS,
+};
+const _matchUnit = (value, { base = MATCH_UNIT_DEFAULT_BASE, threshold = 800, unitType = UnitType.CAPACITY, groups, unitRange, baseUnit, } = {}) => {
+    const units = unitRange || UnitMap[unitType];
+    if (!value) {
+        return { unit: baseUnit || units[0], units };
+    }
+    const cloneUnits = units.map(item => item);
+    const index = units.indexOf(baseUnit || units[0]);
+    const isPositive = value > threshold;
+    const unitsList = isPositive
+        ? cloneUnits.splice(index)
+        : cloneUnits.splice(0, index + 1).reverse();
+    let unitBase = 1;
+    for (const unit of unitsList) {
+        const _base = groups?.find(g => g.range?.slice(0, -1)?.includes(unit))?.base || base;
+        if (value <= threshold) {
+            return { unit, base: unitBase, units: unitsList };
+        }
+        isPositive ? (unitBase *= _base) : (unitBase /= _base);
+        isPositive ? (value /= _base) : (value *= _base);
+    }
+    return { unit: last(unitsList), base: unitBase, units: unitsList };
+};
+export const matchUnit = (value, params) => {
+    const { unit, units, base } = _matchUnit(value, params);
+    return {
+        unit,
+        base,
+        exponent: units.indexOf(unit),
+    };
+};
+export const adaptUnit = (seriesOrMetrics, params) => matchUnit(max(seriesOrMetrics.flatMap(({ data, values = data }) => values.map(d => d.y))), params);
+export function getTimeValueOf(value) {
+    return dayjs(value).valueOf() / 1000;
+}
+export const CHART_DATA_FORMAT = `${DATE_FORMAT} HH:mm`;
+export const getTimeRanges = (value, unit) => ({
+    start: () => dateTimeRounding(dayjs().subtract(value, unit)),
+    end: () => dayjs().format(CHART_DATA_FORMAT),
+    startTime: () => getTimeValueOf(dateTimeRounding(dayjs().subtract(value, unit))),
+    endTime: () => getTimeValueOf(dayjs().format(CHART_DATA_FORMAT)),
+});
+export function dateTimeRounding(value) {
+    return dayjs(value).format(CHART_DATA_FORMAT);
+}
+export const PICKER_TIME_RANGES = [
+    {
+        name: 'nearly_30_minute',
+        ...getTimeRanges(30, 'm'),
+        step: 30,
+        zoomStep: 30,
+    },
+    {
+        name: 'nearly_1_hour',
+        ...getTimeRanges(1, 'hour'),
+        step: 60,
+        zoomStep: 30,
+    },
+    {
+        name: 'nearly_3_hour',
+        ...getTimeRanges(3, 'hour'),
+        step: ((3 * 60) / 60) * 60,
+        zoomStep: ((3 * 60) / 360) * 60,
+    },
+    {
+        name: 'nearly_6_hour',
+        ...getTimeRanges(6, 'hour'),
+        step: ((6 * 60) / 120) * 60,
+        zoomStep: ((6 * 60) / 720) * 60,
+    },
+    {
+        name: 'nearly_12_hour',
+        ...getTimeRanges(12, 'hour'),
+        step: ((12 * 60) / 120) * 60,
+        zoomStep: ((12 * 60) / 720) * 60,
+    },
+    {
+        name: 'nearly_1_day',
+        ...getTimeRanges(1, 'day'),
+        step: ((24 * 60) / 120) * 60,
+        zoomStep: ((24 * 60) / 720) * 60,
+    },
+    {
+        name: 'nearly_3_day',
+        ...getTimeRanges(3, 'day'),
+        step: ((3 * 24 * 60) / 120) * 60,
+        zoomStep: ((3 * 24 * 60) / 720) * 60,
+    },
+    {
+        name: 'nearly_7_day',
+        ...getTimeRanges(7, 'day'),
+        step: ((7 * 24 * 60) / 120) * 60,
+        zoomStep: ((7 * 24 * 60) / 720) * 60,
+    },
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../../../../libs/common/src/metric-chart/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAgC,MAAM,OAAO,CAAC;AACrD,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAEtC,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAC3D,OAAO,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAIjD,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAU,CAAC;AAClE,MAAM,CAAC,MAAM,YAAY,GAAG,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,GAAG,GAAG,CAAC,CAAC;AAE/D,MAAM,CAAN,IAAY,QAGX;AAHD,WAAY,QAAQ;IAClB,6BAAiB,CAAA;IACjB,iCAAqB,CAAA;AACvB,CAAC,EAHW,QAAQ,KAAR,QAAQ,QAGnB;AAaD,MAAM,CAAC,MAAM,uBAAuB,GAAG,IAAI,CAAC;AAE5C,MAAM,CAAC,MAAM,OAAO,GAAyC;IAC3D,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY;IAC/B,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,KAAK;CAC3B,CAAC;AAEF,MAAM,UAAU,GAAG,CACjB,KAAa,EACb,EACE,IAAI,GAAG,uBAAuB,EAC9B,SAAS,GAAG,GAAG,EACf,QAAQ,GAAG,QAAQ,CAAC,QAAQ,EAC5B,MAAM,EACN,SAAS,EACT,QAAQ,MACW,EAAE,EACvB,EAAE;IACF,MAAM,KAAK,GAAG,SAAS,IAAI,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC7C,IAAI,CAAC,KAAK,EAAE;QACV,OAAO,EAAE,IAAI,EAAE,QAAQ,IAAI,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC;KAC9C;IACD,MAAM,UAAU,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;IAC3C,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,QAAQ,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAClD,MAAM,UAAU,GAAG,KAAK,GAAG,SAAS,CAAC;IACrC,MAAM,SAAS,GAAG,UAAU;QAC1B,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,KAAK,CAAC;QAC1B,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;IAC9C,IAAI,QAAQ,GAAG,CAAC,CAAC;IACjB,KAAK,MAAM,IAAI,IAAI,SAAS,EAAE;QAC5B,MAAM,KAAK,GACT,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,IAAI,IAAI,CAAC;QACzE,IAAI,KAAK,IAAI,SAAS,EAAE;YACtB,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;SACnD;QACD,UAAU,CAAC,CAAC,CAAC,CAAC,QAAQ,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,IAAI,KAAK,CAAC,CAAC;QACvD,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,KAAK,CAAC,CAAC;KAClD;IACD,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;AACrE,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,KAAa,EAAE,MAAwB,EAAE,EAAE;IACnE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACxD,OAAO;QACL,IAAI;QACJ,IAAI;QACJ,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;KAC9B,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,SAAS,GAAG,CACvB,eAGE,EACF,MAAwB,EACxB,EAAE,CACF,SAAS,CACP,GAAG,CACD,eAAe,CAAC,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,EAAE,EAAE,EAAE,CAClD,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CACrB,CACF,EACD,MAAM,CACP,CAAC;AAEJ,MAAM,UAAU,cAAc,CAAC,KAAa;IAC1C,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC;AACvC,CAAC;AAED,MAAM,CAAC,MAAM,iBAAiB,GAAG,GAAG,WAAW,QAAQ,CAAC;AAExD,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,KAAa,EAAE,IAAoB,EAAE,EAAE,CAAC,CAAC;IACrE,KAAK,EAAE,GAAG,EAAE,CAAC,gBAAgB,CAAC,KAAK,EAAE,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAC5D,GAAG,EAAE,GAAG,EAAE,CAAC,KAAK,EAAE,CAAC,MAAM,CAAC,iBAAiB,CAAC;IAC5C,SAAS,EAAE,GAAG,EAAE,CACd,cAAc,CAAC,gBAAgB,CAAC,KAAK,EAAE,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;IACjE,OAAO,EAAE,GAAG,EAAE,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC;CACjE,CAAC,CAAC;AAEH,MAAM,UAAU,gBAAgB,CAAC,KAAqB;IACpD,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC;AAChD,CAAC;AAED,MAAM,CAAC,MAAM,kBAAkB,GAAuB;IACpD;QACE,IAAI,EAAE,kBAAkB;QACxB,GAAG,aAAa,CAAC,EAAE,EAAE,GAAG,CAAC;QACzB,IAAI,EAAE,EAAE;QACR,QAAQ,EAAE,EAAE;KACb;IACD;QACE,IAAI,EAAE,eAAe;QACrB,GAAG,aAAa,CAAC,CAAC,EAAE,MAAM,CAAC;QAC3B,IAAI,EAAE,EAAE;QACR,QAAQ,EAAE,EAAE;KACb;IACD;QACE,IAAI,EAAE,eAAe;QACrB,GAAG,aAAa,CAAC,CAAC,EAAE,MAAM,CAAC;QAC3B,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE;QAC1B,QAAQ,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,GAAG,CAAC,GAAG,EAAE;KAChC;IACD;QACE,IAAI,EAAE,eAAe;QACrB,GAAG,aAAa,CAAC,CAAC,EAAE,MAAM,CAAC;QAC3B,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,GAAG,CAAC,GAAG,EAAE;QAC3B,QAAQ,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,GAAG,CAAC,GAAG,EAAE;KAChC;IACD;QACE,IAAI,EAAE,gBAAgB;QACtB,GAAG,aAAa,CAAC,EAAE,EAAE,MAAM,CAAC;QAC5B,IAAI,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,GAAG,CAAC,GAAG,EAAE;QAC5B,QAAQ,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,GAAG,CAAC,GAAG,EAAE;KACjC;IACD;QACE,IAAI,EAAE,cAAc;QACpB,GAAG,aAAa,CAAC,CAAC,EAAE,KAAK,CAAC;QAC1B,IAAI,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,GAAG,CAAC,GAAG,EAAE;QAC5B,QAAQ,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,GAAG,CAAC,GAAG,EAAE;KACjC;IACD;QACE,IAAI,EAAE,cAAc;QACpB,GAAG,aAAa,CAAC,CAAC,EAAE,KAAK,CAAC;QAC1B,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,GAAG,GAAG,CAAC,GAAG,EAAE;QAChC,QAAQ,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,GAAG,GAAG,CAAC,GAAG,EAAE;KACrC;IACD;QACE,IAAI,EAAE,cAAc;QACpB,GAAG,aAAa,CAAC,CAAC,EAAE,KAAK,CAAC;QAC1B,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,GAAG,GAAG,CAAC,GAAG,EAAE;QAChC,QAAQ,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,GAAG,GAAG,CAAC,GAAG,EAAE;KACrC;CACF,CAAC","sourcesContent":["import dayjs, { Dayjs, ManipulateType } from 'dayjs';\nimport { last, max } from 'lodash-es';\n\nimport { DATE_FORMAT } from '../core/constants/public-api';\nimport { UNITS } from '../core/utils/public-api';\n\nimport { PickerTimeRanges } from './types';\n\nexport const BASE_UNITS = ['K', 'M', 'G', 'T', 'P', 'E'] as const;\nexport const MEMORY_UNITS = BASE_UNITS.map(unit => unit + 'i');\n\nexport enum UnitType {\n  MEMORY = 'memory',\n  CAPACITY = 'capacity',\n}\n\nexport interface MatchUnitParams {\n  base?: number;\n  threshold?: number;\n  unitType?: UnitType;\n  unitRange?: string[];\n  defaultPrefix?: boolean;\n  prefix?: string;\n  baseUnit?: string;\n  groups?: Array<{ base: number; range: string[] }>;\n}\n\nexport const MATCH_UNIT_DEFAULT_BASE = 1024;\n\nexport const UnitMap: { [key: string]: readonly string[] } = {\n  [UnitType.MEMORY]: MEMORY_UNITS,\n  [UnitType.CAPACITY]: UNITS,\n};\n\nconst _matchUnit = (\n  value: number,\n  {\n    base = MATCH_UNIT_DEFAULT_BASE,\n    threshold = 800,\n    unitType = UnitType.CAPACITY,\n    groups,\n    unitRange,\n    baseUnit,\n  }: MatchUnitParams = {},\n) => {\n  const units = unitRange || UnitMap[unitType];\n  if (!value) {\n    return { unit: baseUnit || units[0], units };\n  }\n  const cloneUnits = units.map(item => item);\n  const index = units.indexOf(baseUnit || units[0]);\n  const isPositive = value > threshold;\n  const unitsList = isPositive\n    ? cloneUnits.splice(index)\n    : cloneUnits.splice(0, index + 1).reverse();\n  let unitBase = 1;\n  for (const unit of unitsList) {\n    const _base: number =\n      groups?.find(g => g.range?.slice(0, -1)?.includes(unit))?.base || base;\n    if (value <= threshold) {\n      return { unit, base: unitBase, units: unitsList };\n    }\n    isPositive ? (unitBase *= _base) : (unitBase /= _base);\n    isPositive ? (value /= _base) : (value *= _base);\n  }\n  return { unit: last(unitsList), base: unitBase, units: unitsList };\n};\n\nexport const matchUnit = (value: number, params?: MatchUnitParams) => {\n  const { unit, units, base } = _matchUnit(value, params);\n  return {\n    unit,\n    base,\n    exponent: units.indexOf(unit),\n  };\n};\n\nexport const adaptUnit = (\n  seriesOrMetrics: Array<{\n    data?: Array<{ x: number; y: number }>;\n    values?: Array<{ x: number; y: number }>;\n  }>,\n  params?: MatchUnitParams,\n) =>\n  matchUnit(\n    max<number>(\n      seriesOrMetrics.flatMap(({ data, values = data }) =>\n        values.map(d => d.y),\n      ),\n    ),\n    params,\n  );\n\nexport function getTimeValueOf(value: string) {\n  return dayjs(value).valueOf() / 1000;\n}\n\nexport const CHART_DATA_FORMAT = `${DATE_FORMAT} HH:mm`;\n\nexport const getTimeRanges = (value: number, unit: ManipulateType) => ({\n  start: () => dateTimeRounding(dayjs().subtract(value, unit)),\n  end: () => dayjs().format(CHART_DATA_FORMAT),\n  startTime: () =>\n    getTimeValueOf(dateTimeRounding(dayjs().subtract(value, unit))),\n  endTime: () => getTimeValueOf(dayjs().format(CHART_DATA_FORMAT)),\n});\n\nexport function dateTimeRounding(value: number | Dayjs) {\n  return dayjs(value).format(CHART_DATA_FORMAT);\n}\n\nexport const PICKER_TIME_RANGES: PickerTimeRanges[] = [\n  {\n    name: 'nearly_30_minute',\n    ...getTimeRanges(30, 'm'),\n    step: 30,\n    zoomStep: 30,\n  },\n  {\n    name: 'nearly_1_hour',\n    ...getTimeRanges(1, 'hour'),\n    step: 60,\n    zoomStep: 30,\n  },\n  {\n    name: 'nearly_3_hour',\n    ...getTimeRanges(3, 'hour'),\n    step: ((3 * 60) / 60) * 60,\n    zoomStep: ((3 * 60) / 360) * 60,\n  },\n  {\n    name: 'nearly_6_hour',\n    ...getTimeRanges(6, 'hour'),\n    step: ((6 * 60) / 120) * 60,\n    zoomStep: ((6 * 60) / 720) * 60,\n  },\n  {\n    name: 'nearly_12_hour',\n    ...getTimeRanges(12, 'hour'),\n    step: ((12 * 60) / 120) * 60,\n    zoomStep: ((12 * 60) / 720) * 60,\n  },\n  {\n    name: 'nearly_1_day',\n    ...getTimeRanges(1, 'day'),\n    step: ((24 * 60) / 120) * 60,\n    zoomStep: ((24 * 60) / 720) * 60,\n  },\n  {\n    name: 'nearly_3_day',\n    ...getTimeRanges(3, 'day'),\n    step: ((3 * 24 * 60) / 120) * 60,\n    zoomStep: ((3 * 24 * 60) / 720) * 60,\n  },\n  {\n    name: 'nearly_7_day',\n    ...getTimeRanges(7, 'day'),\n    step: ((7 * 24 * 60) / 120) * 60,\n    zoomStep: ((7 * 24 * 60) / 720) * 60,\n  },\n];\n"]}

package/esm2022/metric-chart/metric-chart.component.mjs

@@ -0,0 +1,346 @@
+import { __decorate, __metadata } from "tslib";
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, HostBinding, Input, Output, TemplateRef, } from '@angular/core';
+import { Observable, Subject, combineLatest, merge, of, pipe, BehaviorSubject, catchError, filter, map, switchMap, tap, withLatestFrom, } from 'rxjs';
+import { DATE_TIME_FORMAT_X_AXIS, } from '../chart/public-api';
+import { ObservableInput, publishRef } from '../core/public-api';
+import { CommonChartService } from './common-chart.service';
+import { PICKER_TIME_RANGES } from './helpers';
+import { checkInterval, fillNullChartData, hasNoData } from './utils';
+import * as i0 from "@angular/core";
+import * as i1 from "./common-chart.service";
+export class MetricChartComponent {
+    get overflow() {
+        return !this.tooltipAppendToBody && 'unset';
+    }
+    get xAccessor() {
+        return (d) => d.x * 1000;
+    }
+    constructor(service, cdr) {
+        this.service = service;
+        this.cdr = cdr;
+        this.chartType = 'area';
+        this.tooltipAppendToBody = true;
+        this.gridOffsetTop = 0;
+        this.barType = 'standard';
+        this.legendSelectAllOperation = false;
+        this.hideLegend = false;
+        this.mode = 'default';
+        this.tooltipTranslation = true;
+        this.yPlotLinesHide = false;
+        this.mouseUpEvent = new EventEmitter();
+        this.markClickEvent = new EventEmitter();
+        this.refreshEvent = new EventEmitter();
+        this.dataCompleted = new EventEmitter();
+        this.reload$ = new BehaviorSubject(null);
+        this._chartStatus$$ = new Subject();
+        this._status = {};
+        this.status$ = merge(this.chartStatus$, this._chartStatus$$).pipe(map(status => ({
+            ...this._status,
+            ...status,
+        })), tap(status => (this._status = status)), publishRef());
+        this.dateAxisLabelFormats = DATE_TIME_FORMAT_X_AXIS;
+        this.dateXAxisLabelFormats = '%H:%M';
+        this.yAccessor$ = this.percent$.pipe(tap(percent => {
+            if (percent) {
+                this.unit = '%';
+            }
+        }), map(percent => (d) => {
+            // prometheus 可能出现 Infinity情况，处理为 null
+            if (!Number.isFinite(d.y) || String(d.y) === '+Inf') {
+                return null;
+            }
+            return percent && d.y ? +d.y * 100 : d.y === null ? d.y : +d.y;
+        }));
+        this._cacheTime = {
+            start: PICKER_TIME_RANGES[1].startTime(),
+            end: PICKER_TIME_RANGES[1].endTime(),
+            step: PICKER_TIME_RANGES[1].step,
+        };
+        this.defaultSeries$ = combineLatest([
+            this.metricApiParams$,
+            this.indicator$,
+            this.reload$,
+        ]).pipe(tap(([, indicator]) => {
+            this.handleTimeParams();
+            this.handleDateAxisLabelFormats(this.chartParams);
+            this.handelChartStatus({
+                loading: !!indicator?.length,
+                failed: false,
+                noData: !indicator?.length,
+            });
+        }), switchMap(([_, indicator]) => indicator?.length && this.chartParams
+            ? this.service.requestChartData(this.chartParams, indicator).pipe(catchError(() => {
+                this.handelChartStatus({ loading: false, failed: true });
+                return of(null);
+            }))
+            : of(null)));
+    }
+    ngOnInit() {
+        if (this.metricApiParams) {
+            this._cacheTime = this.metricApiParams;
+        }
+        this.series$ = (this.isCustomSeries ? this.customSeries$ : this.defaultSeries$).pipe(this.handleMetricDataPipe());
+    }
+    handleTimeParams() {
+        let timeParams = this.metricApiParams;
+        if (timeParams) {
+            if (checkInterval(this.metricApiParams, this._cacheTime)) {
+                this._cacheTime = this.metricApiParams;
+            }
+            else {
+                timeParams = this._cacheTime;
+            }
+            this.chartParams = {
+                ...this.metricApiParams,
+                ...timeParams,
+            };
+        }
+    }
+    handleMetricDataPipe() {
+        return pipe(tap(() => {
+            if (this.isCustomSeries) {
+                this.handleTimeParams();
+            }
+        }), filter((res) => !!this.chartParams && (!!res || !this.indicator?.length)), map((res) => {
+            const format = this.dataFormat || this.service.handelChartData;
+            // `fillNullChartData` prometheus 存在某个时间点未采集到数据的情况，这里为区分 未采集到数据为0的情况，这里前端根据时间段自动填充数据
+            // 后端 需要和 Prometheus API 保持兼容，还是在前端做处理填充
+            return format(res, this.indicator || [], this.dependOnData)?.map(item => ({
+                ...item,
+                unit: this.unit,
+                values: fillNullChartData(this.chartParams, item.values, this.stepLine),
+            }));
+        }), tap(res => {
+            this.handleDateAxisLabelFormats(this.chartParams);
+            this.handelChartStatus({
+                loading: false,
+                noData: hasNoData(res),
+            });
+            this.cdr.markForCheck();
+        }), map(res => res?.length
+            ? res
+            : [
+                {
+                    values: fillNullChartData(this.chartParams, [], this.stepLine),
+                },
+            ]), withLatestFrom(this.adaptUnit$), map(([res, _adaptUnit]) => {
+            if (_adaptUnit && !this.noData) {
+                const { base, unit } = this.service.adaptChartUnit(res, _adaptUnit);
+                this.unit = `unit_${unit}`;
+                if (typeof _adaptUnit === 'object') {
+                    const { defaultPrefix = true, prefix } = _adaptUnit;
+                    this.unit = defaultPrefix
+                        ? `unit_${unit}`
+                        : `${prefix || ''}${unit}`;
+                }
+                return res.map((item) => ({
+                    ...item,
+                    unit: this.unit,
+                    values: item.values.map(d => ({
+                        ...d,
+                        y: d.y ? d.y / base : d.y,
+                    })),
+                }));
+            }
+            return res.map(item => ({ ...item, unit: this.unit }));
+        }), tap(() => {
+            this.dataCompleted.next();
+        }), publishRef());
+    }
+    refresh() {
+        this.reload$.next(null);
+        this.refreshEvent.next(null);
+    }
+    handelChartStatus(status) {
+        this._chartStatus$$.next({
+            ...status,
+        });
+    }
+    handleDateAxisLabelFormats(params) {
+        if (params) {
+            const diff = params.end - params.start;
+            const m1 = 24 * 60 * 60;
+            const m3 = 3 * m1;
+            const m7 = 7 * m1;
+            const M_D_FORMAT = 'MM-DD';
+            const format = diff >= m7
+                ? M_D_FORMAT
+                : diff < m7 && (diff >= m3 || diff > m1)
+                    ? `${M_D_FORMAT} ${DATE_TIME_FORMAT_X_AXIS}`
+                    : DATE_TIME_FORMAT_X_AXIS;
+            this.dateAxisLabelFormats = format;
+            // https://d3js.org.cn/document/d3-time-format/#api-reference
+            this.dateXAxisLabelFormats =
+                diff >= m7
+                    ? '%m-%d'
+                    : diff < m7 && (diff >= m3 || diff > m1)
+                        ? `%m-%d %H:%M`
+                        : '%H:%M';
+            this.cdr.detectChanges();
+        }
+    }
+    static { this.ɵfac = function MetricChartComponent_Factory(t) { return new (t || MetricChartComponent)(i0.ɵɵdirectiveInject(i1.CommonChartService), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: MetricChartComponent, selectors: [["acl-metric-chart"]], hostVars: 2, hostBindings: function MetricChartComponent_HostBindings(rf, ctx) { if (rf & 2) {
+            i0.ɵɵstyleProp("overflow", ctx.overflow);
+        } }, inputs: { contextCallbackFunction: "contextCallbackFunction", backgroundColor: "backgroundColor", hideHeader: "hideHeader", title: "title", hideTitle: "hideTitle", chartType: "chartType", titleDescription: "titleDescription", titleDescriptionContext: "titleDescriptionContext", unit: "unit", tooltipAppendToBody: "tooltipAppendToBody", indicator: "indicator", gridOffsetTop: "gridOffsetTop", yAxisMinStep: "yAxisMinStep", rotated: "rotated", barType: "barType", metricApiParams: "metricApiParams", tooltipPointNameTemplate: "tooltipPointNameTemplate", tooltipPointTemplate: "tooltipPointTemplate", legendTemplate: "legendTemplate", legendSelectAllOperation: "legendSelectAllOperation", legendSelectAllName: "legendSelectAllName", tooltipHide: "tooltipHide", tooltipPointFormat: "tooltipPointFormat", tooltipPointTemplateContext: "tooltipPointTemplateContext", tooltipColumnLayout: "tooltipColumnLayout", hideLegend: "hideLegend", tooltipAutoSort: "tooltipAutoSort", tooltipSortMethod: "tooltipSortMethod", hideTooltipUnit: "hideTooltipUnit", leftOperation: "leftOperation", leftOperationContext: "leftOperationContext", rightOperation: "rightOperation", mode: "mode", adaptUnit: "adaptUnit", percent: "percent", dependOnData: "dependOnData", customNoDataTitle: "customNoDataTitle", dataFormat: "dataFormat", customSeries: "customSeries", isCustomSeries: "isCustomSeries", chartStatus: "chartStatus", tooltipTranslation: "tooltipTranslation", xPlotLines: "xPlotLines", xPlotEmpty: "xPlotEmpty", yPlotLines: "yPlotLines", yPlotLinesTooltip: "yPlotLinesTooltip", yPlotLinesTooltipContext: "yPlotLinesTooltipContext", yPlotLinesHide: "yPlotLinesHide", enableZoom: "enableZoom", stepLine: "stepLine", tooltipTitleTemplate: "tooltipTitleTemplate", yAccessor: "yAccessor", curveType: "curveType" }, outputs: { mouseUpEvent: "mouseUpEvent", markClickEvent: "markClickEvent", refreshEvent: "refreshEvent", dataCompleted: "dataCompleted" }, decls: 4, vars: 51, consts: [[3, "contextCallbackFunction", "unit", "hideHeader", "customNoDataTitle", "chartStatus", "backgroundColor", "series", "curveType", "tooltipAppendToBody", "mode", "gridOffsetTop", "title", "chartType", "hideTitle", "tooltipHide", "tooltipSortMethod", "titleDescription", "titleDescriptionContext", "hideLegend", "dateAxisLabelFormats", "enableZoom", "stepLine", "rotated", "rightOperation", "leftOperation", "leftOperationContext", "legendTemplate", "legendSelectAllOperation", "legendSelectAllName", "yAccessor", "xAccessor", "yAxisMinStep", "hideTooltipUnit", "tooltipTitleTemplate", "tooltipAutoSort", "tooltipTranslation", "tooltipPointNameTemplate", "tooltipPointTemplate", "tooltipPointTemplateContext", "xPlotLines", "xPlotEmpty", "yPlotLinesHide", "yPlotLines", "mouseUpEvent", "markClickEvent", "refreshEvent"]], template: function MetricChartComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "acl-view-zchart", 0);
+            i0.ɵɵlistener("mouseUpEvent", function MetricChartComponent_Template_acl_view_zchart_mouseUpEvent_0_listener($event) { return ctx.mouseUpEvent.next($event); })("markClickEvent", function MetricChartComponent_Template_acl_view_zchart_markClickEvent_0_listener($event) { return ctx.markClickEvent.next($event); })("refreshEvent", function MetricChartComponent_Template_acl_view_zchart_refreshEvent_0_listener() { return ctx.refresh(); });
+            i0.ɵɵpipe(1, "async");
+            i0.ɵɵpipe(2, "async");
+            i0.ɵɵpipe(3, "async");
+            i0.ɵɵelementEnd();
+        } if (rf & 2) {
+            i0.ɵɵclassProp("overflow-display", !ctx.tooltipAppendToBody);
+            i0.ɵɵproperty("contextCallbackFunction", ctx.contextCallbackFunction)("unit", ctx.unit)("hideHeader", ctx.hideHeader)("customNoDataTitle", ctx.customNoDataTitle)("chartStatus", i0.ɵɵpipeBind1(1, 45, ctx.status$))("backgroundColor", ctx.backgroundColor)("series", i0.ɵɵpipeBind1(2, 47, ctx.series$))("curveType", ctx.curveType)("tooltipAppendToBody", ctx.tooltipAppendToBody)("mode", ctx.mode)("gridOffsetTop", ctx.gridOffsetTop)("title", ctx.title)("chartType", ctx.chartType)("hideTitle", ctx.hideTitle)("tooltipHide", ctx.tooltipHide)("tooltipSortMethod", ctx.tooltipSortMethod)("titleDescription", ctx.titleDescription)("titleDescriptionContext", ctx.titleDescriptionContext)("hideLegend", ctx.dependOnData && ctx.noData || ctx.hideLegend)("dateAxisLabelFormats", ctx.dateAxisLabelFormats)("enableZoom", ctx.enableZoom)("stepLine", ctx.stepLine)("rotated", ctx.rotated)("rightOperation", ctx.rightOperation)("leftOperation", ctx.leftOperation)("leftOperationContext", ctx.leftOperationContext)("legendTemplate", ctx.legendTemplate)("legendSelectAllOperation", ctx.legendSelectAllOperation)("legendSelectAllName", ctx.legendSelectAllName)("yAccessor", ctx.yAccessor || i0.ɵɵpipeBind1(3, 49, ctx.yAccessor$))("xAccessor", ctx.xAccessor)("yAxisMinStep", ctx.yAxisMinStep)("hideTooltipUnit", ctx.hideTooltipUnit)("tooltipTitleTemplate", ctx.tooltipTitleTemplate)("tooltipAutoSort", ctx.tooltipAutoSort)("tooltipTranslation", ctx.tooltipTranslation)("tooltipPointNameTemplate", ctx.tooltipPointNameTemplate)("tooltipPointTemplate", ctx.tooltipPointTemplate)("tooltipPointTemplateContext", ctx.tooltipPointTemplateContext)("xPlotLines", ctx.xPlotLines)("xPlotEmpty", ctx.xPlotEmpty)("yPlotLinesHide", ctx.yPlotLinesHide)("yPlotLines", ctx.yPlotLines);
+        } }, styles: ["[_nghost-%COMP%]{flex:1;display:flex;height:100%;overflow:hidden}[_nghost-%COMP%]   .overflow-display[_ngcontent-%COMP%]{overflow:unset}"], changeDetection: 0 }); }
+}
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], MetricChartComponent.prototype, "unit$", void 0);
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], MetricChartComponent.prototype, "indicator$", void 0);
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], MetricChartComponent.prototype, "metricApiParams$", void 0);
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], MetricChartComponent.prototype, "adaptUnit$", void 0);
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], MetricChartComponent.prototype, "percent$", void 0);
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], MetricChartComponent.prototype, "customSeries$", void 0);
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], MetricChartComponent.prototype, "chartStatus$", void 0);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MetricChartComponent, [{
+        type: Component,
+        args: [{ selector: 'acl-metric-chart', changeDetection: ChangeDetectionStrategy.OnPush, template: "<acl-view-zchart\n  [class.overflow-display]=\"!tooltipAppendToBody\"\n  [contextCallbackFunction]=\"contextCallbackFunction\"\n  [unit]=\"unit\"\n  [hideHeader]=\"hideHeader\"\n  [customNoDataTitle]=\"customNoDataTitle\"\n  [chartStatus]=\"status$ | async\"\n  [backgroundColor]=\"backgroundColor\"\n  [series]=\"series$ | async\"\n  [curveType]=\"curveType\"\n  [tooltipAppendToBody]=\"tooltipAppendToBody\"\n  [mode]=\"mode\"\n  [gridOffsetTop]=\"gridOffsetTop\"\n  [title]=\"title\"\n  [chartType]=\"chartType\"\n  [hideTitle]=\"hideTitle\"\n  [tooltipHide]=\"tooltipHide\"\n  [tooltipSortMethod]=\"tooltipSortMethod\"\n  [titleDescription]=\"titleDescription\"\n  [titleDescriptionContext]=\"titleDescriptionContext\"\n  [hideLegend]=\"(dependOnData && noData) || hideLegend\"\n  [dateAxisLabelFormats]=\"dateAxisLabelFormats\"\n  [enableZoom]=\"enableZoom\"\n  [stepLine]=\"stepLine\"\n  [rotated]=\"rotated\"\n  [rightOperation]=\"rightOperation\"\n  [leftOperation]=\"leftOperation\"\n  [leftOperationContext]=\"leftOperationContext\"\n  [legendTemplate]=\"legendTemplate\"\n  [legendSelectAllOperation]=\"legendSelectAllOperation\"\n  [legendSelectAllName]=\"legendSelectAllName\"\n  [yAccessor]=\"yAccessor || (yAccessor$ | async)\"\n  [xAccessor]=\"xAccessor\"\n  [yAxisMinStep]=\"yAxisMinStep\"\n  [hideTooltipUnit]=\"hideTooltipUnit\"\n  [tooltipTitleTemplate]=\"tooltipTitleTemplate\"\n  [tooltipAutoSort]=\"tooltipAutoSort\"\n  [tooltipTranslation]=\"tooltipTranslation\"\n  [tooltipPointNameTemplate]=\"tooltipPointNameTemplate\"\n  [tooltipPointTemplate]=\"tooltipPointTemplate\"\n  [tooltipPointTemplateContext]=\"tooltipPointTemplateContext\"\n  [xPlotLines]=\"xPlotLines\"\n  [xPlotEmpty]=\"xPlotEmpty\"\n  [yPlotLinesHide]=\"yPlotLinesHide\"\n  [yPlotLines]=\"yPlotLines\"\n  (mouseUpEvent)=\"mouseUpEvent.next($event)\"\n  (markClickEvent)=\"markClickEvent.next($event)\"\n  (refreshEvent)=\"refresh()\"\n>\n</acl-view-zchart>\n<!-- [tooltipPointFormat]=\"tooltipPointFormat\" -->\n", styles: [":host{flex:1;display:flex;height:100%;overflow:hidden}:host .overflow-display{overflow:unset}\n"] }]
+    }], function () { return [{ type: i1.CommonChartService }, { type: i0.ChangeDetectorRef }]; }, { contextCallbackFunction: [{
+            type: Input
+        }], backgroundColor: [{
+            type: Input
+        }], hideHeader: [{
+            type: Input
+        }], title: [{
+            type: Input
+        }], hideTitle: [{
+            type: Input
+        }], chartType: [{
+            type: Input
+        }], titleDescription: [{
+            type: Input
+        }], titleDescriptionContext: [{
+            type: Input
+        }], unit: [{
+            type: Input
+        }], tooltipAppendToBody: [{
+            type: Input
+        }], overflow: [{
+            type: HostBinding,
+            args: ['style.overflow']
+        }], unit$: [], indicator: [{
+            type: Input
+        }], gridOffsetTop: [{
+            type: Input
+        }], yAxisMinStep: [{
+            type: Input
+        }], rotated: [{
+            type: Input
+        }], barType: [{
+            type: Input
+        }], indicator$: [], metricApiParams: [{
+            type: Input
+        }], metricApiParams$: [], tooltipPointNameTemplate: [{
+            type: Input
+        }], tooltipPointTemplate: [{
+            type: Input
+        }], legendTemplate: [{
+            type: Input
+        }], legendSelectAllOperation: [{
+            type: Input
+        }], legendSelectAllName: [{
+            type: Input
+        }], tooltipHide: [{
+            type: Input
+        }], tooltipPointFormat: [{
+            type: Input
+        }], tooltipPointTemplateContext: [{
+            type: Input
+        }], tooltipColumnLayout: [{
+            type: Input
+        }], hideLegend: [{
+            type: Input
+        }], tooltipAutoSort: [{
+            type: Input
+        }], tooltipSortMethod: [{
+            type: Input
+        }], hideTooltipUnit: [{
+            type: Input
+        }], leftOperation: [{
+            type: Input
+        }], leftOperationContext: [{
+            type: Input
+        }], rightOperation: [{
+            type: Input
+        }], mode: [{
+            type: Input
+        }], adaptUnit: [{
+            type: Input
+        }], adaptUnit$: [], percent: [{
+            type: Input
+        }], percent$: [], dependOnData: [{
+            type: Input
+        }], customNoDataTitle: [{
+            type: Input
+        }], dataFormat: [{
+            type: Input
+        }], customSeries: [{
+            type: Input
+        }], customSeries$: [], isCustomSeries: [{
+            type: Input
+        }], chartStatus: [{
+            type: Input
+        }], chartStatus$: [], tooltipTranslation: [{
+            type: Input
+        }], xPlotLines: [{
+            type: Input
+        }], xPlotEmpty: [{
+            type: Input
+        }], yPlotLines: [{
+            type: Input
+        }], yPlotLinesTooltip: [{
+            type: Input
+        }], yPlotLinesTooltipContext: [{
+            type: Input
+        }], yPlotLinesHide: [{
+            type: Input
+        }], enableZoom: [{
+            type: Input
+        }], stepLine: [{
+            type: Input
+        }], tooltipTitleTemplate: [{
+            type: Input
+        }], yAccessor: [{
+            type: Input
+        }], curveType: [{
+            type: Input
+        }], mouseUpEvent: [{
+            type: Output
+        }], markClickEvent: [{
+            type: Output
+        }], refreshEvent: [{
+            type: Output
+        }], dataCompleted: [{
+            type: Output
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"metric-chart.component.js","sourceRoot":"","sources":["../../../../../libs/common/src/metric-chart/metric-chart.component.ts","../../../../../libs/common/src/metric-chart/metric-chart.component.html"],"names":[],"mappings":"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","sourcesContent":["import { TooltipContext } from '@alauda/chart';\nimport {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  EventEmitter,\n  HostBinding,\n  Input,\n  OnInit,\n  Output,\n  TemplateRef,\n} from '@angular/core';\nimport { CurveFactory, CurveFactoryLineOnly } from 'd3';\nimport {\n  Observable,\n  Subject,\n  combineLatest,\n  merge,\n  of,\n  pipe,\n  BehaviorSubject,\n  catchError,\n  filter,\n  map,\n  switchMap,\n  tap,\n  withLatestFrom,\n} from 'rxjs';\nimport { Chart, TooltipValue } from 'zz-chart';\n\nimport {\n  AreaPosition,\n  ContextItem,\n  DATE_TIME_FORMAT_X_AXIS,\n} from '../chart/public-api';\nimport { StringMap, ObservableInput, publishRef } from '../core/public-api';\nimport {\n  ChartData,\n  ChartDataItem,\n  ChartStatus,\n  XPlotLines,\n} from '../view-chart/public-api';\n\nimport { CommonChartService } from './common-chart.service';\nimport { MatchUnitParams, PICKER_TIME_RANGES } from './helpers';\nimport { Indicator, MetricApiParams, MetricResult } from './types';\nimport { checkInterval, fillNullChartData, hasNoData } from './utils';\n\n@Component({\n  selector: 'acl-metric-chart',\n  templateUrl: './metric-chart.component.html',\n  styleUrls: ['./metric-chart.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class MetricChartComponent implements OnInit {\n  @Input() contextCallbackFunction: (context: Chart) => void;\n\n  @Input() backgroundColor: string;\n\n  @Input() hideHeader: boolean;\n\n  @Input() title: string | TemplateRef<unknown>;\n\n  @Input() hideTitle: boolean;\n\n  @Input() chartType: 'line' | 'area' | 'bar' | 'point' | 'stat' = 'area';\n\n  @Input() titleDescription: string | TemplateRef<unknown>;\n\n  @Input() titleDescriptionContext: StringMap;\n\n  @Input() unit: string;\n\n  @Input() tooltipAppendToBody = true;\n\n  @HostBinding('style.overflow')\n  get overflow() {\n    return !this.tooltipAppendToBody && 'unset';\n  }\n\n  @ObservableInput()\n  unit$!: Observable<string>;\n\n  @Input() indicator: Indicator[];\n\n  @Input() gridOffsetTop = 0;\n\n  @Input() yAxisMinStep?: number;\n\n  @Input() rotated: boolean;\n\n  @Input() barType: 'standard' | 'stacked' = 'standard';\n\n  @ObservableInput()\n  indicator$!: Observable<Indicator[]>;\n\n  @Input() metricApiParams: MetricApiParams;\n\n  @ObservableInput()\n  metricApiParams$!: Observable<MetricApiParams>;\n\n  @Input() tooltipPointNameTemplate: TemplateRef<unknown>;\n\n  @Input() tooltipPointTemplate: TemplateRef<unknown>;\n\n  @Input() legendTemplate: TemplateRef<unknown> | string;\n\n  @Input() legendSelectAllOperation = false;\n\n  @Input() legendSelectAllName: string;\n\n  @Input() tooltipHide: boolean;\n\n  @Input() tooltipPointFormat: (d: ContextItem) => number | string;\n\n  @Input() tooltipPointTemplateContext: { [key: string]: any };\n\n  @Input() tooltipColumnLayout: boolean;\n\n  @Input() hideLegend = false;\n\n  @Input() tooltipAutoSort: boolean;\n\n  @Input() tooltipSortMethod: (a: TooltipValue, b: TooltipValue) => number;\n\n  @Input() hideTooltipUnit: boolean;\n\n  @Input() leftOperation: TemplateRef<unknown>;\n\n  @Input() leftOperationContext: StringMap;\n\n  @Input() rightOperation: TemplateRef<unknown>;\n\n  @Input() mode: 'card' | 'default' = 'default';\n\n  @Input()\n  adaptUnit: boolean | MatchUnitParams;\n\n  @ObservableInput()\n  adaptUnit$!: Observable<boolean | MatchUnitParams>;\n\n  @Input()\n  percent: boolean;\n\n  @ObservableInput()\n  percent$!: Observable<boolean>;\n\n  @Input() dependOnData: boolean;\n\n  @Input() customNoDataTitle: TemplateRef<unknown> | string;\n\n  @Input() dataFormat: (\n    d: MetricResult[],\n    indicator: Indicator[],\n  ) => ChartData[];\n\n  @Input() customSeries!: MetricResult[];\n  @ObservableInput() customSeries$!: Observable<MetricResult[]>;\n\n  @Input() isCustomSeries: boolean;\n\n  series$: Observable<ChartData[]>;\n\n  @Input() chartStatus: ChartStatus;\n  @ObservableInput()\n  chartStatus$!: Observable<ChartStatus>;\n\n  @Input() tooltipTranslation = true;\n\n  @Input() xPlotLines: XPlotLines;\n\n  @Input() xPlotEmpty: boolean;\n\n  @Input() yPlotLines: TooltipContext;\n\n  @Input() yPlotLinesTooltip: TemplateRef<unknown>;\n\n  @Input() yPlotLinesTooltipContext: StringMap;\n\n  @Input() yPlotLinesHide = false;\n\n  @Input() enableZoom: boolean;\n\n  @Input() stepLine: boolean;\n\n  @Input() tooltipTitleTemplate: TemplateRef<unknown>;\n\n  @Input() yAccessor: (d: ChartDataItem) => number;\n\n  @Input() curveType: CurveFactory | CurveFactoryLineOnly;\n\n  @Output() mouseUpEvent = new EventEmitter<AreaPosition>();\n\n  @Output() markClickEvent = new EventEmitter<TooltipContext>();\n\n  @Output() refreshEvent = new EventEmitter();\n\n  @Output() dataCompleted = new EventEmitter<void>();\n\n  reload$ = new BehaviorSubject(null);\n\n  _chartStatus$$ = new Subject<ChartStatus>();\n  _status: ChartStatus = {};\n  status$ = merge(this.chartStatus$, this._chartStatus$$).pipe(\n    map(status => ({\n      ...this._status,\n      ...status,\n    })),\n    tap(status => (this._status = status)),\n    publishRef(),\n  );\n\n  noData: boolean;\n\n  dateAxisLabelFormats = DATE_TIME_FORMAT_X_AXIS;\n\n  dateXAxisLabelFormats = '%H:%M';\n\n  get xAccessor() {\n    return (d: ChartDataItem<{ x: number; y: number }>) => d.x * 1000;\n  }\n\n  yAccessor$ = this.percent$.pipe(\n    tap(percent => {\n      if (percent) {\n        this.unit = '%';\n      }\n    }),\n    map(percent => (d: ChartDataItem<{ x: number; y: number }>) => {\n      // prometheus 可能出现 Infinity情况，处理为 null\n      if (!Number.isFinite(d.y) || String(d.y) === '+Inf') {\n        return null;\n      }\n      return percent && d.y ? +d.y * 100 : d.y === null ? d.y : +d.y;\n    }),\n  );\n\n  _cacheTime: MetricApiParams = {\n    start: PICKER_TIME_RANGES[1].startTime(),\n    end: PICKER_TIME_RANGES[1].endTime(),\n    step: PICKER_TIME_RANGES[1].step,\n  };\n\n  private chartParams: MetricApiParams;\n\n  constructor(\n    private readonly service: CommonChartService,\n    private readonly cdr: ChangeDetectorRef,\n  ) {}\n\n  ngOnInit() {\n    if (this.metricApiParams) {\n      this._cacheTime = this.metricApiParams;\n    }\n\n    this.series$ = (\n      this.isCustomSeries ? this.customSeries$ : this.defaultSeries$\n    ).pipe(this.handleMetricDataPipe());\n  }\n\n  defaultSeries$: Observable<MetricResult[]> = combineLatest([\n    this.metricApiParams$,\n    this.indicator$,\n    this.reload$,\n  ]).pipe(\n    tap(([, indicator]) => {\n      this.handleTimeParams();\n      this.handleDateAxisLabelFormats(this.chartParams);\n      this.handelChartStatus({\n        loading: !!indicator?.length,\n        failed: false,\n        noData: !indicator?.length,\n      });\n    }),\n    switchMap(([_, indicator]) =>\n      indicator?.length && this.chartParams\n        ? this.service.requestChartData(this.chartParams, indicator).pipe(\n            catchError(() => {\n              this.handelChartStatus({ loading: false, failed: true });\n              return of(null);\n            }),\n          )\n        : of(null),\n    ),\n  );\n\n  handleTimeParams() {\n    let timeParams = this.metricApiParams;\n    if (timeParams) {\n      if (checkInterval(this.metricApiParams, this._cacheTime)) {\n        this._cacheTime = this.metricApiParams;\n      } else {\n        timeParams = this._cacheTime;\n      }\n      this.chartParams = {\n        ...this.metricApiParams,\n        ...timeParams,\n      };\n    }\n  }\n\n  handleMetricDataPipe() {\n    return pipe(\n      tap(() => {\n        if (this.isCustomSeries) {\n          this.handleTimeParams();\n        }\n      }),\n      filter(\n        (res: MetricResult[]) =>\n          !!this.chartParams && (!!res || !this.indicator?.length),\n      ),\n      map((res: MetricResult[]) => {\n        const format = this.dataFormat || this.service.handelChartData;\n        // `fillNullChartData` prometheus 存在某个时间点未采集到数据的情况，这里为区分 未采集到数据为0的情况，这里前端根据时间段自动填充数据\n        // 后端 需要和 Prometheus API 保持兼容，还是在前端做处理填充\n        return format(res, this.indicator || [], this.dependOnData)?.map(\n          item => ({\n            ...item,\n            unit: this.unit,\n            values: fillNullChartData(\n              this.chartParams,\n              item.values as Array<ChartDataItem<{ x: number; y: number }>>,\n              this.stepLine,\n            ),\n          }),\n        );\n      }),\n      tap(res => {\n        this.handleDateAxisLabelFormats(this.chartParams);\n        this.handelChartStatus({\n          loading: false,\n          noData: hasNoData(res),\n        });\n        this.cdr.markForCheck();\n      }),\n      map(res =>\n        res?.length\n          ? res\n          : [\n              {\n                values: fillNullChartData(this.chartParams, [], this.stepLine),\n              },\n            ],\n      ),\n      withLatestFrom(this.adaptUnit$),\n      map(([res, _adaptUnit]) => {\n        if (_adaptUnit && !this.noData) {\n          const { base, unit } = this.service.adaptChartUnit(res, _adaptUnit);\n          this.unit = `unit_${unit}`;\n          if (typeof _adaptUnit === 'object') {\n            const { defaultPrefix = true, prefix } = _adaptUnit;\n            this.unit = defaultPrefix\n              ? `unit_${unit}`\n              : `${prefix || ''}${unit}`;\n          }\n          return (res as ChartData[]).map((item: ChartData) => ({\n            ...item,\n            unit: this.unit,\n            values: item.values.map(d => ({\n              ...d,\n              y: d.y ? d.y / base : d.y,\n            })),\n          }));\n        }\n        return res.map(item => ({ ...item, unit: this.unit })) as ChartData[];\n      }),\n      tap(() => {\n        this.dataCompleted.next();\n      }),\n      publishRef(),\n    );\n  }\n\n  refresh() {\n    this.reload$.next(null);\n    this.refreshEvent.next(null);\n  }\n\n  private handelChartStatus(status: ChartStatus) {\n    this._chartStatus$$.next({\n      ...status,\n    });\n  }\n\n  private handleDateAxisLabelFormats(params: MetricApiParams) {\n    if (params) {\n      const diff = params.end - params.start;\n      const m1 = 24 * 60 * 60;\n      const m3 = 3 * m1;\n      const m7 = 7 * m1;\n      const M_D_FORMAT = 'MM-DD';\n      const format =\n        diff >= m7\n          ? M_D_FORMAT\n          : diff < m7 && (diff >= m3 || diff > m1)\n          ? `${M_D_FORMAT} ${DATE_TIME_FORMAT_X_AXIS}`\n          : DATE_TIME_FORMAT_X_AXIS;\n      this.dateAxisLabelFormats = format;\n      // https://d3js.org.cn/document/d3-time-format/#api-reference\n      this.dateXAxisLabelFormats =\n        diff >= m7\n          ? '%m-%d'\n          : diff < m7 && (diff >= m3 || diff > m1)\n          ? `%m-%d %H:%M`\n          : '%H:%M';\n      this.cdr.detectChanges();\n    }\n  }\n}\n","<acl-view-zchart\n  [class.overflow-display]=\"!tooltipAppendToBody\"\n  [contextCallbackFunction]=\"contextCallbackFunction\"\n  [unit]=\"unit\"\n  [hideHeader]=\"hideHeader\"\n  [customNoDataTitle]=\"customNoDataTitle\"\n  [chartStatus]=\"status$ | async\"\n  [backgroundColor]=\"backgroundColor\"\n  [series]=\"series$ | async\"\n  [curveType]=\"curveType\"\n  [tooltipAppendToBody]=\"tooltipAppendToBody\"\n  [mode]=\"mode\"\n  [gridOffsetTop]=\"gridOffsetTop\"\n  [title]=\"title\"\n  [chartType]=\"chartType\"\n  [hideTitle]=\"hideTitle\"\n  [tooltipHide]=\"tooltipHide\"\n  [tooltipSortMethod]=\"tooltipSortMethod\"\n  [titleDescription]=\"titleDescription\"\n  [titleDescriptionContext]=\"titleDescriptionContext\"\n  [hideLegend]=\"(dependOnData && noData) || hideLegend\"\n  [dateAxisLabelFormats]=\"dateAxisLabelFormats\"\n  [enableZoom]=\"enableZoom\"\n  [stepLine]=\"stepLine\"\n  [rotated]=\"rotated\"\n  [rightOperation]=\"rightOperation\"\n  [leftOperation]=\"leftOperation\"\n  [leftOperationContext]=\"leftOperationContext\"\n  [legendTemplate]=\"legendTemplate\"\n  [legendSelectAllOperation]=\"legendSelectAllOperation\"\n  [legendSelectAllName]=\"legendSelectAllName\"\n  [yAccessor]=\"yAccessor || (yAccessor$ | async)\"\n  [xAccessor]=\"xAccessor\"\n  [yAxisMinStep]=\"yAxisMinStep\"\n  [hideTooltipUnit]=\"hideTooltipUnit\"\n  [tooltipTitleTemplate]=\"tooltipTitleTemplate\"\n  [tooltipAutoSort]=\"tooltipAutoSort\"\n  [tooltipTranslation]=\"tooltipTranslation\"\n  [tooltipPointNameTemplate]=\"tooltipPointNameTemplate\"\n  [tooltipPointTemplate]=\"tooltipPointTemplate\"\n  [tooltipPointTemplateContext]=\"tooltipPointTemplateContext\"\n  [xPlotLines]=\"xPlotLines\"\n  [xPlotEmpty]=\"xPlotEmpty\"\n  [yPlotLinesHide]=\"yPlotLinesHide\"\n  [yPlotLines]=\"yPlotLines\"\n  (mouseUpEvent)=\"mouseUpEvent.next($event)\"\n  (markClickEvent)=\"markClickEvent.next($event)\"\n  (refreshEvent)=\"refresh()\"\n>\n</acl-view-zchart>\n<!-- [tooltipPointFormat]=\"tooltipPointFormat\" -->\n"]}