@alauda-fe/common 1.0.0-next.0

package/esm2022/a-metric-chart/utils/util.mjs

@@ -0,0 +1,219 @@
+import dayjs from 'dayjs';
+import { get, isEqual, isFunction, template, uniq } from 'lodash-es';
+import { CHART_TIME_FORMAT } from '../../a-chart/public-api';
+import { FIELD_NOT_AVAILABLE_PLACEHOLDER, } from '../../core/public-api';
+import { PICKER_TIME_RANGES } from '../../metric-chart/helpers';
+import { roundInterval } from './range';
+export function handleMetricParams(params, { variableSource, start, end, step }) {
+    const value = params.reduce((pre, cur) => {
+        const v = Array.isArray(variableSource)
+            ? variableSource
+            : cur.variables?.length && variableSource
+                ? [variableSource]
+                : [];
+        const variable = v.map(value => {
+            return cur.variables?.reduce((pre, key) => value[key]
+                ? {
+                    ...pre,
+                    [key]: value[key],
+                }
+                : pre, {});
+        });
+        const indicators = cur.indicators || cur.expr;
+        return {
+            indicators: cur.indicators
+                ? uniq([...pre.indicators, indicators])
+                : pre.indicators,
+            exprs: cur.expr ? [...pre.exprs, indicators] : pre.exprs,
+            variables: isEqual(variable.reduce((p, c) => ({ ...p, ...c }), {}), pre.variables.reduce((p, c) => ({ ...p, ...c }), {}))
+                ? pre.variables
+                : [...pre.variables, ...variable],
+        };
+    }, { indicators: [], exprs: [], variables: [] });
+    return {
+        ...value,
+        start,
+        end,
+        step,
+    };
+}
+export function handleChartData({ indicatorParams, metricParams }, data) {
+    if (!data) {
+        return [];
+    }
+    const { dependentData } = metricParams;
+    return dependentData
+        ? dependOnData(indicatorParams, data)
+        : dependOnIndicator(indicatorParams, data);
+}
+export function dependOnIndicator(indicatorParams, data) {
+    return indicatorParams.reduce((pre, params) => {
+        const metricData = data?.find(item => item.indicator === params.indicators);
+        return [...pre, handleDataResult(params, metricData?.result?.[0])];
+    }, []);
+}
+export function dependOnData(indicatorParams, data) {
+    const params = indicatorParams[0];
+    return data?.reduce((pre, res) => {
+        if (params.indicators === res.indicator || params.expr === res.query) {
+            return [
+                ...pre,
+                ...res.result.map(item => handleDataResult(params, item)),
+            ];
+        }
+        return pre;
+    }, []);
+}
+export function handleDataResult(params, res) {
+    return {
+        name: handleLegend(params, res),
+        values: res?.values?.map(d => ({
+            x: d[0],
+            y: d[1],
+        })),
+    };
+}
+export function handleLegend(params, result) {
+    return isFunction(params?.legend)
+        ? params.legend(params, result)
+        : getLegendName(params?.legend, result?.metric || {});
+}
+export const LEGEND_TEMPLATE_OPTIONS = Object.freeze({
+    // eslint-disable-next-line regexp/match-any, regexp/strict
+    interpolate: /{{\.([\S\s]+?)}}/g,
+});
+export function getLegendName(metricKey, metric) {
+    if (!metricKey && !Object.keys(metric || {})?.length) {
+        return FIELD_NOT_AVAILABLE_PLACEHOLDER;
+    }
+    if (!metricKey && metric) {
+        return JSON.stringify(metric);
+    }
+    const metricKeys = metricKey?.split(',').map(matchLegend);
+    if (metricKeys?.length > 1) {
+        const value = metric?.[metricKeys.find(item => metric[item])];
+        return value || metricKey;
+    }
+    return (getLegendTemplate(metricKey, metric) ||
+        metric[matchLegend(metricKey)] ||
+        metricKey);
+}
+function getLegendTemplate(str, obj) {
+    let name;
+    try {
+        name = get(obj, str) || template(str, LEGEND_TEMPLATE_OPTIONS)(obj);
+    }
+    catch {
+        name = '';
+    }
+    return name;
+}
+function matchLegend(value) {
+    // eslint-disable-next-line unicorn/better-regex
+    return value.match(/\{\{\.(.+?)\}\}/)?.[1] || value;
+}
+// 填充空数据
+// eslint-disable-next-line sonarjs/cognitive-complexity
+export function fillNullData({ start, end, step }, res = [], stepLine = false) {
+    if (!+start || !+end) {
+        return res;
+    }
+    const _step = step || roundInterval(start, end);
+    const curStart = +start;
+    const curEnd = start + step * ((end - start) / step);
+    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: 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 handleDateAxisLabelFormats(params, isRich) {
+    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 MD_HS_FORMAT = `${M_D_FORMAT} ${CHART_TIME_FORMAT}`;
+        return diff >= m7
+            ? isRich
+                ? MD_HS_FORMAT
+                : M_D_FORMAT
+            : diff < m7 && (diff >= m3 || diff > m1)
+                ? MD_HS_FORMAT
+                : CHART_TIME_FORMAT;
+    }
+}
+export function limitMaxTooltipItem(context, limit = 15) {
+    return context.slice(0, limit);
+}
+export const VARIABLE_KEY_CLUSTER = '$cluster';
+export const VARIABLE_KEY_NAMESPACE = '$namespace';
+export function replaceExprVariable(expr, variable) {
+    let data = Array.isArray(expr) ? expr.join('|') : expr;
+    const variableKeys = Object.keys(variable);
+    const variableValues = Object.values(variable);
+    const vars = data && typeof data.match === 'function' ? data.match(/\$\w+/g) : [];
+    if (!variableKeys.length ||
+        !variableKeys.some(v => vars?.some(item => item.replace('$', '') === v))) {
+        return data;
+    }
+    vars.forEach(key => {
+        const k = key.replace('$', '');
+        const index = variableKeys.indexOf(k);
+        if (index >= 0) {
+            const v = variableValues[index];
+            data = data?.replace(new RegExp(`\\$${k}`, 'g'), Array.isArray(v) ? v.join('|') : v);
+        }
+    });
+    return data;
+}
+export function findTimeRange(diff) {
+    const time = PICKER_TIME_RANGES.find(item => {
+        return item.endTime() - item.startTime() === diff;
+    });
+    return time ? { start: time.startTime(), end: time.endTime() } : null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../../../../libs/common/src/a-metric-chart/utils/util.ts"],"names":[],"mappings":"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","sourcesContent":["import dayjs from 'dayjs';\nimport { get, isEqual, isFunction, template, uniq } from 'lodash-es';\nimport { DataItem, TooltipValue } from 'zz-chart';\n\nimport { CHART_TIME_FORMAT } from '../../a-chart/public-api';\nimport { AChartData } from '../../a-chart/types';\nimport { MonitorMetric, MonitorMetricResult } from '../../api/public-api';\nimport {\n  Dictionary,\n  FIELD_NOT_AVAILABLE_PLACEHOLDER,\n  StringMap,\n} from '../../core/public-api';\nimport { PICKER_TIME_RANGES } from '../../metric-chart/helpers';\nimport { FetchParams, IndicatorParams, MetricParams } from '../types';\n\nimport { roundInterval } from './range';\n\nexport function handleMetricParams(\n  params: IndicatorParams[],\n  { variableSource, start, end, step }: MetricParams,\n) {\n  const value = params.reduce(\n    (pre, cur) => {\n      const v = Array.isArray(variableSource)\n        ? variableSource\n        : cur.variables?.length && variableSource\n        ? [variableSource]\n        : [];\n      const variable: StringMap[] = v.map(value => {\n        return cur.variables?.reduce(\n          (pre, key) =>\n            value[key]\n              ? {\n                  ...pre,\n                  [key]: value[key],\n                }\n              : pre,\n          {},\n        );\n      });\n      const indicators = cur.indicators || cur.expr;\n      return {\n        indicators: cur.indicators\n          ? uniq([...pre.indicators, indicators])\n          : pre.indicators,\n        exprs: cur.expr ? [...pre.exprs, indicators] : pre.exprs,\n        variables: isEqual(\n          variable.reduce((p, c) => ({ ...p, ...c }), {}),\n          pre.variables.reduce((p, c) => ({ ...p, ...c }), {}),\n        )\n          ? pre.variables\n          : [...pre.variables, ...variable],\n      };\n    },\n    { indicators: [], exprs: [], variables: [] },\n  );\n  return {\n    ...value,\n    start,\n    end,\n    step,\n  };\n}\n\nexport function handleChartData(\n  { indicatorParams, metricParams }: FetchParams,\n  data: MonitorMetric[],\n) {\n  if (!data) {\n    return [];\n  }\n  const { dependentData } = metricParams;\n  return dependentData\n    ? dependOnData(indicatorParams, data)\n    : dependOnIndicator(indicatorParams, data);\n}\n\nexport function dependOnIndicator(\n  indicatorParams: IndicatorParams[],\n  data: MonitorMetric[],\n): AChartData[] {\n  return indicatorParams.reduce((pre, params) => {\n    const metricData = data?.find(item => item.indicator === params.indicators);\n    return [...pre, handleDataResult(params, metricData?.result?.[0])];\n  }, []);\n}\n\nexport function dependOnData(\n  indicatorParams: IndicatorParams[],\n  data: MonitorMetric[],\n): AChartData[] {\n  const params = indicatorParams[0];\n  return data?.reduce((pre, res) => {\n    if (params.indicators === res.indicator || params.expr === res.query) {\n      return [\n        ...pre,\n        ...res.result.map(item => handleDataResult(params, item)),\n      ];\n    }\n    return pre;\n  }, []);\n}\n\nexport function handleDataResult(\n  params: IndicatorParams,\n  res: MonitorMetricResult,\n) {\n  return {\n    name: handleLegend(params, res),\n    values: res?.values?.map(d => ({\n      x: d[0],\n      y: d[1],\n    })),\n  };\n}\n\nexport function handleLegend(\n  params: IndicatorParams,\n  result: MonitorMetricResult,\n) {\n  return isFunction(params?.legend)\n    ? params.legend(params, result)\n    : getLegendName(params?.legend, result?.metric || {});\n}\nexport const LEGEND_TEMPLATE_OPTIONS = Object.freeze({\n  // eslint-disable-next-line regexp/match-any, regexp/strict\n  interpolate: /{{\\.([\\S\\s]+?)}}/g,\n});\n\nexport function getLegendName(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(',').map(matchLegend);\n  if (metricKeys?.length > 1) {\n    const value = metric?.[metricKeys.find(item => metric[item])];\n    return value || metricKey;\n  }\n  return (\n    getLegendTemplate(metricKey, metric) ||\n    metric[matchLegend(metricKey)] ||\n    metricKey\n  );\n}\n\nfunction getLegendTemplate(str: string, obj: object) {\n  let name: string;\n  try {\n    name = get(obj, str) || template(str, LEGEND_TEMPLATE_OPTIONS)(obj);\n  } catch {\n    name = '';\n  }\n  return name;\n}\n\nfunction matchLegend(value: string) {\n  // eslint-disable-next-line unicorn/better-regex\n  return value.match(/\\{\\{\\.(.+?)\\}\\}/)?.[1] || value;\n}\n\n// 填充空数据\n// eslint-disable-next-line sonarjs/cognitive-complexity\nexport function fillNullData(\n  { start, end, step }: MetricParams,\n  res: DataItem['values'] = [],\n  stepLine = false,\n) {\n  if (!+start || !+end) {\n    return res;\n  }\n  const _step = step || roundInterval(start, end);\n  const curStart = +start;\n  const curEnd = start + step * ((end - start) / step);\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: 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 handleDateAxisLabelFormats(\n  params: MetricParams,\n  isRich?: boolean,\n) {\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 MD_HS_FORMAT = `${M_D_FORMAT} ${CHART_TIME_FORMAT}`;\n    return diff >= m7\n      ? isRich\n        ? MD_HS_FORMAT\n        : M_D_FORMAT\n      : diff < m7 && (diff >= m3 || diff > m1)\n      ? MD_HS_FORMAT\n      : CHART_TIME_FORMAT;\n  }\n}\n\nexport function limitMaxTooltipItem(context: TooltipValue[], limit = 15) {\n  return context.slice(0, limit);\n}\n\nexport const VARIABLE_KEY_CLUSTER = '$cluster';\nexport const VARIABLE_KEY_NAMESPACE = '$namespace';\n\nexport function replaceExprVariable(\n  expr: string | string[],\n  variable: Dictionary<any>,\n) {\n  let data = Array.isArray(expr) ? expr.join('|') : expr;\n  const variableKeys = Object.keys(variable);\n  const variableValues = Object.values(variable);\n  const vars: string[] =\n    data && typeof data.match === 'function' ? data.match(/\\$\\w+/g) : [];\n  if (\n    !variableKeys.length ||\n    !variableKeys.some(v => vars?.some(item => item.replace('$', '') === v))\n  ) {\n    return data;\n  }\n  vars.forEach(key => {\n    const k = key.replace('$', '');\n    const index = variableKeys.indexOf(k);\n    if (index >= 0) {\n      const v = variableValues[index];\n      data = data?.replace(\n        new RegExp(`\\\\$${k}`, 'g'),\n        Array.isArray(v) ? v.join('|') : v,\n      );\n    }\n  });\n  return data;\n}\n\nexport function findTimeRange(diff: number) {\n  const time = PICKER_TIME_RANGES.find(item => {\n    return item.endTime() - item.startTime() === diff;\n  });\n  return time ? { start: time.startTime(), end: time.endTime() } : null;\n}\n"]}

package/esm2022/abnormal-page/abnormal-page.component.mjs

@@ -0,0 +1,66 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { Reason } from '../page-guard/public-api';
+import * as i0 from "@angular/core";
+function AbnormalPageComponent_ng_container_1_Template(rf, ctx) { if (rf & 1) {
+    const _r2 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelementStart(1, "p", 2)(2, "span");
+    i0.ɵɵtext(3);
+    i0.ɵɵpipe(4, "translate");
+    i0.ɵɵpipe(5, "translate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(6, "button", 3);
+    i0.ɵɵlistener("click", function AbnormalPageComponent_ng_container_1_Template_button_click_6_listener() { i0.ɵɵrestoreView(_r2); const ctx_r1 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r1.retry()); });
+    i0.ɵɵtext(7);
+    i0.ɵɵpipe(8, "translate");
+    i0.ɵɵelementEnd()();
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    i0.ɵɵadvance(3);
+    i0.ɵɵtextInterpolate2("", i0.ɵɵpipeBind1(4, 3, "system_abnormal_description"), "", i0.ɵɵpipeBind1(5, 5, "or"), "");
+    i0.ɵɵadvance(4);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(8, 7, "retry"), " ");
+} }
+export class AbnormalPageComponent {
+    constructor() {
+        this.reason = Reason;
+    }
+    retry() {
+        window.location.reload();
+    }
+    static { this.ɵfac = function AbnormalPageComponent_Factory(t) { return new (t || AbnormalPageComponent)(); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: AbnormalPageComponent, selectors: [["acl-abnormal-page"]], decls: 2, vars: 3, consts: [[3, "allowed", "reason", "isFull"], [4, "aclPageGuardDescription"], [1, "description"], ["aui-button", "text", "size", "small", 3, "click"]], template: function AbnormalPageComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "acl-page-guard", 0);
+            i0.ɵɵtemplate(1, AbnormalPageComponent_ng_container_1_Template, 9, 9, "ng-container", 1);
+            i0.ɵɵelementEnd();
+        } if (rf & 2) {
+            i0.ɵɵproperty("allowed", false)("reason", ctx.reason.Abnormal)("isFull", true);
+        } }, styles: [".description[_ngcontent-%COMP%]{color:rgb(var(--aui-color-secondary-text))}"], changeDetection: 0 }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(AbnormalPageComponent, [{
+        type: Component,
+        args: [{ selector: 'acl-abnormal-page', template: `
+    <acl-page-guard
+      [allowed]="false"
+      [reason]="reason.Abnormal"
+      [isFull]="true"
+    >
+      <ng-container *aclPageGuardDescription>
+        <p class="description">
+          <span
+            >{{ 'system_abnormal_description' | translate
+            }}{{ 'or' | translate }}</span
+          >
+          <button
+            aui-button="text"
+            size="small"
+            (click)="retry()"
+          >
+            {{ 'retry' | translate }}
+          </button>
+        </p>
+      </ng-container>
+    </acl-page-guard>
+  `, changeDetection: ChangeDetectionStrategy.OnPush, styles: [".description{color:rgb(var(--aui-color-secondary-text))}\n"] }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/abnormal-page/abnormal-page.module.mjs

@@ -0,0 +1,27 @@
+import { ButtonModule } from '@alauda/ui';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { PageGuardModule } from '../page-guard/public-api';
+import { TranslateModule } from '../translate/public-api';
+import { AbnormalPageComponent } from './abnormal-page.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../page-guard/component/component";
+import * as i2 from "../page-guard/component/helper-directives";
+import * as i3 from "@alauda/ui";
+import * as i4 from "../translate/translate.pipe";
+export class AbnormalPageModule {
+    static { this.ɵfac = function AbnormalPageModule_Factory(t) { return new (t || AbnormalPageModule)(); }; }
+    static { this.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: AbnormalPageModule }); }
+    static { this.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [CommonModule, PageGuardModule, TranslateModule, ButtonModule] }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(AbnormalPageModule, [{
+        type: NgModule,
+        args: [{
+                imports: [CommonModule, PageGuardModule, TranslateModule, ButtonModule],
+                declarations: [AbnormalPageComponent],
+                exports: [AbnormalPageComponent],
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(AbnormalPageModule, { declarations: [AbnormalPageComponent], imports: [CommonModule, PageGuardModule, TranslateModule, ButtonModule], exports: [AbnormalPageComponent] }); })();
+i0.ɵɵsetComponentScope(AbnormalPageComponent, [i1.PageGuardComponent, i2.PageGuardDescriptionDirective, i3.ButtonComponent], [i4.TranslatePipe]);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJub3JtYWwtcGFnZS5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2NvbW1vbi9zcmMvYWJub3JtYWwtcGFnZS9hYm5vcm1hbC1wYWdlLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sWUFBWSxDQUFDO0FBQzFDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXpDLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUMzRCxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFMUQsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7Ozs7OztBQU9sRSxNQUFNLE9BQU8sa0JBQWtCO21GQUFsQixrQkFBa0I7bUVBQWxCLGtCQUFrQjt1RUFKbkIsWUFBWSxFQUFFLGVBQWUsRUFBRSxlQUFlLEVBQUUsWUFBWTs7dUZBSTNELGtCQUFrQjtjQUw5QixRQUFRO2VBQUM7Z0JBQ1IsT0FBTyxFQUFFLENBQUMsWUFBWSxFQUFFLGVBQWUsRUFBRSxlQUFlLEVBQUUsWUFBWSxDQUFDO2dCQUN2RSxZQUFZLEVBQUUsQ0FBQyxxQkFBcUIsQ0FBQztnQkFDckMsT0FBTyxFQUFFLENBQUMscUJBQXFCLENBQUM7YUFDakM7O3dGQUNZLGtCQUFrQixtQkFIZCxxQkFBcUIsYUFEMUIsWUFBWSxFQUFFLGVBQWUsRUFBRSxlQUFlLEVBQUUsWUFBWSxhQUU1RCxxQkFBcUI7dUJBRGhCLHFCQUFxQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJ1dHRvbk1vZHVsZSB9IGZyb20gJ0BhbGF1ZGEvdWknO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IFBhZ2VHdWFyZE1vZHVsZSB9IGZyb20gJy4uL3BhZ2UtZ3VhcmQvcHVibGljLWFwaSc7XG5pbXBvcnQgeyBUcmFuc2xhdGVNb2R1bGUgfSBmcm9tICcuLi90cmFuc2xhdGUvcHVibGljLWFwaSc7XG5cbmltcG9ydCB7IEFibm9ybWFsUGFnZUNvbXBvbmVudCB9IGZyb20gJy4vYWJub3JtYWwtcGFnZS5jb21wb25lbnQnO1xuXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlLCBQYWdlR3VhcmRNb2R1bGUsIFRyYW5zbGF0ZU1vZHVsZSwgQnV0dG9uTW9kdWxlXSxcbiAgZGVjbGFyYXRpb25zOiBbQWJub3JtYWxQYWdlQ29tcG9uZW50XSxcbiAgZXhwb3J0czogW0Fibm9ybWFsUGFnZUNvbXBvbmVudF0sXG59KVxuZXhwb3J0IGNsYXNzIEFibm9ybWFsUGFnZU1vZHVsZSB7fVxuIl19

package/esm2022/abnormal-page/public-api.mjs

@@ -0,0 +1,3 @@
+export * from './abnormal-page.component';
+export * from './abnormal-page.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9hYm5vcm1hbC1wYWdlL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLHdCQUF3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hYm5vcm1hbC1wYWdlLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2Fibm9ybWFsLXBhZ2UubW9kdWxlJztcbiJdfQ==

package/esm2022/alauda-fe-common.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxhdWRhLWZlLWNvbW1vbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9hbGF1ZGEtZmUtY29tbW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=

package/esm2022/api/api-gateway.interceptor.mjs

@@ -0,0 +1,28 @@
+import { Injectable } from '@angular/core';
+import { switchMap } from 'rxjs';
+import { API_GATEWAY } from '../core/public-api';
+import { ApiGatewayService } from './api-gateway.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./api-gateway.service";
+// Interceptor must provide with correct order, not provide in root here
+// https://angular.cn/guide/http#interceptor-order
+export class ApiGatewayInterceptor {
+    constructor(apiGateway) {
+        this.apiGateway = apiGateway;
+    }
+    intercept(req, next) {
+        if (!req.url.startsWith(API_GATEWAY)) {
+            return next.handle(req);
+        }
+        return this.apiGateway.getApiAddress().pipe(switchMap(apiAddress => {
+            const url = req.url.replace(API_GATEWAY, apiAddress);
+            return next.handle(req.clone({ url }));
+        }));
+    }
+    static { this.ɵfac = function ApiGatewayInterceptor_Factory(t) { return new (t || ApiGatewayInterceptor)(i0.ɵɵinject(i1.ApiGatewayService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ApiGatewayInterceptor, factory: ApiGatewayInterceptor.ɵfac }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ApiGatewayInterceptor, [{
+        type: Injectable
+    }], function () { return [{ type: i1.ApiGatewayService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/api/api-gateway.service.mjs

@@ -0,0 +1,38 @@
+/**
+ * @packageDocumentation
+ * @module api
+ */
+import { HttpClient } from '@angular/common/http';
+import { Inject, Injectable } from '@angular/core';
+import { Subject, map, retry, shareReplay, takeUntil } from 'rxjs';
+import { MODULES_API } from '../core/public-api';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+const RETRY_COUNT = 3;
+export class ApiGatewayService {
+    constructor(http, modulesApi) {
+        this.http = http;
+        this.modulesApi = modulesApi;
+        this.destroy$$ = new Subject();
+        this.state$ = this.http
+            .get(this.modulesApi)
+            .pipe(retry(RETRY_COUNT), shareReplay(1), takeUntil(this.destroy$$));
+    }
+    ngOnDestroy() {
+        this.destroy$$.next();
+        this.destroy$$.complete();
+    }
+    getApiAddress() {
+        return this.state$.pipe(map(state => state.apiAddress));
+    }
+    static { this.ɵfac = function ApiGatewayService_Factory(t) { return new (t || ApiGatewayService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(MODULES_API)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ApiGatewayService, factory: ApiGatewayService.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ApiGatewayService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], function () { return [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                type: Inject,
+                args: [MODULES_API]
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/api/cluster-version.service.mjs

@@ -0,0 +1,67 @@
+import { Injectable } from '@angular/core';
+import { catchError, combineLatest, map, of, shareReplay, tap, } from 'rxjs';
+import { compareMinorVersion, PUBLIC_NAMESPACE, publishRef } from '../core';
+import { K8sApiService } from './k8s-api.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./k8s-api.service";
+export class ClusterVersionService {
+    constructor(k8sApi) {
+        this.k8sApi = k8sApi;
+        this.store = {};
+        this.platformVersion$ = this.k8sApi
+            .getGlobalResource({
+            definition: { type: 'configmaps' },
+            namespace: PUBLIC_NAMESPACE,
+            name: 'platform',
+        })
+            .pipe(map(config => config.data.version.slice(1)), shareReplay(1));
+        this.isOldCluster = (cluster) => {
+            return combineLatest([
+                this.getClusterVersion(cluster),
+                this.platformVersion(),
+            ]).pipe(map(([clusterVersion, platformVersion]) => compareMinorVersion(clusterVersion, platformVersion) < 0), catchError(() => of(false)), publishRef());
+        };
+    }
+    /**
+     * @deprecated
+     */
+    isPrevLTS(cluster) {
+        return this.isOldCluster(cluster);
+    }
+    clusterOldThan(cluster, version) {
+        return this.getClusterVersion(cluster).pipe(map(clusterVersion => compareMinorVersion(clusterVersion, version) < 0), publishRef());
+    }
+    platformVersion() {
+        return this.platformVersion$;
+    }
+    getClusterVersion(cluster) {
+        if (this.store[cluster]) {
+            return of(this.store[cluster]);
+        }
+        return this.k8sApi
+            .getGlobalResource({
+            definition: {
+                type: 'clustermodules',
+                apiVersion: 'v1alpha1',
+                apiGroup: 'cluster.alauda.io',
+            },
+            name: cluster,
+        })
+            .pipe(map(cluster => cluster.spec.version.slice(1)), tap(version => {
+            this.store[cluster] = version;
+        }));
+    }
+    set clusterVersion(version) {
+        this.version = version;
+    }
+    get clusterVersion() {
+        return this.version;
+    }
+    static { this.ɵfac = function ClusterVersionService_Factory(t) { return new (t || ClusterVersionService)(i0.ɵɵinject(i1.K8sApiService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ClusterVersionService, factory: ClusterVersionService.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ClusterVersionService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], function () { return [{ type: i1.K8sApiService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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