@alauda-fe/common 1.0.0-next.0

package/esm2022/k8s-resource-list/utils.mjs

@@ -0,0 +1,81 @@
+/**
+ * @packageDocumentation
+ * @module k8s-resource-list
+ */
+import { equals } from 'ramda';
+import { distinctUntilChanged, map } from 'rxjs';
+/**
+ * convert selector.matchLabels to string
+ * refers to: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api
+ */
+export function matchLabelsToString(params = {}) {
+    return Object.keys(params)
+        .filter(key => params[key])
+        .map(key => `${key}=${params[key]}`)
+        .join(',');
+}
+/**
+ * convert string to selector.matchLabels
+ */
+export function stringToMatchLabels(str) {
+    const labels = {};
+    if (str) {
+        return str.split(',').reduce((acc, item) => {
+            const [key, value] = item.split('=');
+            if (key && value) {
+                acc[key] = value;
+            }
+            return acc;
+        }, labels);
+    }
+    return labels;
+}
+export function matchExpressionsToString(params) {
+    return params
+        .map(param => {
+        switch (param.operator.toLowerCase()) {
+            case '=':
+            case '==':
+            case '!=': {
+                return `${param.key}${param.operator}${param.values[0]}`;
+            }
+            case '!': {
+                return `!${param.key}`;
+            }
+            case 'in':
+            case 'notin': {
+                return `${param.key} ${param.operator} (${param.values
+                    .filter(Boolean)
+                    .join(',')})`;
+            }
+            case 'exists': {
+                return `${param.key}`;
+            }
+            case 'doesnotexist': {
+                return `!${param.key}`;
+            }
+            default: {
+                return param.key;
+            }
+        }
+    })
+        .join(',');
+}
+export function extractListParamsFromRoute(route) {
+    return route.queryParamMap.pipe(map(paramMap => ({
+        labelSelector: paramMap.get('labelSelector'),
+        fieldSelector: paramMap.get('fieldSelector'),
+        keyword: paramMap.get('keyword'),
+        field: paramMap.get('field'),
+    })), distinctUntilChanged(equals));
+}
+export function normalizeParams(params) {
+    return Object.entries(params).reduce((acc, [key, value]) => {
+        value = typeof value === 'string' ? value.trim() : value;
+        if (value) {
+            acc[key] = value;
+        }
+        return acc;
+    }, {});
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/license/license-api.mjs

@@ -0,0 +1,55 @@
+/**
+ * @packageDocumentation
+ * @module license-api
+ */
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs';
+import { API_GATEWAY } from '../core/constants/constants';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export const LICENSE_FEATURE_GATE = `${API_GATEWAY}/fg/v1/featuregates/license`;
+export function getResourceNum(resource = {}) {
+    return Object.values(resource).reduce((pre, cur) => cur + pre, 0);
+}
+// replace space to -, as Container-Platform
+export function formatProductName(productName) {
+    return productName.replaceAll(/\s+/g, '-');
+}
+export class LicenseApiService {
+    constructor(http) {
+        this.http = http;
+    }
+    getLicenseResourceLimit(check, resource) {
+        const params = check === 'version'
+            ? { check, targetVersion: resource }
+            : { check, resourceNum: resource };
+        return this.http
+            .get(LICENSE_FEATURE_GATE, {
+            params,
+        })
+            .pipe(map(res => res.status.enabled));
+    }
+    getLicenseAllowVersion(version) {
+        return this.http.get(LICENSE_FEATURE_GATE, {
+            params: {
+                check: 'version',
+                targetVersion: version,
+            },
+        });
+    }
+    getEnterpriseSupport(product) {
+        return this.http.get(`${API_GATEWAY}/fg/v1/featuregates/enterprise-support`, {
+            params: product && {
+                product,
+            },
+        });
+    }
+    static { this.ɵfac = function LicenseApiService_Factory(t) { return new (t || LicenseApiService)(i0.ɵɵinject(i1.HttpClient)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: LicenseApiService, factory: LicenseApiService.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LicenseApiService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], function () { return [{ type: i1.HttpClient }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/license/license-error/component.mjs

@@ -0,0 +1,113 @@
+/**
+ * @packageDocumentation
+ * @module license
+ */
+import { ChangeDetectionStrategy, Component, Inject } from '@angular/core';
+import { Router } from '@angular/router';
+import { tap } from 'rxjs';
+import { Reason } from '../../page-guard/public-api';
+import { TranslateService } from '../../translate/public-api';
+import { LICENSE_PRODUCT_NAME_TOKEN, LicenseService } from '../license.service';
+import { LicenseStatus } from '../license.type';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../license.service";
+import * as i3 from "../../translate/public-api";
+function LicenseErrorComponent_ng_container_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵprojection(1);
+    i0.ɵɵelementContainerEnd();
+} }
+function LicenseErrorComponent_div_2_ng_container_7_a_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "a", 6)(1, "button", 7);
+    i0.ɵɵtext(2);
+    i0.ɵɵpipe(3, "pure");
+    i0.ɵɵpipe(4, "async");
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    const ctx_r3 = i0.ɵɵnextContext(3);
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind3(3, 1, i0.ɵɵpipeBind1(4, 5, ctx_r3.errorStatus$), ctx_r3.getButtonText, ctx_r3.translate.locale), " ");
+} }
+function LicenseErrorComponent_div_2_ng_container_7_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵtemplate(1, LicenseErrorComponent_div_2_ng_container_7_a_1_Template, 5, 7, "a", 5);
+    i0.ɵɵpipe(2, "pure");
+    i0.ɵɵpipe(3, "async");
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind2(2, 1, i0.ɵɵpipeBind1(3, 4, ctx_r2.errorStatus$), ctx_r2.shouldShowImport));
+} }
+function LicenseErrorComponent_div_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 2)(1, "acl-page-guard", 3);
+    i0.ɵɵpipe(2, "translate");
+    i0.ɵɵpipe(3, "pure");
+    i0.ɵɵpipe(4, "async");
+    i0.ɵɵpipe(5, "pure");
+    i0.ɵɵpipe(6, "async");
+    i0.ɵɵtemplate(7, LicenseErrorComponent_div_2_ng_container_7_Template, 4, 6, "ng-container", 4);
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("allowed", false)("reason", ctx_r1.Reason.LicenseAbnormal)("title", i0.ɵɵpipeBind1(2, 4, i0.ɵɵpipeBind2(3, 6, i0.ɵɵpipeBind1(4, 9, ctx_r1.errorStatus$), ctx_r1.getErrorTitle)))("description", i0.ɵɵpipeBind3(5, 11, i0.ɵɵpipeBind1(6, 15, ctx_r1.errorStatus$), ctx_r1.getErrorContent, ctx_r1.translate.locale));
+} }
+const _c0 = ["*"];
+const LICENSE_ERROR_TITLE_MAPPER = {
+    unauthorized: 'no_available_license_title',
+    expired: 'expired_license',
+    no_permission: 'no_permission_license',
+};
+export class LicenseErrorComponent {
+    constructor(router, licenseService, translate, productName) {
+        this.router = router;
+        this.licenseService = licenseService;
+        this.translate = translate;
+        this.productName = productName;
+        this.Reason = Reason;
+        this.errorStatus$ = this.licenseService.status$.pipe(
+        // in case user input license-error url
+        tap(status => {
+            if (status === LicenseStatus.AUTHORIZED) {
+                this.router.navigateByUrl('/');
+            }
+        }));
+        this.LicenseStatus = LicenseStatus;
+        this.getErrorContent = this.getErrorContent.bind(this);
+        this.getButtonText = this.getButtonText.bind(this);
+    }
+    getErrorTitle(status) {
+        return LICENSE_ERROR_TITLE_MAPPER[status];
+    }
+    getErrorContent(status, _locale) {
+        return status === LicenseStatus.NO_PERMISSION
+            ? this.translate.get('no_permission_license_hint')
+            : status === LicenseStatus.UNAUTHORIZED
+                ? this.translate.get('license_unauthorized_hint')
+                : this.translate.get('license_error_hint', { product: this.productName });
+    }
+    shouldShowImport(status) {
+        return status !== LicenseStatus.NO_PERMISSION;
+    }
+    getButtonText(status, _locale) {
+        return this.translate.get(status === LicenseStatus.UNAUTHORIZED ? 'show_license' : 'import_now');
+    }
+    static { this.ɵfac = function LicenseErrorComponent_Factory(t) { return new (t || LicenseErrorComponent)(i0.ɵɵdirectiveInject(i1.Router), i0.ɵɵdirectiveInject(i2.LicenseService), i0.ɵɵdirectiveInject(i3.TranslateService), i0.ɵɵdirectiveInject(LICENSE_PRODUCT_NAME_TOKEN)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LicenseErrorComponent, selectors: [["acl-license-error"]], ngContentSelectors: _c0, decls: 3, vars: 0, consts: [[4, "aclPageHeader"], ["class", "layout-page-content", 4, "aclPageContent"], [1, "layout-page-content"], [3, "allowed", "reason", "title", "description"], [4, "aclPageGuardOperation"], ["href", "/console-platform/manage-platform/platform-setting/license", "target", "_blank", "noopener", "", "noreferrer", "", 4, "ngIf"], ["href", "/console-platform/manage-platform/platform-setting/license", "target", "_blank", "noopener", "", "noreferrer", ""], ["aui-button", "primary"]], template: function LicenseErrorComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵelementStart(0, "acl-page");
+            i0.ɵɵtemplate(1, LicenseErrorComponent_ng_container_1_Template, 2, 0, "ng-container", 0);
+            i0.ɵɵtemplate(2, LicenseErrorComponent_div_2_Template, 8, 17, "div", 1);
+            i0.ɵɵelementEnd();
+        } }, styles: [".layout-page-content[_ngcontent-%COMP%]{height:calc(100vh - var(--acl-page-header-height) - (20px * 2))}.error-page__wrapper[_ngcontent-%COMP%]{height:100%;display:flex;flex-direction:column;align-items:center}.error-page__wrapper[_ngcontent-%COMP%] > img[_ngcontent-%COMP%]{margin-top:102px;width:160px;height:160px}.error-page__title[_ngcontent-%COMP%]{font-size:18px;margin-top:16px}.error-page__content[_ngcontent-%COMP%]{color:rgb(var(--aui-color-help-text));margin-top:8px;margin-bottom:16px}"], changeDetection: 0 }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LicenseErrorComponent, [{
+        type: Component,
+        args: [{ selector: 'acl-license-error', changeDetection: ChangeDetectionStrategy.OnPush, template: "<acl-page>\n  <ng-container *aclPageHeader>\n    <ng-content></ng-content>\n  </ng-container>\n  <div\n    *aclPageContent\n    class=\"layout-page-content\"\n  >\n    <acl-page-guard\n      [allowed]=\"false\"\n      [reason]=\"Reason.LicenseAbnormal\"\n      [title]=\"errorStatus$ | async | pure: getErrorTitle | translate\"\n      [description]=\"\n        errorStatus$ | async | pure: getErrorContent:translate.locale\n      \"\n    >\n      <ng-container *aclPageGuardOperation>\n        <a\n          href=\"/console-platform/manage-platform/platform-setting/license\"\n          target=\"_blank\"\n          *ngIf=\"errorStatus$ | async | pure: shouldShowImport\"\n          noopener\n          noreferrer\n        >\n          <button aui-button=\"primary\">\n            {{ errorStatus$ | async | pure: getButtonText:translate.locale }}\n          </button>\n        </a>\n      </ng-container>\n    </acl-page-guard>\n  </div>\n</acl-page>\n", styles: [".layout-page-content{height:calc(100vh - var(--acl-page-header-height) - (20px * 2))}.error-page__wrapper{height:100%;display:flex;flex-direction:column;align-items:center}.error-page__wrapper>img{margin-top:102px;width:160px;height:160px}.error-page__title{font-size:18px;margin-top:16px}.error-page__content{color:rgb(var(--aui-color-help-text));margin-top:8px;margin-bottom:16px}\n"] }]
+    }], function () { return [{ type: i1.Router }, { type: i2.LicenseService }, { type: i3.TranslateService }, { type: undefined, decorators: [{
+                type: Inject,
+                args: [LICENSE_PRODUCT_NAME_TOKEN]
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/license/license-error/module.mjs

@@ -0,0 +1,55 @@
+/**
+ * @packageDocumentation
+ * @module license
+ */
+import { ButtonModule } from '@alauda/ui';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { CoreModule } from '../../core/public-api';
+import { PageGuardModule } from '../../page-guard/public-api';
+import { PageModule } from '../../page-scaffold';
+import { TranslateModule } from '../../translate/public-api';
+import { LicenseErrorComponent } from './component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../page-scaffold/page/page.component";
+import * as i2 from "../../page-scaffold/page/helper-directives";
+import * as i3 from "@angular/common";
+import * as i4 from "@alauda/ui";
+import * as i5 from "../../effect-directive/e2e-attribute-binding.directive";
+import * as i6 from "../../page-guard/component/component";
+import * as i7 from "../../page-guard/component/helper-directives";
+import * as i8 from "../../translate/translate.pipe";
+import * as i9 from "../../scm/pure-pipe/pure.pipe";
+export class LicenseErrorModule {
+    static { this.ɵfac = function LicenseErrorModule_Factory(t) { return new (t || LicenseErrorModule)(); }; }
+    static { this.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: LicenseErrorModule }); }
+    static { this.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [PageModule,
+            CommonModule,
+            ButtonModule,
+            TranslateModule,
+            CoreModule,
+            PageGuardModule] }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LicenseErrorModule, [{
+        type: NgModule,
+        args: [{
+                declarations: [LicenseErrorComponent],
+                imports: [
+                    PageModule,
+                    CommonModule,
+                    ButtonModule,
+                    TranslateModule,
+                    CoreModule,
+                    PageGuardModule,
+                ],
+                exports: [LicenseErrorComponent],
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(LicenseErrorModule, { declarations: [LicenseErrorComponent], imports: [PageModule,
+        CommonModule,
+        ButtonModule,
+        TranslateModule,
+        CoreModule,
+        PageGuardModule], exports: [LicenseErrorComponent] }); })();
+i0.ɵɵsetComponentScope(LicenseErrorComponent, [i1.PageComponent, i2.PageHeaderDirective, i2.PageContentDirective, i3.NgIf, i4.ButtonComponent, i5.E2eAttributeBindingDirective, i6.PageGuardComponent, i7.PageGuardOperationDirective], [i3.AsyncPipe, i8.TranslatePipe, i9.PurePipe]);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/license/license.guard.mjs

@@ -0,0 +1,54 @@
+/**
+ * @packageDocumentation
+ * @module license
+ */
+import { Inject, Injectable, InjectionToken } from '@angular/core';
+import { of, catchError, map } from 'rxjs';
+import { ABNORMAL_EMPTY_URL_TOKEN } from '../authorization/guard.service';
+import { SilentlyNavigateService } from '../core/services';
+import { LicenseService } from './license.service';
+import { LicenseStatus } from './license.type';
+import * as i0 from "@angular/core";
+import * as i1 from "../core/services";
+import * as i2 from "./license.service";
+export const DEFAULT_LICENSE_ERROR_URL = 'license-error';
+export function defaultLicenseErrorUrlFactory() {
+    return DEFAULT_LICENSE_ERROR_URL;
+}
+export const LICENSE_ERROR_URL_TOKEN = new InjectionToken('license_error_url', { providedIn: 'root', factory: defaultLicenseErrorUrlFactory });
+export class LicenseGuardService {
+    constructor(errorUrl, emptyUrl, silentlyNavigate, licenseService) {
+        this.errorUrl = errorUrl;
+        this.emptyUrl = emptyUrl;
+        this.silentlyNavigate = silentlyNavigate;
+        this.licenseService = licenseService;
+    }
+    canActivate(_route, state) {
+        return this.licenseService.status$.pipe(map(status => {
+            if (status === LicenseStatus.AUTHORIZED) {
+                return true;
+            }
+            this.silentlyNavigate.navigate(state.url, this.errorUrl);
+            return false;
+        }), catchError(() => {
+            this.silentlyNavigate.navigate(state.url, this.emptyUrl);
+            return of(false);
+        }));
+    }
+    canActivateChild(route, state) {
+        return this.canActivate(route, state);
+    }
+    static { this.ɵfac = function LicenseGuardService_Factory(t) { return new (t || LicenseGuardService)(i0.ɵɵinject(LICENSE_ERROR_URL_TOKEN), i0.ɵɵinject(ABNORMAL_EMPTY_URL_TOKEN), i0.ɵɵinject(i1.SilentlyNavigateService), i0.ɵɵinject(i2.LicenseService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: LicenseGuardService, factory: LicenseGuardService.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LicenseGuardService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], function () { return [{ type: undefined, decorators: [{
+                type: Inject,
+                args: [LICENSE_ERROR_URL_TOKEN]
+            }] }, { type: undefined, decorators: [{
+                type: Inject,
+                args: [ABNORMAL_EMPTY_URL_TOKEN]
+            }] }, { type: i1.SilentlyNavigateService }, { type: i2.LicenseService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/license/license.service.mjs

@@ -0,0 +1,53 @@
+/**
+ * @packageDocumentation
+ * @module license
+ */
+import { HttpClient } from '@angular/common/http';
+import { Inject, Injectable, InjectionToken } from '@angular/core';
+import { catchError, map, of, shareReplay } from 'rxjs';
+import { K8sUtilService } from '../core/public-api';
+import { formatProductName, LICENSE_FEATURE_GATE } from './license-api';
+import { LicenseProductName, LicenseStatus } from './license.type';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../core/public-api";
+import * as i3 from "./license.type";
+// each platform inject this token to specify product name
+export const LICENSE_PRODUCT_NAME_TOKEN = new InjectionToken('product_name');
+const FAILED_STATUS_MAPPER = {
+    Expired: LicenseStatus.EXPIRED,
+    Forbidden: LicenseStatus.NO_PERMISSION,
+    NotExist: LicenseStatus.UNAUTHORIZED,
+};
+export class LicenseService {
+    constructor(productName, http, k8sUtil) {
+        this.productName = productName;
+        this.http = http;
+        this.k8sUtil = k8sUtil;
+        this.status$ = this.getStatus();
+    }
+    getStatus() {
+        return this.http
+            .get(LICENSE_FEATURE_GATE, {
+            params: { product: formatProductName(this.productName) },
+        })
+            .pipe(catchError(() => of(null)), map(featureGate => {
+            if (featureGate?.status?.enabled) {
+                return LicenseStatus.AUTHORIZED;
+            }
+            const annotation = this.k8sUtil.getAnnotation(featureGate, 'reason', 'license');
+            return ((annotation && FAILED_STATUS_MAPPER[annotation]) ||
+                LicenseStatus.INVALID);
+        }), shareReplay(1));
+    }
+    static { this.ɵfac = function LicenseService_Factory(t) { return new (t || LicenseService)(i0.ɵɵinject(LICENSE_PRODUCT_NAME_TOKEN), i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.K8sUtilService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: LicenseService, factory: LicenseService.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LicenseService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], function () { return [{ type: i3.LicenseProductName, decorators: [{
+                type: Inject,
+                args: [LICENSE_PRODUCT_NAME_TOKEN]
+            }] }, { type: i1.HttpClient }, { type: i2.K8sUtilService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/license/license.type.mjs

@@ -0,0 +1,24 @@
+/**
+ * @packageDocumentation
+ * @module license
+ */
+export var LicenseStatus;
+(function (LicenseStatus) {
+    LicenseStatus["EXPIRED"] = "expired";
+    LicenseStatus["UNAUTHORIZED"] = "unauthorized";
+    LicenseStatus["AUTHORIZED"] = "authorized";
+    LicenseStatus["NO_PERMISSION"] = "no_permission";
+    LicenseStatus["INVALID"] = "invalid";
+})(LicenseStatus || (LicenseStatus = {}));
+// 支持证书功能的产品名称
+// reference: http://confluence.alauda.cn/pages/viewpage.action?pageId=61903707
+export var LicenseProductName;
+(function (LicenseProductName) {
+    LicenseProductName["CONTAINER_PLATFORM"] = "Container Platform";
+    LicenseProductName["DEVOPS"] = "DevOps";
+    LicenseProductName["SERVICE_MESH"] = "Service Mesh";
+    LicenseProductName["MACHINE_LEARNING"] = "Machine Learning";
+    LicenseProductName["API_MANAGEMENT_PLATFORM"] = "API Management Platform";
+    LicenseProductName["DATA_SERVICES"] = "Data Services";
+})(LicenseProductName || (LicenseProductName = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGljZW5zZS50eXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGlicy9jb21tb24vc3JjL2xpY2Vuc2UvbGljZW5zZS50eXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7R0FHRztBQUVILE1BQU0sQ0FBTixJQUFZLGFBTVg7QUFORCxXQUFZLGFBQWE7SUFDdkIsb0NBQW1CLENBQUE7SUFDbkIsOENBQTZCLENBQUE7SUFDN0IsMENBQXlCLENBQUE7SUFDekIsZ0RBQStCLENBQUE7SUFDL0Isb0NBQW1CLENBQUE7QUFDckIsQ0FBQyxFQU5XLGFBQWEsS0FBYixhQUFhLFFBTXhCO0FBRUQsY0FBYztBQUNkLCtFQUErRTtBQUMvRSxNQUFNLENBQU4sSUFBWSxrQkFPWDtBQVBELFdBQVksa0JBQWtCO0lBQzVCLCtEQUF5QyxDQUFBO0lBQ3pDLHVDQUFpQixDQUFBO0lBQ2pCLG1EQUE2QixDQUFBO0lBQzdCLDJEQUFxQyxDQUFBO0lBQ3JDLHlFQUFtRCxDQUFBO0lBQ25ELHFEQUErQixDQUFBO0FBQ2pDLENBQUMsRUFQVyxrQkFBa0IsS0FBbEIsa0JBQWtCLFFBTzdCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAcGFja2FnZURvY3VtZW50YXRpb25cbiAqIEBtb2R1bGUgbGljZW5zZVxuICovXG5cbmV4cG9ydCBlbnVtIExpY2Vuc2VTdGF0dXMge1xuICBFWFBJUkVEID0gJ2V4cGlyZWQnLFxuICBVTkFVVEhPUklaRUQgPSAndW5hdXRob3JpemVkJyxcbiAgQVVUSE9SSVpFRCA9ICdhdXRob3JpemVkJyxcbiAgTk9fUEVSTUlTU0lPTiA9ICdub19wZXJtaXNzaW9uJyxcbiAgSU5WQUxJRCA9ICdpbnZhbGlkJyxcbn1cblxuLy8g5pSv5oyB6K+B5Lmm5Yqf6IO955qE5Lqn5ZOB5ZCN56ewXG4vLyByZWZlcmVuY2U6IGh0dHA6Ly9jb25mbHVlbmNlLmFsYXVkYS5jbi9wYWdlcy92aWV3cGFnZS5hY3Rpb24/cGFnZUlkPTYxOTAzNzA3XG5leHBvcnQgZW51bSBMaWNlbnNlUHJvZHVjdE5hbWUge1xuICBDT05UQUlORVJfUExBVEZPUk0gPSAnQ29udGFpbmVyIFBsYXRmb3JtJyxcbiAgREVWT1BTID0gJ0Rldk9wcycsXG4gIFNFUlZJQ0VfTUVTSCA9ICdTZXJ2aWNlIE1lc2gnLFxuICBNQUNISU5FX0xFQVJOSU5HID0gJ01hY2hpbmUgTGVhcm5pbmcnLFxuICBBUElfTUFOQUdFTUVOVF9QTEFURk9STSA9ICdBUEkgTWFuYWdlbWVudCBQbGF0Zm9ybScsXG4gIERBVEFfU0VSVklDRVMgPSAnRGF0YSBTZXJ2aWNlcycsXG59XG4iXX0=

package/esm2022/license/public-api.mjs

@@ -0,0 +1,12 @@
+/**
+ * @packageDocumentation
+ * @module license
+ * @preferred
+ */
+export * from './license-api';
+export * from './license.guard';
+export * from './license.service';
+export * from './license.type';
+export * from './license-error/component';
+export * from './license-error/module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9saWNlbnNlL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUVILGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyx3QkFBd0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQHBhY2thZ2VEb2N1bWVudGF0aW9uXG4gKiBAbW9kdWxlIGxpY2Vuc2VcbiAqIEBwcmVmZXJyZWRcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2xpY2Vuc2UtYXBpJztcbmV4cG9ydCAqIGZyb20gJy4vbGljZW5zZS5ndWFyZCc7XG5leHBvcnQgKiBmcm9tICcuL2xpY2Vuc2Uuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpY2Vuc2UudHlwZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpY2Vuc2UtZXJyb3IvY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGljZW5zZS1lcnJvci9tb2R1bGUnO1xuIl19

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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