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

package/esm2022/k8s-shared/update-key-value-dialog/component.mjs

@@ -0,0 +1,111 @@
+import { ButtonModule, DIALOG_DATA, DialogModule, DialogRef, MessageService, } from '@alauda/ui';
+import { AsyncPipe } from '@angular/common';
+import { ChangeDetectionStrategy, Component, Inject, Optional, } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { cloneDeep, isEqual } from 'lodash-es';
+import { BehaviorSubject, EMPTY, Subject, from, catchError, switchMap, takeUntil, tap, } from 'rxjs';
+import { KeyValueFormTableComponent } from '../../array-form-table/key-value-form/component';
+import { TranslateModule, TranslateService } from '../../translate/public-api';
+import * as i0 from "@angular/core";
+import * as i1 from "@alauda/ui";
+import * as i2 from "../../translate/public-api";
+import * as i3 from "@angular/forms";
+import * as i4 from "../../translate/translate.pipe";
+export class UpdateKeyValueDialogComponent {
+    constructor(dialogRef, message, translate, data = {}) {
+        this.dialogRef = dialogRef;
+        this.message = message;
+        this.translate = translate;
+        this.data = data;
+        this.onUpdate$$ = new Subject();
+        this.submitting$$ = new BehaviorSubject(false);
+        this.destroy$$ = new Subject();
+        this.originalKeyValues = this.data.keyValues || {};
+        this.keyValues = cloneDeep(this.originalKeyValues);
+    }
+    ngOnInit() {
+        const { context, onUpdate, updateSuccessMsg, updateFailMsg, showMessage } = this.data;
+        if (!onUpdate) {
+            return;
+        }
+        this.onUpdate$$
+            .pipe(takeUntil(this.destroy$$), tap(() => this.submitting$$.next(true)), switchMap(() => {
+            // nothing changed
+            if (isEqual(this.originalKeyValues, this.keyValues)) {
+                this.dialogRef.close();
+                return EMPTY;
+            }
+            return from(onUpdate.call(context, this.keyValues)).pipe(tap(() => {
+                if (showMessage ?? true) {
+                    this.message.success(this.translate.get(updateSuccessMsg || 'update_succeeded'));
+                }
+                this.submitting$$.next(false);
+                this.dialogRef.close();
+            }), catchError(() => {
+                if (showMessage ?? true) {
+                    this.message.error(this.translate.get(updateFailMsg || 'update_failed'));
+                }
+                this.submitting$$.next(false);
+                return EMPTY;
+            }));
+        }))
+            .subscribe();
+    }
+    ngOnDestroy() {
+        this.destroy$$.next();
+        this.destroy$$.complete();
+    }
+    static { this.ɵfac = function UpdateKeyValueDialogComponent_Factory(t) { return new (t || UpdateKeyValueDialogComponent)(i0.ɵɵdirectiveInject(i1.DialogRef), i0.ɵɵdirectiveInject(i1.MessageService), i0.ɵɵdirectiveInject(i2.TranslateService), i0.ɵɵdirectiveInject(DIALOG_DATA, 8)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: UpdateKeyValueDialogComponent, selectors: [["ng-component"]], standalone: true, features: [i0.ɵɵStandaloneFeature], decls: 16, vars: 19, consts: [[3, "ngSubmit"], ["ngForm", "ngForm"], ["name", "key-values", 3, "ngModel", "readonlyKeys", "validator", "errorMapper", "ngModelChange"], ["aui-button", "primary", 3, "loading", "disabled", "click"], ["aui-button", "", "type", "button", "auiDialogClose", ""]], template: function UpdateKeyValueDialogComponent_Template(rf, ctx) { if (rf & 1) {
+            const _r1 = i0.ɵɵgetCurrentView();
+            i0.ɵɵelementStart(0, "aui-dialog-header");
+            i0.ɵɵtext(1);
+            i0.ɵɵpipe(2, "translate");
+            i0.ɵɵelementEnd();
+            i0.ɵɵelementStart(3, "aui-dialog-content")(4, "form", 0, 1);
+            i0.ɵɵlistener("ngSubmit", function UpdateKeyValueDialogComponent_Template_form_ngSubmit_4_listener() { i0.ɵɵrestoreView(_r1); const _r0 = i0.ɵɵreference(5); return i0.ɵɵresetView(_r0.valid && ctx.onUpdate$$.next()); });
+            i0.ɵɵelementStart(6, "acl-key-value-form-table", 2);
+            i0.ɵɵlistener("ngModelChange", function UpdateKeyValueDialogComponent_Template_acl_key_value_form_table_ngModelChange_6_listener($event) { return ctx.keyValues = $event; });
+            i0.ɵɵelementEnd()()();
+            i0.ɵɵelementStart(7, "aui-dialog-footer")(8, "button", 3);
+            i0.ɵɵlistener("click", function UpdateKeyValueDialogComponent_Template_button_click_8_listener() { i0.ɵɵrestoreView(_r1); const _r0 = i0.ɵɵreference(5); return i0.ɵɵresetView(_r0.onSubmit(null)); });
+            i0.ɵɵpipe(9, "async");
+            i0.ɵɵpipe(10, "async");
+            i0.ɵɵtext(11);
+            i0.ɵɵpipe(12, "translate");
+            i0.ɵɵelementEnd();
+            i0.ɵɵelementStart(13, "button", 4);
+            i0.ɵɵtext(14);
+            i0.ɵɵpipe(15, "translate");
+            i0.ɵɵelementEnd()();
+        } if (rf & 2) {
+            i0.ɵɵadvance(1);
+            i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(2, 9, ctx.data.title || "update"), "\n");
+            i0.ɵɵadvance(5);
+            i0.ɵɵproperty("ngModel", ctx.keyValues)("readonlyKeys", ctx.data.readonlyKeys)("validator", ctx.data.validator)("errorMapper", ctx.data.errorMapper);
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("loading", i0.ɵɵpipeBind1(9, 11, ctx.submitting$$))("disabled", i0.ɵɵpipeBind1(10, 13, ctx.submitting$$));
+            i0.ɵɵadvance(3);
+            i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(12, 15, ctx.data.confirmButton || "update"), " ");
+            i0.ɵɵadvance(3);
+            i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(15, 17, "cancel"), " ");
+        } }, dependencies: [DialogModule, i1.DialogHeaderComponent, i1.DialogContentComponent, i1.DialogFooterComponent, i1.DialogCloseDirective, KeyValueFormTableComponent,
+            FormsModule, i3.ɵNgNoValidate, i3.NgControlStatus, i3.NgControlStatusGroup, i3.NgModel, i3.NgForm, TranslateModule, i4.TranslatePipe, ButtonModule, i1.ButtonComponent, AsyncPipe], encapsulation: 2, changeDetection: 0 }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(UpdateKeyValueDialogComponent, [{
+        type: Component,
+        args: [{ standalone: true, preserveWhitespaces: false, changeDetection: ChangeDetectionStrategy.OnPush, imports: [
+                    DialogModule,
+                    KeyValueFormTableComponent,
+                    FormsModule,
+                    TranslateModule,
+                    ButtonModule,
+                    AsyncPipe,
+                ], template: "<aui-dialog-header>\n  {{ data.title || 'update' | translate }}\n</aui-dialog-header>\n<aui-dialog-content>\n  <form\n    #ngForm=\"ngForm\"\n    (ngSubmit)=\"ngForm.valid && onUpdate$$.next()\"\n  >\n    <acl-key-value-form-table\n      [(ngModel)]=\"keyValues\"\n      [readonlyKeys]=\"data.readonlyKeys\"\n      [validator]=\"data.validator\"\n      [errorMapper]=\"data.errorMapper\"\n      name=\"key-values\"\n    ></acl-key-value-form-table>\n  </form>\n</aui-dialog-content>\n<aui-dialog-footer>\n  <button\n    aui-button=\"primary\"\n    [loading]=\"submitting$$ | async\"\n    [disabled]=\"submitting$$ | async\"\n    (click)=\"ngForm.onSubmit(null)\"\n  >\n    {{ data.confirmButton || 'update' | translate }}\n  </button>\n  <button\n    aui-button\n    type=\"button\"\n    auiDialogClose\n  >\n    {{ 'cancel' | translate }}\n  </button>\n</aui-dialog-footer>\n" }]
+    }], function () { return [{ type: i1.DialogRef }, { type: i1.MessageService }, { type: i2.TranslateService }, { type: undefined, decorators: [{
+                type: Optional
+            }, {
+                type: Inject,
+                args: [DIALOG_DATA]
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component.js","sourceRoot":"","sources":["../../../../../../libs/common/src/k8s-shared/update-key-value-dialog/component.ts","../../../../../../libs/common/src/k8s-shared/update-key-value-dialog/template.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ButtonModule,\n  DIALOG_DATA,\n  DialogModule,\n  DialogRef,\n  MessageService,\n} from '@alauda/ui';\nimport { AsyncPipe } from '@angular/common';\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  Inject,\n  OnDestroy,\n  OnInit,\n  Optional,\n} from '@angular/core';\nimport { FormsModule, ValidatorFn } from '@angular/forms';\nimport { cloneDeep, isEqual } from 'lodash-es';\nimport {\n  BehaviorSubject,\n  EMPTY,\n  Observable,\n  Subject,\n  from,\n  catchError,\n  switchMap,\n  takeUntil,\n  tap,\n} from 'rxjs';\n\nimport { KeyValueFormTableComponent } from '../../array-form-table/key-value-form/component';\nimport { StringMap } from '../../core/public-api';\nimport { TranslateModule, TranslateService } from '../../translate/public-api';\n\nexport interface UpdateKeyValueDialogData<\n  R = unknown,\n  Context = unknown,\n  T = StringMap,\n> {\n  title?: string;\n  keyValues?: T;\n  confirmButton?: string;\n  readonlyKeys?: Array<string | RegExp>;\n  onUpdate?: (keyValues: T) => Promise<R> | Observable<R>;\n  context?: Context;\n  updateSuccessMsg?: string;\n  updateFailMsg?: string;\n  validator?: {\n    key: ValidatorFn | ValidatorFn[];\n    value?: ValidatorFn | ValidatorFn[];\n  };\n  errorMapper?: Record<string, unknown>;\n  showMessage?: boolean;\n}\n\n@Component({\n  standalone: true,\n  templateUrl: './template.html',\n  preserveWhitespaces: false,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  imports: [\n    DialogModule,\n    KeyValueFormTableComponent,\n    FormsModule,\n    TranslateModule,\n    ButtonModule,\n    AsyncPipe,\n  ],\n})\nexport class UpdateKeyValueDialogComponent<\n  R = unknown,\n  Context = unknown,\n  T = StringMap,\n> implements OnInit, OnDestroy\n{\n  readonly onUpdate$$ = new Subject<void>();\n\n  readonly submitting$$ = new BehaviorSubject(false);\n\n  private readonly originalKeyValues: T;\n\n  keyValues: T;\n\n  private readonly destroy$$ = new Subject<void>();\n\n  constructor(\n    private readonly dialogRef: DialogRef<\n      UpdateKeyValueDialogComponent<R, Context, T>,\n      UpdateKeyValueDialogData<R, Context, T>\n    >,\n    private readonly message: MessageService,\n    private readonly translate: TranslateService,\n    @Optional()\n    @Inject(DIALOG_DATA)\n    public data: UpdateKeyValueDialogData<R, Context, T> = {},\n  ) {\n    this.originalKeyValues = this.data.keyValues || ({} as T);\n    this.keyValues = cloneDeep(this.originalKeyValues);\n  }\n\n  ngOnInit() {\n    const { context, onUpdate, updateSuccessMsg, updateFailMsg, showMessage } =\n      this.data;\n    if (!onUpdate) {\n      return;\n    }\n    this.onUpdate$$\n      .pipe(\n        takeUntil(this.destroy$$),\n        tap(() => this.submitting$$.next(true)),\n        switchMap(() => {\n          // nothing changed\n          if (isEqual(this.originalKeyValues, this.keyValues)) {\n            this.dialogRef.close();\n            return EMPTY;\n          }\n          return from(onUpdate.call(context, this.keyValues)).pipe(\n            tap(() => {\n              if (showMessage ?? true) {\n                this.message.success(\n                  this.translate.get(updateSuccessMsg || 'update_succeeded'),\n                );\n              }\n              this.submitting$$.next(false);\n              this.dialogRef.close();\n            }),\n            catchError(() => {\n              if (showMessage ?? true) {\n                this.message.error(\n                  this.translate.get(updateFailMsg || 'update_failed'),\n                );\n              }\n              this.submitting$$.next(false);\n              return EMPTY;\n            }),\n          );\n        }),\n      )\n      .subscribe();\n  }\n\n  ngOnDestroy() {\n    this.destroy$$.next();\n    this.destroy$$.complete();\n  }\n}\n","<aui-dialog-header>\n  {{ data.title || 'update' | translate }}\n</aui-dialog-header>\n<aui-dialog-content>\n  <form\n    #ngForm=\"ngForm\"\n    (ngSubmit)=\"ngForm.valid && onUpdate$$.next()\"\n  >\n    <acl-key-value-form-table\n      [(ngModel)]=\"keyValues\"\n      [readonlyKeys]=\"data.readonlyKeys\"\n      [validator]=\"data.validator\"\n      [errorMapper]=\"data.errorMapper\"\n      name=\"key-values\"\n    ></acl-key-value-form-table>\n  </form>\n</aui-dialog-content>\n<aui-dialog-footer>\n  <button\n    aui-button=\"primary\"\n    [loading]=\"submitting$$ | async\"\n    [disabled]=\"submitting$$ | async\"\n    (click)=\"ngForm.onSubmit(null)\"\n  >\n    {{ data.confirmButton || 'update' | translate }}\n  </button>\n  <button\n    aui-button\n    type=\"button\"\n    auiDialogClose\n  >\n    {{ 'cancel' | translate }}\n  </button>\n</aui-dialog-footer>\n"]}

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/public-api';
+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/public-api';
+import { LicenseService } from './license.service';
+import { LicenseStatus } from './license.type';
+import * as i0 from "@angular/core";
+import * as i1 from "../core/services/public-api";
+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