@alauda-fe/common 1.4.0 → 1.4.1

package/esm2022/effect-directive/event.directive.mjs

@@ -1,8 +1,19 @@
 import { __decorate, __metadata } from "tslib";
-import { Directive, Input } from '@angular/core';
+import { booleanAttribute, Directive, HostListener, Input, } from '@angular/core';
 import { isBoolean } from 'lodash-es';
 import { ValueHook } from '../core/utils/public-api';
 import * as i0 from "@angular/core";
+export var PreventHandler;
+(function (PreventHandler) {
+    PreventHandler["Contextmenu"] = "contextmenu";
+    PreventHandler["Paste"] = "paste";
+    PreventHandler["Cut"] = "cut";
+    PreventHandler["Copy"] = "copy";
+})(PreventHandler || (PreventHandler = {}));
+const handleEvent = (event, enable) => enable && event.preventDefault();
+/**
+ * 阻止点击事件
+ */
 export class PreventDirective {
     constructor() {
         this.prevent = true;
@@ -19,7 +30,6 @@ __decorate([
         args: [{
                 // eslint-disable-next-line @angular-eslint/directive-selector
                 selector: '[prevent]',
-                // eslint-disable-next-line @angular-eslint/no-host-metadata-property
                 host: {
                     click: 'prevent && $event.preventDefault()',
                 },
@@ -28,6 +38,9 @@ __decorate([
     }], null, { prevent: [{
             type: Input
         }] }); })();
+/**
+ * 阻止冒泡事件
+ */
 export class StopDirective {
     constructor() {
         this.stop = true;
@@ -44,7 +57,6 @@ __decorate([
         args: [{
                 // eslint-disable-next-line @angular-eslint/directive-selector
                 selector: '[stop]',
-                // eslint-disable-next-line @angular-eslint/no-host-metadata-property
                 host: {
                     click: 'stop && $event.stopPropagation()',
                 },
@@ -53,4 +65,67 @@ __decorate([
     }], null, { stop: [{
             type: Input
         }] }); })();
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * 阻止剪切板（拷贝、粘贴、剪切、右键菜单）等事件
+ *
+ * @example
+ *
+ * 阻止全部:
+ * ```
+ * <input aui-input aclPreventEvent>
+ * ```
+ * 自定义:
+ * ```
+ * <input aui-input [aclPreventEvent]="{copy: true, paste: true}">
+ * ```
+ */
+export class PreventClipboardDirective {
+    constructor() {
+        this.preventClipboardEvent = true;
+    }
+    isPreventEvent(action) {
+        if (typeof this.preventClipboardEvent === 'object') {
+            return !!this.preventClipboardEvent[action];
+        }
+        return booleanAttribute(this.preventClipboardEvent);
+    }
+    onContextmenu(event) {
+        handleEvent(event, this.isPreventEvent(PreventHandler.Contextmenu));
+    }
+    onCut(event) {
+        handleEvent(event, this.isPreventEvent(PreventHandler.Cut));
+    }
+    onPaste(event) {
+        handleEvent(event, this.isPreventEvent(PreventHandler.Paste));
+    }
+    onCopy(event) {
+        handleEvent(event, this.isPreventEvent(PreventHandler.Copy));
+    }
+    static { this.ɵfac = function PreventClipboardDirective_Factory(t) { return new (t || PreventClipboardDirective)(); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: PreventClipboardDirective, selectors: [["input", "aclPreventClipboardEvent", ""]], hostBindings: function PreventClipboardDirective_HostBindings(rf, ctx) { if (rf & 1) {
+            i0.ɵɵlistener("contextmenu", function PreventClipboardDirective_contextmenu_HostBindingHandler($event) { return ctx.onContextmenu($event); })("cut", function PreventClipboardDirective_cut_HostBindingHandler($event) { return ctx.onCut($event); })("paste", function PreventClipboardDirective_paste_HostBindingHandler($event) { return ctx.onPaste($event); })("copy", function PreventClipboardDirective_copy_HostBindingHandler($event) { return ctx.onCopy($event); });
+        } }, inputs: { preventClipboardEvent: [0, "aclPreventClipboardEvent", "preventClipboardEvent"] }, standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PreventClipboardDirective, [{
+        type: Directive,
+        args: [{
+                selector: 'input[aclPreventClipboardEvent]',
+                standalone: true,
+            }]
+    }], null, { preventClipboardEvent: [{
+            type: Input,
+            args: ['aclPreventClipboardEvent']
+        }], onContextmenu: [{
+            type: HostListener,
+            args: ['contextmenu', ['$event']]
+        }], onCut: [{
+            type: HostListener,
+            args: ['cut', ['$event']]
+        }], onPaste: [{
+            type: HostListener,
+            args: ['paste', ['$event']]
+        }], onCopy: [{
+            type: HostListener,
+            args: ['copy', ['$event']]
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/k8s-resource-list/footer/component.mjs

@@ -285,10 +285,12 @@ export class K8SResourceListFooterComponent extends ScrollBorderObserverDirectiv
             ? document.documentElement
             : this.scrollEl;
         // 当数据不够一屏时自动加载更多
-        const autoLoadOneScreen$ = this.list.loadState$.pipe(map(state => state.rawResponse), filter(res => !!res), debounceTime(50), takeWhile(res => (!!res.metadata?.continue &&
-            viewEl.scrollHeight - viewEl.clientHeight < this.bottomDistance) ||
-            (this.firstScrollLoad &&
-                this.list.snapshot.items?.length < this.firstScrollLoad)));
+        const autoLoadOneScreen$ = this.list.loadState$.pipe(map(state => state.rawResponse), filter(res => !!res), debounceTime(50), takeWhile(res => {
+            return ((!!res.metadata?.continue &&
+                viewEl.scrollHeight - viewEl.clientHeight < this.bottomDistance) ||
+                (this.firstScrollLoad &&
+                    (this.list.snapshot.items?.length || 0) < this.firstScrollLoad));
+        }));
         this.list.loadState$
             .pipe(filter(state => state.action === LoadAction.Reload), startWith(null), switchMap(() => concat(autoLoadOneScreen$, this.scrollBottomBorder)), 
         // list.rawResponse$ 会处理好 loading 等状态时的 loadMore 请求，但有错误时主要主动停止
@@ -366,4 +368,4 @@ __decorate([
                 }]
         }] }); })();
 (() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(K8SResourceListFooterComponent, { className: "K8SResourceListFooterComponent" }); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component.js","sourceRoot":"","sources":["../../../../../../libs/common/src/k8s-resource-list/footer/component.ts","../../../../../../libs/common/src/k8s-resource-list/footer/template.html"],"names":[],"mappings":"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","sourcesContent":["/**\n * @packageDocumentation\n * @module k8s-resource-list\n */\n\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  ContentChild,\n  Directive,\n  Input,\n  OnDestroy,\n  OnInit,\n  TemplateRef,\n  Injector,\n} from '@angular/core';\nimport {\n  Observable,\n  combineLatest,\n  concat,\n  debounceTime,\n  distinctUntilChanged,\n  filter,\n  map,\n  startWith,\n  switchMap,\n  take,\n  takeUntil,\n  takeWhile,\n} from 'rxjs';\n\nimport {\n  KubernetesResource,\n  KubernetesResourceList,\n  publishRef,\n  ScrollBorderObserverDirective,\n} from '../../core/public-api';\nimport { ObservableInput } from '../../core/utils/decorators';\nimport { TranslateService } from '../../translate/public-api';\nimport { LoadAction, StreamListLoader } from '../types';\n\n@Directive({\n  selector: '[aclK8sListFooterNoData]',\n})\nexport class K8sListFooterNoDataDirective {\n  constructor(public templateRef: TemplateRef<any>) {}\n}\n\n@Directive({\n  selector: '[aclK8sListFooterLoadingError]',\n})\nexport class K8sListFooterLoadingErrorDirective {\n  constructor(public templateRef: TemplateRef<any>) {}\n}\n\n@Component({\n  selector: 'acl-k8s-resource-list-footer',\n  templateUrl: 'template.html',\n  styleUrls: ['styles.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class K8SResourceListFooterComponent\n  extends ScrollBorderObserverDirective\n  implements OnInit, OnDestroy\n{\n  @Input() list: StreamListLoader<KubernetesResourceList, KubernetesResource>;\n\n  @Input() autoLoad = true;\n  @Input() backTop = true;\n  @Input() bottomDistance = 60;\n  @Input() resourceNameTranslated: string;\n  @Input() firstScrollLoad: number;\n\n  @ObservableInput()\n  resourceNameTranslated$: Observable<string>;\n\n  @Input() resourceName: string;\n\n  @ObservableInput()\n  resourceName$: Observable<string>;\n\n  @ContentChild(K8sListFooterNoDataDirective, {\n    read: TemplateRef,\n  })\n  noDataTemplate: TemplateRef<any>;\n\n  @ContentChild(K8sListFooterLoadingErrorDirective, {\n    read: TemplateRef,\n  })\n  loadingErrorTemplate: TemplateRef<any>;\n\n  isEmptyList$: Observable<boolean>;\n  noDataHint$: Observable<string>;\n  loadingErrorCode$: Observable<number>;\n\n  window = window;\n\n  constructor(\n    injector: Injector,\n    private readonly translate: TranslateService,\n  ) {\n    super(injector);\n    this.option = this.autoLoad ? '' : false;\n  }\n\n  override ngOnInit() {\n    super.ngOnInit();\n\n    this.loadingErrorCode$ = this.list.loadingError$.pipe(\n      map(\n        loadingError =>\n          loadingError && 'code' in loadingError && loadingError.code,\n      ),\n      distinctUntilChanged(),\n      publishRef(),\n    );\n\n    this.isEmptyList$ = combineLatest([\n      this.list.items$.pipe(map(items => items.length)),\n      this.list.hasMore$,\n      this.list.loading$,\n      this.list.loadingError$,\n    ]).pipe(\n      map(\n        ([length, hasMore, loading, loadingError]) =>\n          !(length || hasMore || loading || loadingError),\n      ),\n      distinctUntilChanged(),\n      publishRef(),\n    );\n\n    this.noDataHint$ = combineLatest([\n      this.list.rawResponse$,\n      this.resourceName$,\n      this.resourceNameTranslated$,\n      this.translate.locale$,\n    ]).pipe(\n      filter(([res]) => !!res),\n      map(([{ kind }, resourceName, resourceNameTranslated]) => {\n        if (resourceNameTranslated) {\n          return this.translate.get('no_named_data_hint', {\n            name: resourceNameTranslated,\n          });\n        }\n\n        if (resourceName || (kind?.endsWith('List') && kind.length > 4)) {\n          return this.translate.get('no_named_data_hint', {\n            name: this.translate.get(\n              resourceName ||\n                kind.slice(0, kind.lastIndexOf('List')).toLowerCase(),\n              null,\n              true,\n            ),\n          });\n        }\n        return this.translate.get('no_data');\n      }),\n    );\n\n    const viewEl =\n      this.scrollEl === window\n        ? document.documentElement\n        : (this.scrollEl as HTMLElement);\n\n    // 当数据不够一屏时自动加载更多\n    const autoLoadOneScreen$ = this.list.loadState$.pipe(\n      map(state => state.rawResponse),\n      filter(res => !!res),\n      debounceTime(50),\n      takeWhile(\n        res =>\n          (!!res.metadata?.continue &&\n            viewEl.scrollHeight - viewEl.clientHeight < this.bottomDistance) ||\n          (this.firstScrollLoad &&\n            this.list.snapshot.items?.length < this.firstScrollLoad),\n      ),\n    );\n    this.list.loadState$\n      .pipe(\n        filter(state => state.action === LoadAction.Reload),\n        startWith(null as void),\n        switchMap(() => concat(autoLoadOneScreen$, this.scrollBottomBorder)),\n        // list.rawResponse$ 会处理好 loading 等状态时的 loadMore 请求，但有错误时主要主动停止\n        filter(() => !this.list.snapshot.loadingError),\n        takeUntil(this.destroy$$),\n      )\n      .subscribe(() => {\n        this.list.loadMore();\n      });\n  }\n\n  retry() {\n    this.list.items$.pipe(take(1)).subscribe(items => {\n      if (items.length > 0) {\n        this.list.loadMore();\n      } else {\n        this.list.reload();\n      }\n    });\n  }\n}\n","<div\n  *ngIf=\"isEmptyList$ | async\"\n  class=\"empty-placeholder\"\n>\n  <ng-container *ngIf=\"noDataTemplate\">\n    <ng-template *ngTemplateOutlet=\"noDataTemplate\"></ng-template>\n  </ng-container>\n  <ng-container *ngIf=\"!noDataTemplate\">\n    {{ noDataHint$ | async }}\n  </ng-container>\n</div>\n\n<ng-container *ngIf=\"!(isEmptyList$ | async)\">\n  <div\n    class=\"table-placeholder\"\n    *ngIf=\"list.loadingError$ | async\"\n  >\n    @if (loadingErrorTemplate) {\n      <ng-template *ngTemplateOutlet=\"loadingErrorTemplate\"></ng-template>\n    } @else {\n      <ng-container *ngIf=\"![410, 403].includes(loadingErrorCode$ | async)\">\n        <span\n          >{{ 'error_loading_data' | translate }},{{\n            'please' | translate\n          }}</span\n        >\n        <button\n          aui-button=\"text\"\n          size=\"small\"\n          (click)=\"retry()\"\n        >\n          {{ ('retry' | translate).toLowerCase() }}\n        </button>\n      </ng-container>\n\n      <ng-container *ngIf=\"(loadingErrorCode$ | async) === 410\">\n        <span>\n          {{ 'list_data_has_expired' | translate }}, {{ 'please' | translate }}\n        </span>\n        <button\n          aui-button=\"text\"\n          size=\"small\"\n          (click)=\"list.reload()\"\n        >\n          {{ 'refresh' | translate }}\n        </button>\n        <span>{{ 'or' | translate }}</span>\n        <button\n          aui-button=\"text\"\n          size=\"small\"\n          (click)=\"list.loadMore()\"\n        >\n          {{ 'continue_load' | translate }}\n        </button>\n      </ng-container>\n\n      <ng-container *ngIf=\"(loadingErrorCode$ | async) === 403\">\n        <span>\n          {{ 'no_permission_description' | translate }}\n        </span>\n      </ng-container>\n    }\n  </div>\n\n  <ng-container *ngIf=\"!(list.loadingError$ | async)\">\n    <ng-container\n      *ngIf=\"{\n        loading: list.loading$ | async,\n        loadMore:\n          !autoLoad && !(list.loading$ | async) && list.hasMore$ | async,\n      } as meta\"\n    >\n      <div\n        class=\"table-placeholder\"\n        *ngIf=\"meta.loading\"\n      >\n        <aui-icon icon=\"spinner\"></aui-icon>\n        <span>{{ 'loading_please_wait' | translate }}</span>\n      </div>\n      <div\n        class=\"table-placeholder\"\n        *ngIf=\"meta.loadMore\"\n      >\n        <button\n          aui-button=\"text\"\n          size=\"small\"\n          (click)=\"list.loadMore()\"\n        >\n          {{ 'load_more' | translate }}\n        </button>\n      </div>\n      <div\n        class=\"table-last-row--empty\"\n        *ngIf=\"!meta.loadMore && !meta.loading\"\n      >\n        <div class=\"table-last-row--empty-inner\"></div>\n      </div>\n    </ng-container>\n  </ng-container>\n</ng-container>\n\n<aui-back-top\n  *ngIf=\"backTop\"\n  [target]=\"window\"\n></aui-back-top>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component.js","sourceRoot":"","sources":["../../../../../../libs/common/src/k8s-resource-list/footer/component.ts","../../../../../../libs/common/src/k8s-resource-list/footer/template.html"],"names":[],"mappings":"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","sourcesContent":["/**\n * @packageDocumentation\n * @module k8s-resource-list\n */\n\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  ContentChild,\n  Directive,\n  Input,\n  OnDestroy,\n  OnInit,\n  TemplateRef,\n  Injector,\n} from '@angular/core';\nimport {\n  Observable,\n  combineLatest,\n  concat,\n  debounceTime,\n  distinctUntilChanged,\n  filter,\n  map,\n  startWith,\n  switchMap,\n  take,\n  takeUntil,\n  takeWhile,\n} from 'rxjs';\n\nimport {\n  KubernetesResource,\n  KubernetesResourceList,\n  publishRef,\n  ScrollBorderObserverDirective,\n} from '../../core/public-api';\nimport { ObservableInput } from '../../core/utils/decorators';\nimport { TranslateService } from '../../translate/public-api';\nimport { LoadAction, StreamListLoader } from '../types';\n\n@Directive({\n  selector: '[aclK8sListFooterNoData]',\n})\nexport class K8sListFooterNoDataDirective {\n  constructor(public templateRef: TemplateRef<any>) {}\n}\n\n@Directive({\n  selector: '[aclK8sListFooterLoadingError]',\n})\nexport class K8sListFooterLoadingErrorDirective {\n  constructor(public templateRef: TemplateRef<any>) {}\n}\n\n@Component({\n  selector: 'acl-k8s-resource-list-footer',\n  templateUrl: 'template.html',\n  styleUrls: ['styles.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class K8SResourceListFooterComponent\n  extends ScrollBorderObserverDirective\n  implements OnInit, OnDestroy\n{\n  @Input() list: StreamListLoader<KubernetesResourceList, KubernetesResource>;\n\n  @Input() autoLoad = true;\n  @Input() backTop = true;\n  @Input() bottomDistance = 60;\n  @Input() resourceNameTranslated: string;\n  @Input() firstScrollLoad: number;\n\n  @ObservableInput()\n  resourceNameTranslated$: Observable<string>;\n\n  @Input() resourceName: string;\n\n  @ObservableInput()\n  resourceName$: Observable<string>;\n\n  @ContentChild(K8sListFooterNoDataDirective, {\n    read: TemplateRef,\n  })\n  noDataTemplate: TemplateRef<any>;\n\n  @ContentChild(K8sListFooterLoadingErrorDirective, {\n    read: TemplateRef,\n  })\n  loadingErrorTemplate: TemplateRef<any>;\n\n  isEmptyList$: Observable<boolean>;\n  noDataHint$: Observable<string>;\n  loadingErrorCode$: Observable<number>;\n\n  window = window;\n\n  constructor(\n    injector: Injector,\n    private readonly translate: TranslateService,\n  ) {\n    super(injector);\n    this.option = this.autoLoad ? '' : false;\n  }\n\n  override ngOnInit() {\n    super.ngOnInit();\n\n    this.loadingErrorCode$ = this.list.loadingError$.pipe(\n      map(\n        loadingError =>\n          loadingError && 'code' in loadingError && loadingError.code,\n      ),\n      distinctUntilChanged(),\n      publishRef(),\n    );\n\n    this.isEmptyList$ = combineLatest([\n      this.list.items$.pipe(map(items => items.length)),\n      this.list.hasMore$,\n      this.list.loading$,\n      this.list.loadingError$,\n    ]).pipe(\n      map(\n        ([length, hasMore, loading, loadingError]) =>\n          !(length || hasMore || loading || loadingError),\n      ),\n      distinctUntilChanged(),\n      publishRef(),\n    );\n\n    this.noDataHint$ = combineLatest([\n      this.list.rawResponse$,\n      this.resourceName$,\n      this.resourceNameTranslated$,\n      this.translate.locale$,\n    ]).pipe(\n      filter(([res]) => !!res),\n      map(([{ kind }, resourceName, resourceNameTranslated]) => {\n        if (resourceNameTranslated) {\n          return this.translate.get('no_named_data_hint', {\n            name: resourceNameTranslated,\n          });\n        }\n\n        if (resourceName || (kind?.endsWith('List') && kind.length > 4)) {\n          return this.translate.get('no_named_data_hint', {\n            name: this.translate.get(\n              resourceName ||\n                kind.slice(0, kind.lastIndexOf('List')).toLowerCase(),\n              null,\n              true,\n            ),\n          });\n        }\n        return this.translate.get('no_data');\n      }),\n    );\n\n    const viewEl =\n      this.scrollEl === window\n        ? document.documentElement\n        : (this.scrollEl as HTMLElement);\n\n    // 当数据不够一屏时自动加载更多\n    const autoLoadOneScreen$ = this.list.loadState$.pipe(\n      map(state => state.rawResponse),\n      filter(res => !!res),\n      debounceTime(50),\n      takeWhile(res => {\n        return (\n          (!!res.metadata?.continue &&\n            viewEl.scrollHeight - viewEl.clientHeight < this.bottomDistance) ||\n          (this.firstScrollLoad &&\n            (this.list.snapshot.items?.length || 0) < this.firstScrollLoad)\n        );\n      }),\n    );\n    this.list.loadState$\n      .pipe(\n        filter(state => state.action === LoadAction.Reload),\n        startWith(null as void),\n        switchMap(() => concat(autoLoadOneScreen$, this.scrollBottomBorder)),\n        // list.rawResponse$ 会处理好 loading 等状态时的 loadMore 请求，但有错误时主要主动停止\n        filter(() => !this.list.snapshot.loadingError),\n        takeUntil(this.destroy$$),\n      )\n      .subscribe(() => {\n        this.list.loadMore();\n      });\n  }\n\n  retry() {\n    this.list.items$.pipe(take(1)).subscribe(items => {\n      if (items.length > 0) {\n        this.list.loadMore();\n      } else {\n        this.list.reload();\n      }\n    });\n  }\n}\n","<div\n  *ngIf=\"isEmptyList$ | async\"\n  class=\"empty-placeholder\"\n>\n  <ng-container *ngIf=\"noDataTemplate\">\n    <ng-template *ngTemplateOutlet=\"noDataTemplate\"></ng-template>\n  </ng-container>\n  <ng-container *ngIf=\"!noDataTemplate\">\n    {{ noDataHint$ | async }}\n  </ng-container>\n</div>\n\n<ng-container *ngIf=\"!(isEmptyList$ | async)\">\n  <div\n    class=\"table-placeholder\"\n    *ngIf=\"list.loadingError$ | async\"\n  >\n    @if (loadingErrorTemplate) {\n      <ng-template *ngTemplateOutlet=\"loadingErrorTemplate\"></ng-template>\n    } @else {\n      <ng-container *ngIf=\"![410, 403].includes(loadingErrorCode$ | async)\">\n        <span\n          >{{ 'error_loading_data' | translate }},{{\n            'please' | translate\n          }}</span\n        >\n        <button\n          aui-button=\"text\"\n          size=\"small\"\n          (click)=\"retry()\"\n        >\n          {{ ('retry' | translate).toLowerCase() }}\n        </button>\n      </ng-container>\n\n      <ng-container *ngIf=\"(loadingErrorCode$ | async) === 410\">\n        <span>\n          {{ 'list_data_has_expired' | translate }}, {{ 'please' | translate }}\n        </span>\n        <button\n          aui-button=\"text\"\n          size=\"small\"\n          (click)=\"list.reload()\"\n        >\n          {{ 'refresh' | translate }}\n        </button>\n        <span>{{ 'or' | translate }}</span>\n        <button\n          aui-button=\"text\"\n          size=\"small\"\n          (click)=\"list.loadMore()\"\n        >\n          {{ 'continue_load' | translate }}\n        </button>\n      </ng-container>\n\n      <ng-container *ngIf=\"(loadingErrorCode$ | async) === 403\">\n        <span>\n          {{ 'no_permission_description' | translate }}\n        </span>\n      </ng-container>\n    }\n  </div>\n\n  <ng-container *ngIf=\"!(list.loadingError$ | async)\">\n    <ng-container\n      *ngIf=\"{\n        loading: list.loading$ | async,\n        loadMore:\n          !autoLoad && !(list.loading$ | async) && list.hasMore$ | async,\n      } as meta\"\n    >\n      <div\n        class=\"table-placeholder\"\n        *ngIf=\"meta.loading\"\n      >\n        <aui-icon icon=\"spinner\"></aui-icon>\n        <span>{{ 'loading_please_wait' | translate }}</span>\n      </div>\n      <div\n        class=\"table-placeholder\"\n        *ngIf=\"meta.loadMore\"\n      >\n        <button\n          aui-button=\"text\"\n          size=\"small\"\n          (click)=\"list.loadMore()\"\n        >\n          {{ 'load_more' | translate }}\n        </button>\n      </div>\n      <div\n        class=\"table-last-row--empty\"\n        *ngIf=\"!meta.loadMore && !meta.loading\"\n      >\n        <div class=\"table-last-row--empty-inner\"></div>\n      </div>\n    </ng-container>\n  </ng-container>\n</ng-container>\n\n<aui-back-top\n  *ngIf=\"backTop\"\n  [target]=\"window\"\n></aui-back-top>\n"]}

package/esm2022/multi-search/multi-search-tags/component.mjs

@@ -69,7 +69,7 @@ export class MultiSearchTagsComponent {
     }
     getValueContent(condition) {
         return condition?.selectedValues
-            ?.map(value => value.label || value.value)
+            ?.map(value => value.tagLabel || value.label || value.value)
             ?.join(condition.separator ?? ' | ');
     }
     static { this.ɵfac = function MultiSearchTagsComponent_Factory(t) { return new (t || MultiSearchTagsComponent)(); }; }
@@ -128,4 +128,4 @@ export class MultiSearchTagsComponent {
             args: ['inputRef']
         }] }); })();
 (() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(MultiSearchTagsComponent, { className: "MultiSearchTagsComponent" }); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component.js","sourceRoot":"","sources":["../../../../../../libs/common/src/multi-search/multi-search-tags/component.ts","../../../../../../libs/common/src/multi-search/multi-search-tags/template.html"],"names":[],"mappings":"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","sourcesContent":["import { TagModule } from '@alauda/ui';\nimport { NgClass, NgFor, NgIf } from '@angular/common';\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  EventEmitter,\n  Input,\n  Output,\n  ViewChild,\n} from '@angular/core';\nimport { FormsModule } from '@angular/forms';\n\nimport { PurePipe } from '../../public-api';\nimport { MultiSearchActionInputComponent } from '../action-input/component';\nimport { SearchConditionConfig, SearchConditionModel } from '../types';\n\n@Component({\n  selector: 'acl-multi-search-tags',\n  standalone: true,\n  templateUrl: './template.html',\n  styleUrls: ['./styles.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  imports: [\n    NgIf,\n    NgFor,\n    TagModule,\n    NgClass,\n    PurePipe,\n    MultiSearchActionInputComponent,\n    FormsModule,\n  ],\n})\nexport class MultiSearchTagsComponent {\n  @Input()\n  placeholder: string;\n\n  @Input()\n  conditionCreatable: boolean;\n\n  @Input()\n  conditionConfig: SearchConditionConfig[];\n\n  @Input()\n  existingConditions: SearchConditionModel[];\n\n  @Output()\n  removeCondition = new EventEmitter<SearchConditionModel>();\n\n  @Output()\n  setConditionEditing = new EventEmitter<SearchConditionModel>();\n\n  @Output()\n  setConditionDeleting = new EventEmitter<number>();\n\n  @Output()\n  search = new EventEmitter<void>();\n\n  @Output()\n  completed = new EventEmitter<{\n    activeCondition: SearchConditionModel;\n    toContinue: boolean;\n    manualFocus: boolean;\n    index?: number;\n  }>();\n\n  @ViewChild('inputRef')\n  inputComponent: MultiSearchActionInputComponent;\n\n  conditionInAction(condition: SearchConditionModel) {\n    return condition.isEditing || condition.isDeleting;\n  }\n\n  getConditionLabel(condition: SearchConditionModel) {\n    return condition?.condition?.label ?? condition?.condition?.value;\n  }\n\n  getValueContent(condition: SearchConditionModel) {\n    return condition?.selectedValues\n      ?.map(value => value.label || value.value)\n      ?.join(condition.separator ?? ' | ');\n  }\n}\n","<div class=\"search-content\">\n  <ng-container *ngFor=\"let condition of existingConditions; let index = index\">\n    <aui-tag\n      *ngIf=\"!conditionInAction(condition); else inAction\"\n      class=\"tw-ml-6 tw-h-[22px] tw-mb-4\"\n      [ngClass]=\"condition.tagClass\"\n      [type]=\"condition.tagType || 'info'\"\n      [border]=\"true\"\n      [closeable]=\"true\"\n      (close)=\"removeCondition.emit(condition); search.emit()\"\n      (click)=\"setConditionEditing.emit(condition)\"\n      size=\"mini\"\n    >\n      <span\n        [title]=\"\n          (condition | pure: getConditionLabel) +\n          ' ' +\n          condition.operator +\n          ' ' +\n          (condition | pure: getValueContent)\n        \"\n      >\n        {{ condition | pure: getConditionLabel }}\n        {{ condition.operator }}\n        {{ condition | pure: getValueContent }}\n      </span>\n    </aui-tag>\n\n    <ng-template #inAction>\n      <acl-multi-search-action-input\n        #inputRef\n        class=\"input-wrapper\"\n        [ngClass]=\"{ 'deleting-input': condition.isDeleting }\"\n        [isEditing]=\"condition.isEditing\"\n        [conditionCreatable]=\"conditionCreatable\"\n        [placeholder]=\"placeholder\"\n        [conditionConfig]=\"conditionConfig\"\n        [existingConditions]=\"existingConditions\"\n        [(ngModel)]=\"condition.actionModel\"\n        (completed)=\"\n          completed.emit({\n            activeCondition: $event.activeCondition,\n            toContinue: $event.toContinue,\n            manualFocus: $event.manualFocus,\n            index: index\n          })\n        \"\n        (delete)=\"setConditionDeleting.emit(index - 1)\"\n        (editing)=\"setConditionEditing.emit(condition)\"\n        (search)=\"search.emit()\"\n      ></acl-multi-search-action-input>\n    </ng-template>\n  </ng-container>\n  <ng-content></ng-content>\n</div>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component.js","sourceRoot":"","sources":["../../../../../../libs/common/src/multi-search/multi-search-tags/component.ts","../../../../../../libs/common/src/multi-search/multi-search-tags/template.html"],"names":[],"mappings":"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","sourcesContent":["import { TagModule } from '@alauda/ui';\nimport { NgClass, NgFor, NgIf } from '@angular/common';\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  EventEmitter,\n  Input,\n  Output,\n  ViewChild,\n} from '@angular/core';\nimport { FormsModule } from '@angular/forms';\n\nimport { PurePipe } from '../../public-api';\nimport { MultiSearchActionInputComponent } from '../action-input/component';\nimport { SearchConditionConfig, SearchConditionModel } from '../types';\n\n@Component({\n  selector: 'acl-multi-search-tags',\n  standalone: true,\n  templateUrl: './template.html',\n  styleUrls: ['./styles.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  imports: [\n    NgIf,\n    NgFor,\n    TagModule,\n    NgClass,\n    PurePipe,\n    MultiSearchActionInputComponent,\n    FormsModule,\n  ],\n})\nexport class MultiSearchTagsComponent {\n  @Input()\n  placeholder: string;\n\n  @Input()\n  conditionCreatable: boolean;\n\n  @Input()\n  conditionConfig: SearchConditionConfig[];\n\n  @Input()\n  existingConditions: SearchConditionModel[];\n\n  @Output()\n  removeCondition = new EventEmitter<SearchConditionModel>();\n\n  @Output()\n  setConditionEditing = new EventEmitter<SearchConditionModel>();\n\n  @Output()\n  setConditionDeleting = new EventEmitter<number>();\n\n  @Output()\n  search = new EventEmitter<void>();\n\n  @Output()\n  completed = new EventEmitter<{\n    activeCondition: SearchConditionModel;\n    toContinue: boolean;\n    manualFocus: boolean;\n    index?: number;\n  }>();\n\n  @ViewChild('inputRef')\n  inputComponent: MultiSearchActionInputComponent;\n\n  conditionInAction(condition: SearchConditionModel) {\n    return condition.isEditing || condition.isDeleting;\n  }\n\n  getConditionLabel(condition: SearchConditionModel) {\n    return condition?.condition?.label ?? condition?.condition?.value;\n  }\n\n  getValueContent(condition: SearchConditionModel) {\n    return condition?.selectedValues\n      ?.map(value => value.tagLabel || value.label || value.value)\n      ?.join(condition.separator ?? ' | ');\n  }\n}\n","<div class=\"search-content\">\n  <ng-container *ngFor=\"let condition of existingConditions; let index = index\">\n    <aui-tag\n      *ngIf=\"!conditionInAction(condition); else inAction\"\n      class=\"tw-ml-6 tw-h-[22px] tw-mb-4\"\n      [ngClass]=\"condition.tagClass\"\n      [type]=\"condition.tagType || 'info'\"\n      [border]=\"true\"\n      [closeable]=\"true\"\n      (close)=\"removeCondition.emit(condition); search.emit()\"\n      (click)=\"setConditionEditing.emit(condition)\"\n      size=\"mini\"\n    >\n      <span\n        [title]=\"\n          (condition | pure: getConditionLabel) +\n          ' ' +\n          condition.operator +\n          ' ' +\n          (condition | pure: getValueContent)\n        \"\n      >\n        {{ condition | pure: getConditionLabel }}\n        {{ condition.operator }}\n        {{ condition | pure: getValueContent }}\n      </span>\n    </aui-tag>\n\n    <ng-template #inAction>\n      <acl-multi-search-action-input\n        #inputRef\n        class=\"input-wrapper\"\n        [ngClass]=\"{ 'deleting-input': condition.isDeleting }\"\n        [isEditing]=\"condition.isEditing\"\n        [conditionCreatable]=\"conditionCreatable\"\n        [placeholder]=\"placeholder\"\n        [conditionConfig]=\"conditionConfig\"\n        [existingConditions]=\"existingConditions\"\n        [(ngModel)]=\"condition.actionModel\"\n        (completed)=\"\n          completed.emit({\n            activeCondition: $event.activeCondition,\n            toContinue: $event.toContinue,\n            manualFocus: $event.manualFocus,\n            index: index\n          })\n        \"\n        (delete)=\"setConditionDeleting.emit(index - 1)\"\n        (editing)=\"setConditionEditing.emit(condition)\"\n        (search)=\"search.emit()\"\n      ></acl-multi-search-action-input>\n    </ng-template>\n  </ng-container>\n  <ng-content></ng-content>\n</div>\n"]}

package/esm2022/multi-search/types.mjs

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

package/esm2022/page-scaffold/page-header/account-menu/component/component.mjs

@@ -7,7 +7,7 @@ import { AlaudaMonacoProviderService } from '@alauda/code-editor';
 import { ThemeService } from '@alauda/ui';
 import { ChangeDetectionStrategy, Component, Optional } from '@angular/core';
 import { toSignal } from '@angular/core/rxjs-interop';
-import { combineLatest, map, timeout } from 'rxjs';
+import { combineLatest, map } from 'rxjs';
 import { AuthorizationStateService } from '../../../../authorization/public-api';
 import { LOCAL_STORAGE_KEY_THEME_MODE } from '../../../../core/public-api';
 import { LOCALE_STORAGE, TranslateService, getAvailableLanguages, } from '../../../../translate/public-api';
@@ -139,12 +139,7 @@ export class AccountMenuComponent {
     }
     logout() {
         // 审计记录登出
-        this.auth
-            .logoutAudit()
-            .pipe(timeout(1000))
-            .subscribe(() => {
-            this.auth.logout();
-        });
+        this.auth.logout();
     }
     changeLanguage(lang) {
         localStorage.setItem(LOCALE_STORAGE, lang);
@@ -194,4 +189,4 @@ export class AccountMenuComponent {
                 type: Optional
             }] }], null); })();
 (() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(AccountMenuComponent, { className: "AccountMenuComponent" }); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component.js","sourceRoot":"","sources":["../../../../../../../../libs/common/src/page-scaffold/page-header/account-menu/component/component.ts","../../../../../../../../libs/common/src/page-scaffold/page-header/account-menu/component/template.html"],"names":[],"mappings":"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","sourcesContent":["/**\n * @packageDocumentation\n * @module account-menu\n */\n\nimport { setTheme as setChartTheme } from '@alauda/chart';\nimport { AlaudaMonacoProviderService } from '@alauda/code-editor';\nimport { ThemeMode, ThemeService } from '@alauda/ui';\nimport { ChangeDetectionStrategy, Component, Optional } from '@angular/core';\nimport { toSignal } from '@angular/core/rxjs-interop';\nimport { combineLatest, map, timeout } from 'rxjs';\n\nimport { AuthorizationStateService } from '../../../../authorization/public-api';\nimport { LOCAL_STORAGE_KEY_THEME_MODE } from '../../../../core/public-api';\nimport {\n  LOCALE_STORAGE,\n  TranslateService,\n  getAvailableLanguages,\n} from '../../../../translate/public-api';\nimport { DEFAULT_PLATFORM_PATH } from '../../component';\n\nexport interface AccountInfo {\n  iss?: string;\n  sub?: string;\n  aud?: string;\n  exp?: number;\n  iat?: number;\n  azp?: string;\n  at_hash?: string;\n  email?: string;\n  email_verified?: true;\n  name?: string;\n  token?: string;\n  ext?: {\n    is_admin?: boolean;\n    conn_id?: boolean;\n  };\n}\n\n@Component({\n  selector: 'acl-account-menu',\n  templateUrl: 'template.html',\n  styleUrls: ['style.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class AccountMenuComponent {\n  displayName$ = this.auth\n    .getTokenPayload<AccountInfo>()\n    .pipe(map(account => account.email || account.name));\n\n  themeMode: string;\n\n  languages = getAvailableLanguages();\n\n  $currentLang = toSignal(this.translate.locale$);\n\n  constructor(\n    private readonly auth: AuthorizationStateService,\n    private readonly translate: TranslateService,\n    private readonly theme: ThemeService,\n    @Optional() monacoService: AlaudaMonacoProviderService,\n  ) {\n    this.initThemeMode();\n    this.theme.currentTheme$.subscribe(theme => {\n      setChartTheme(theme);\n    });\n\n    if (monacoService) {\n      monacoService.initMonaco().then(() => {\n        combineLatest([\n          this.theme.currentTheme$,\n          monacoService.themeMode$,\n        ]).subscribe(([theme, mode]) => {\n          monacoService.changeThemeMode(mode, theme);\n        });\n      });\n    }\n  }\n\n  logout() {\n    // 审计记录登出\n    this.auth\n      .logoutAudit()\n      .pipe(timeout(1000))\n      .subscribe(() => {\n        this.auth.logout();\n      });\n  }\n\n  changeLanguage(lang: string) {\n    localStorage.setItem(LOCALE_STORAGE, lang);\n    window.location.reload();\n  }\n\n  navigateToLink() {\n    window.open(`${DEFAULT_PLATFORM_PATH}/personal-info`, '_blank');\n  }\n\n  setThemeMode(v: ThemeMode) {\n    localStorage.setItem(LOCAL_STORAGE_KEY_THEME_MODE, v);\n    this.themeMode = v;\n    this.theme.setThemeMode(v);\n  }\n\n  private initThemeMode() {\n    let localTheme = localStorage.getItem(LOCAL_STORAGE_KEY_THEME_MODE);\n\n    if (!localTheme) {\n      localTheme = 'system';\n      localStorage.setItem(LOCAL_STORAGE_KEY_THEME_MODE, localTheme);\n    }\n\n    this.themeMode = localTheme;\n\n    if (['system', 'light', 'dark'].includes(localTheme)) {\n      this.theme.setThemeMode(localTheme as ThemeMode);\n    }\n  }\n}\n","<div\n  class=\"account-menu\"\n  [auiDropdown]=\"menu\"\n  [auiDropdownClass]=\"'acl-page-header__tooltip'\"\n>\n  <img\n    src=\"header/portrait.svg\"\n    class=\"account-menu__icon\"\n    alt=\"portrait\"\n  />\n  <div class=\"account-menu__display\">{{ displayName$ | async }}</div>\n  <aui-icon\n    class=\"account-menu__pointer\"\n    icon=\"angle_down\"\n  ></aui-icon>\n</div>\n\n<ng-template #menu>\n  <aui-menu>\n    <aui-menu-item (click)=\"navigateToLink()\">\n      <aui-icon icon=\"user\"></aui-icon>\n      <span>{{ 'my_profile' | translate }}</span>\n    </aui-menu-item>\n\n    <aui-submenu\n      *ngIf=\"themeMode !== 'custom'\"\n      class=\"acl-account-menu-item\"\n    >\n      <div>\n        <aui-icon\n          [icon]=\"\n            themeMode === 'system'\n              ? 'computer'\n              : themeMode === 'light'\n              ? 'sun'\n              : 'moon'\n          \"\n        ></aui-icon>\n        <span>{{ 'appearance' | translate }}</span>\n      </div>\n      <aui-menu-item\n        [actived]=\"themeMode === 'system'\"\n        (click)=\"setThemeMode('system')\"\n      >\n        {{ 'follow_the_system' | translate }}\n      </aui-menu-item>\n      <aui-menu-item\n        [actived]=\"themeMode === 'light'\"\n        (click)=\"setThemeMode('light')\"\n      >\n        {{ 'light_theme' | translate }}\n      </aui-menu-item>\n      <aui-menu-item\n        [actived]=\"themeMode === 'dark'\"\n        (click)=\"setThemeMode('dark')\"\n      >\n        {{ 'dark_theme' | translate }}\n      </aui-menu-item>\n    </aui-submenu>\n\n    <aui-submenu class=\"acl-account-menu-item\">\n      <div>\n        <aui-icon icon=\"prod:globe\"></aui-icon>\n        <span>{{ 'language' | translate }}</span>\n      </div>\n      <aui-menu-item\n        *ngFor=\"let lang of languages\"\n        [actived]=\"lang.id === $currentLang()\"\n        (click)=\"changeLanguage(lang.id)\"\n      >\n        {{ lang.name }}\n      </aui-menu-item>\n    </aui-submenu>\n\n    <aui-menu-item\n      class=\"acl-account-menu-item\"\n      [divide]=\"true\"\n      (click)=\"logout()\"\n    >\n      <aui-icon icon=\"sign_out\"></aui-icon>\n      <span>{{ 'logout' | translate }}</span>\n    </aui-menu-item>\n  </aui-menu>\n</ng-template>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component.js","sourceRoot":"","sources":["../../../../../../../../libs/common/src/page-scaffold/page-header/account-menu/component/component.ts","../../../../../../../../libs/common/src/page-scaffold/page-header/account-menu/component/template.html"],"names":[],"mappings":"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","sourcesContent":["/**\n * @packageDocumentation\n * @module account-menu\n */\n\nimport { setTheme as setChartTheme } from '@alauda/chart';\nimport { AlaudaMonacoProviderService } from '@alauda/code-editor';\nimport { ThemeMode, ThemeService } from '@alauda/ui';\nimport { ChangeDetectionStrategy, Component, Optional } from '@angular/core';\nimport { toSignal } from '@angular/core/rxjs-interop';\nimport { combineLatest, map } from 'rxjs';\n\nimport { AuthorizationStateService } from '../../../../authorization/public-api';\nimport { LOCAL_STORAGE_KEY_THEME_MODE } from '../../../../core/public-api';\nimport {\n  LOCALE_STORAGE,\n  TranslateService,\n  getAvailableLanguages,\n} from '../../../../translate/public-api';\nimport { DEFAULT_PLATFORM_PATH } from '../../component';\n\nexport interface AccountInfo {\n  iss?: string;\n  sub?: string;\n  aud?: string;\n  exp?: number;\n  iat?: number;\n  azp?: string;\n  at_hash?: string;\n  email?: string;\n  email_verified?: true;\n  name?: string;\n  token?: string;\n  ext?: {\n    is_admin?: boolean;\n    conn_id?: boolean;\n  };\n}\n\n@Component({\n  selector: 'acl-account-menu',\n  templateUrl: 'template.html',\n  styleUrls: ['style.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class AccountMenuComponent {\n  displayName$ = this.auth\n    .getTokenPayload<AccountInfo>()\n    .pipe(map(account => account.email || account.name));\n\n  themeMode: string;\n\n  languages = getAvailableLanguages();\n\n  $currentLang = toSignal(this.translate.locale$);\n\n  constructor(\n    private readonly auth: AuthorizationStateService,\n    private readonly translate: TranslateService,\n    private readonly theme: ThemeService,\n    @Optional() monacoService: AlaudaMonacoProviderService,\n  ) {\n    this.initThemeMode();\n    this.theme.currentTheme$.subscribe(theme => {\n      setChartTheme(theme);\n    });\n\n    if (monacoService) {\n      monacoService.initMonaco().then(() => {\n        combineLatest([\n          this.theme.currentTheme$,\n          monacoService.themeMode$,\n        ]).subscribe(([theme, mode]) => {\n          monacoService.changeThemeMode(mode, theme);\n        });\n      });\n    }\n  }\n\n  logout() {\n    // 审计记录登出\n    this.auth.logout();\n  }\n\n  changeLanguage(lang: string) {\n    localStorage.setItem(LOCALE_STORAGE, lang);\n    window.location.reload();\n  }\n\n  navigateToLink() {\n    window.open(`${DEFAULT_PLATFORM_PATH}/personal-info`, '_blank');\n  }\n\n  setThemeMode(v: ThemeMode) {\n    localStorage.setItem(LOCAL_STORAGE_KEY_THEME_MODE, v);\n    this.themeMode = v;\n    this.theme.setThemeMode(v);\n  }\n\n  private initThemeMode() {\n    let localTheme = localStorage.getItem(LOCAL_STORAGE_KEY_THEME_MODE);\n\n    if (!localTheme) {\n      localTheme = 'system';\n      localStorage.setItem(LOCAL_STORAGE_KEY_THEME_MODE, localTheme);\n    }\n\n    this.themeMode = localTheme;\n\n    if (['system', 'light', 'dark'].includes(localTheme)) {\n      this.theme.setThemeMode(localTheme as ThemeMode);\n    }\n  }\n}\n","<div\n  class=\"account-menu\"\n  [auiDropdown]=\"menu\"\n  [auiDropdownClass]=\"'acl-page-header__tooltip'\"\n>\n  <img\n    src=\"header/portrait.svg\"\n    class=\"account-menu__icon\"\n    alt=\"portrait\"\n  />\n  <div class=\"account-menu__display\">{{ displayName$ | async }}</div>\n  <aui-icon\n    class=\"account-menu__pointer\"\n    icon=\"angle_down\"\n  ></aui-icon>\n</div>\n\n<ng-template #menu>\n  <aui-menu>\n    <aui-menu-item (click)=\"navigateToLink()\">\n      <aui-icon icon=\"user\"></aui-icon>\n      <span>{{ 'my_profile' | translate }}</span>\n    </aui-menu-item>\n\n    <aui-submenu\n      *ngIf=\"themeMode !== 'custom'\"\n      class=\"acl-account-menu-item\"\n    >\n      <div>\n        <aui-icon\n          [icon]=\"\n            themeMode === 'system'\n              ? 'computer'\n              : themeMode === 'light'\n              ? 'sun'\n              : 'moon'\n          \"\n        ></aui-icon>\n        <span>{{ 'appearance' | translate }}</span>\n      </div>\n      <aui-menu-item\n        [actived]=\"themeMode === 'system'\"\n        (click)=\"setThemeMode('system')\"\n      >\n        {{ 'follow_the_system' | translate }}\n      </aui-menu-item>\n      <aui-menu-item\n        [actived]=\"themeMode === 'light'\"\n        (click)=\"setThemeMode('light')\"\n      >\n        {{ 'light_theme' | translate }}\n      </aui-menu-item>\n      <aui-menu-item\n        [actived]=\"themeMode === 'dark'\"\n        (click)=\"setThemeMode('dark')\"\n      >\n        {{ 'dark_theme' | translate }}\n      </aui-menu-item>\n    </aui-submenu>\n\n    <aui-submenu class=\"acl-account-menu-item\">\n      <div>\n        <aui-icon icon=\"prod:globe\"></aui-icon>\n        <span>{{ 'language' | translate }}</span>\n      </div>\n      <aui-menu-item\n        *ngFor=\"let lang of languages\"\n        [actived]=\"lang.id === $currentLang()\"\n        (click)=\"changeLanguage(lang.id)\"\n      >\n        {{ lang.name }}\n      </aui-menu-item>\n    </aui-submenu>\n\n    <aui-menu-item\n      class=\"acl-account-menu-item\"\n      [divide]=\"true\"\n      (click)=\"logout()\"\n    >\n      <aui-icon icon=\"sign_out\"></aui-icon>\n      <span>{{ 'logout' | translate }}</span>\n    </aui-menu-item>\n  </aui-menu>\n</ng-template>\n"]}

package/esm2022/pod-status/component.mjs

@@ -8,42 +8,32 @@ import { PodStatusColorMapper, PodStatusIconMapper } from './typings';
 import * as i0 from "@angular/core";
 import * as i1 from "@alauda/ui";
 const _c0 = () => ({ "margin-right": 0 });
-const _c1 = a0 => ({ "tw-flex": a0 });
-const _c2 = a0 => ({ $implicit: a0 });
-const _c3 = a0 => ({ messages: a0 });
-function PodStatusComponent_ng_container_0_div_5_Template(rf, ctx) { if (rf & 1) {
-    i0.ɵɵelementStart(0, "div", 12);
-    i0.ɵɵtext(1);
-    i0.ɵɵelementEnd();
-} if (rf & 2) {
-    const ctx_r0 = i0.ɵɵnextContext(2);
-    i0.ɵɵadvance();
-    i0.ɵɵtextInterpolate1(" ", ctx_r0.pod == null ? null : ctx_r0.pod.status == null ? null : ctx_r0.pod.status.phase, " - ");
-} }
-function PodStatusComponent_ng_container_0_ng_template_10_Template(rf, ctx) { if (rf & 1) {
+const _c1 = a0 => ({ $implicit: a0 });
+const _c2 = a0 => ({ messages: a0 });
+function PodStatusComponent_ng_container_0_ng_template_8_Template(rf, ctx) { if (rf & 1) {
     i0.ɵɵtext(0);
 } if (rf & 2) {
-    const data_r2 = ctx.$implicit;
-    i0.ɵɵtextInterpolate2(" (", data_r2.ready, "/", data_r2.all, ") ");
+    const data_r1 = ctx.$implicit;
+    i0.ɵɵtextInterpolate2(" (", data_r1.ready, "/", data_r1.all, ") ");
 } }
-function PodStatusComponent_ng_container_0_ng_container_12_aui_icon_1_Template(rf, ctx) { if (rf & 1) {
-    i0.ɵɵelement(0, "aui-icon", 14);
+function PodStatusComponent_ng_container_0_ng_container_10_aui_icon_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "aui-icon", 11);
 } if (rf & 2) {
-    const messages_r3 = i0.ɵɵnextContext().ngIf;
+    const messages_r2 = i0.ɵɵnextContext().ngIf;
     i0.ɵɵnextContext(2);
-    const podMessages_r4 = i0.ɵɵreference(5);
-    const onlyOnePodMessage_r5 = i0.ɵɵreference(7);
-    i0.ɵɵproperty("auiTooltip", messages_r3.length === 1 ? onlyOnePodMessage_r5 : podMessages_r4)("auiTooltipContext", i0.ɵɵpureFunction1(2, _c3, messages_r3));
+    const podMessages_r3 = i0.ɵɵreference(5);
+    const onlyOnePodMessage_r4 = i0.ɵɵreference(7);
+    i0.ɵɵproperty("auiTooltip", messages_r2.length === 1 ? onlyOnePodMessage_r4 : podMessages_r3)("auiTooltipContext", i0.ɵɵpureFunction1(2, _c2, messages_r2));
 } }
-function PodStatusComponent_ng_container_0_ng_container_12_Template(rf, ctx) { if (rf & 1) {
+function PodStatusComponent_ng_container_0_ng_container_10_Template(rf, ctx) { if (rf & 1) {
     i0.ɵɵelementContainerStart(0);
-    i0.ɵɵtemplate(1, PodStatusComponent_ng_container_0_ng_container_12_aui_icon_1_Template, 1, 4, "aui-icon", 13);
+    i0.ɵɵtemplate(1, PodStatusComponent_ng_container_0_ng_container_10_aui_icon_1_Template, 1, 4, "aui-icon", 10);
     i0.ɵɵelementContainerEnd();
 } if (rf & 2) {
-    const messages_r3 = ctx.ngIf;
-    const ctx_r0 = i0.ɵɵnextContext(2);
+    const messages_r2 = ctx.ngIf;
+    const ctx_r4 = i0.ɵɵnextContext(2);
     i0.ɵɵadvance();
-    i0.ɵɵproperty("ngIf", (messages_r3 == null ? null : messages_r3.length) && !ctx_r0.disableMessageOverview);
+    i0.ɵɵproperty("ngIf", (messages_r2 == null ? null : messages_r2.length) && !ctx_r4.disableMessageOverview);
 } }
 function PodStatusComponent_ng_container_0_Template(rf, ctx) { if (rf & 1) {
     i0.ɵɵelementContainerStart(0);
@@ -51,31 +41,25 @@ function PodStatusComponent_ng_container_0_Template(rf, ctx) { if (rf & 1) {
     i0.ɵɵelement(2, "acl-status-icon", 6);
     i0.ɵɵpipe(3, "pure");
     i0.ɵɵelementStart(4, "div", 7);
-    i0.ɵɵtemplate(5, PodStatusComponent_ng_container_0_div_5_Template, 2, 1, "div", 8);
-    i0.ɵɵelementStart(6, "div", 9);
-    i0.ɵɵtext(7);
-    i0.ɵɵelementContainer(8, 10);
-    i0.ɵɵpipe(9, "pure");
-    i0.ɵɵtemplate(10, PodStatusComponent_ng_container_0_ng_template_10_Template, 1, 2, "ng-template", null, 3, i0.ɵɵtemplateRefExtractor)(12, PodStatusComponent_ng_container_0_ng_container_12_Template, 2, 1, "ng-container", 11);
-    i0.ɵɵpipe(13, "pure");
-    i0.ɵɵelementEnd()()();
+    i0.ɵɵtext(5);
+    i0.ɵɵelementContainer(6, 8);
+    i0.ɵɵpipe(7, "pure");
+    i0.ɵɵtemplate(8, PodStatusComponent_ng_container_0_ng_template_8_Template, 1, 2, "ng-template", null, 3, i0.ɵɵtemplateRefExtractor)(10, PodStatusComponent_ng_container_0_ng_container_10_Template, 2, 1, "ng-container", 9);
+    i0.ɵɵpipe(11, "pure");
+    i0.ɵɵelementEnd()();
     i0.ɵɵelementContainerEnd();
 } if (rf & 2) {
     const status_r6 = ctx.ngIf;
-    const readyContainerTmpl_r7 = i0.ɵɵreference(11);
-    const ctx_r0 = i0.ɵɵnextContext();
-    i0.ɵɵadvance(2);
-    i0.ɵɵproperty("status", i0.ɵɵpipeBind2(3, 11, status_r6, ctx_r0.getPodAggregatedStatus))("colorMapper", ctx_r0.PodStatusColorMapper)("iconMapper", ctx_r0.PodStatusIconMapper)("withText", false)("ngStyle", i0.ɵɵpureFunction0(20, _c0));
-    i0.ɵɵadvance(2);
-    i0.ɵɵproperty("ngClass", i0.ɵɵpureFunction1(21, _c1, ctx_r0.showNativeStatusWrap));
-    i0.ɵɵadvance();
-    i0.ɵɵproperty("ngIf", ctx_r0.showNativeStatus && (ctx_r0.pod == null ? null : ctx_r0.pod.status == null ? null : ctx_r0.pod.status.phase) !== status_r6);
+    const readyContainerTmpl_r7 = i0.ɵɵreference(9);
+    const ctx_r4 = i0.ɵɵnextContext();
     i0.ɵɵadvance(2);
+    i0.ɵɵproperty("status", i0.ɵɵpipeBind2(3, 9, status_r6, ctx_r4.getPodAggregatedStatus))("colorMapper", ctx_r4.PodStatusColorMapper)("iconMapper", ctx_r4.PodStatusIconMapper)("withText", false)("ngStyle", i0.ɵɵpureFunction0(18, _c0));
+    i0.ɵɵadvance(3);
     i0.ɵɵtextInterpolate1(" ", status_r6, " ");
     i0.ɵɵadvance();
-    i0.ɵɵproperty("ngTemplateOutlet", readyContainerTmpl_r7)("ngTemplateOutletContext", i0.ɵɵpureFunction1(23, _c2, i0.ɵɵpipeBind2(9, 14, ctx_r0.pod, ctx_r0.getReadyContainer)));
+    i0.ɵɵproperty("ngTemplateOutlet", readyContainerTmpl_r7)("ngTemplateOutletContext", i0.ɵɵpureFunction1(19, _c1, i0.ɵɵpipeBind2(7, 12, ctx_r4.pod, ctx_r4.getReadyContainer)));
     i0.ɵɵadvance(4);
-    i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind2(13, 17, ctx_r0.pod, ctx_r0.getPodErrorMessages));
+    i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind2(11, 15, ctx_r4.pod, ctx_r4.getPodErrorMessages));
 } }
 function PodStatusComponent_ng_template_2_Template(rf, ctx) { if (rf & 1) {
     i0.ɵɵtext(0, "-");
@@ -92,8 +76,8 @@ function PodStatusComponent_ng_template_4_li_1_Template(rf, ctx) { if (rf & 1) {
     i0.ɵɵtextInterpolate(msg_r8);
 } }
 function PodStatusComponent_ng_template_4_Template(rf, ctx) { if (rf & 1) {
-    i0.ɵɵelementStart(0, "ul", 15);
-    i0.ɵɵtemplate(1, PodStatusComponent_ng_template_4_li_1_Template, 4, 1, "li", 16);
+    i0.ɵɵelementStart(0, "ul", 12);
+    i0.ɵɵtemplate(1, PodStatusComponent_ng_template_4_li_1_Template, 4, 1, "li", 13);
     i0.ɵɵelementEnd();
 } if (rf & 2) {
     const messages_r9 = ctx.messages;
@@ -126,8 +110,8 @@ export class PodStatusComponent {
         };
     }
     static { this.ɵfac = function PodStatusComponent_Factory(t) { return new (t || PodStatusComponent)(); }; }
-    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: PodStatusComponent, selectors: [["acl-pod-status"]], inputs: { pod: "pod", showNativeStatus: "showNativeStatus", showNativeStatusWrap: "showNativeStatusWrap", disableMessageOverview: "disableMessageOverview" }, standalone: true, features: [i0.ɵɵStandaloneFeature], decls: 8, vars: 5, consts: [["nodata", ""], ["podMessages", ""], ["onlyOnePodMessage", ""], ["readyContainerTmpl", ""], [4, "ngIf", "ngIfElse"], [1, "status-wrapper"], [3, "status", "colorMapper", "iconMapper", "withText", "ngStyle"], [3, "ngClass"], ["class", "tw-mb-4 tw-mr-4", 4, "ngIf"], [1, "tw-flex"], [3, "ngTemplateOutlet", "ngTemplateOutletContext"], [4, "ngIf"], [1, "tw-mb-4", "tw-mr-4"], ["icon", "file_magnifier", "class", "message-tip-icon", "size", "14", "auiTooltipClass", "condition-message-tip", 3, "auiTooltip", "auiTooltipContext", 4, "ngIf"], ["icon", "file_magnifier", "size", "14", "auiTooltipClass", "condition-message-tip", 1, "message-tip-icon", 3, "auiTooltip", "auiTooltipContext"], [1, "pod-messages"], [4, "ngFor", "ngForOf"]], template: function PodStatusComponent_Template(rf, ctx) { if (rf & 1) {
-            i0.ɵɵtemplate(0, PodStatusComponent_ng_container_0_Template, 14, 25, "ng-container", 4);
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: PodStatusComponent, selectors: [["acl-pod-status"]], inputs: { pod: "pod", disableMessageOverview: "disableMessageOverview" }, standalone: true, features: [i0.ɵɵStandaloneFeature], decls: 8, vars: 5, consts: [["nodata", ""], ["podMessages", ""], ["onlyOnePodMessage", ""], ["readyContainerTmpl", ""], [4, "ngIf", "ngIfElse"], [1, "status-wrapper"], [3, "status", "colorMapper", "iconMapper", "withText", "ngStyle"], [1, "tw-flex"], [3, "ngTemplateOutlet", "ngTemplateOutletContext"], [4, "ngIf"], ["icon", "file_magnifier", "class", "message-tip-icon", "size", "14", "auiTooltipClass", "condition-message-tip", 3, "auiTooltip", "auiTooltipContext", 4, "ngIf"], ["icon", "file_magnifier", "size", "14", "auiTooltipClass", "condition-message-tip", 1, "message-tip-icon", 3, "auiTooltip", "auiTooltipContext"], [1, "pod-messages"], [4, "ngFor", "ngForOf"]], template: function PodStatusComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵtemplate(0, PodStatusComponent_ng_container_0_Template, 12, 21, "ng-container", 4);
             i0.ɵɵpipe(1, "pure");
             i0.ɵɵtemplate(2, PodStatusComponent_ng_template_2_Template, 1, 0, "ng-template", null, 0, i0.ɵɵtemplateRefExtractor)(4, PodStatusComponent_ng_template_4_Template, 2, 1, "ng-template", null, 1, i0.ɵɵtemplateRefExtractor)(6, PodStatusComponent_ng_template_6_Template, 1, 1, "ng-template", null, 2, i0.ɵɵtemplateRefExtractor);
         } if (rf & 2) {
@@ -136,7 +120,6 @@ export class PodStatusComponent {
         } }, dependencies: [StatusIconComponent,
             NgIf,
             IconModule, i1.IconComponent, TooltipModule, i1.TooltipDirective, NgStyle,
-            NgClass,
             NgTemplateOutlet,
             PurePipe,
             NgFor], styles: ["[_nghost-%COMP%]{display:flex}[_nghost-%COMP%]     .condition-message-tip{white-space:pre-line}[_nghost-%COMP%]   .message-tip-icon[_ngcontent-%COMP%]{margin-left:6px}[_nghost-%COMP%]   .status-wrapper[_ngcontent-%COMP%]{display:flex;overflow:hidden;text-overflow:ellipsis}.pod-messages[_ngcontent-%COMP%]   li[_ngcontent-%COMP%]{padding-left:8px}.pod-messages[_ngcontent-%COMP%]   li[_ngcontent-%COMP%]   em[_ngcontent-%COMP%]{color:rgb(var(--aui-color-n-4));margin-right:4px;margin-left:-8px;font-size:14px}"], changeDetection: 0 }); }
@@ -153,15 +136,11 @@ export class PodStatusComponent {
                     NgTemplateOutlet,
                     PurePipe,
                     NgFor,
-                ], changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container *ngIf=\"pod | pure: getPodStatus as status; else nodata\">\n  <div class=\"status-wrapper\">\n    <acl-status-icon\n      [status]=\"status | pure: getPodAggregatedStatus\"\n      [colorMapper]=\"PodStatusColorMapper\"\n      [iconMapper]=\"PodStatusIconMapper\"\n      [withText]=\"false\"\n      [ngStyle]=\"{ 'margin-right': 0 }\"\n    ></acl-status-icon>\n    <div [ngClass]=\"{ 'tw-flex': showNativeStatusWrap }\">\n      <div\n        class=\"tw-mb-4 tw-mr-4\"\n        *ngIf=\"showNativeStatus && pod?.status?.phase !== status\"\n      >\n        {{ pod?.status?.phase }} -\n      </div>\n      <div class=\"tw-flex\">\n        {{ status }}\n        <ng-container\n          [ngTemplateOutlet]=\"readyContainerTmpl\"\n          [ngTemplateOutletContext]=\"{\n            $implicit: pod | pure: getReadyContainer\n          }\"\n        ></ng-container>\n        <ng-template\n          #readyContainerTmpl\n          let-data\n        >\n          ({{ data.ready }}/{{ data.all }})\n        </ng-template>\n        <ng-container *ngIf=\"pod | pure: getPodErrorMessages as messages\">\n          <aui-icon\n            icon=\"file_magnifier\"\n            *ngIf=\"messages?.length && !disableMessageOverview\"\n            class=\"message-tip-icon\"\n            [auiTooltip]=\"\n              messages.length === 1 ? onlyOnePodMessage : podMessages\n            \"\n            [auiTooltipContext]=\"{ messages: messages }\"\n            size=\"14\"\n            auiTooltipClass=\"condition-message-tip\"\n          ></aui-icon>\n        </ng-container>\n      </div>\n    </div>\n  </div>\n</ng-container>\n<ng-template #nodata>-</ng-template>\n<ng-template\n  #podMessages\n  let-messages=\"messages\"\n>\n  <ul class=\"pod-messages\">\n    <li *ngFor=\"let msg of messages\"><em>&bull;</em>{{ msg }}</li>\n  </ul>\n</ng-template>\n<ng-template\n  #onlyOnePodMessage\n  let-messages=\"messages\"\n>\n  {{ messages[0] }}\n</ng-template>\n", styles: [":host{display:flex}:host ::ng-deep .condition-message-tip{white-space:pre-line}:host .message-tip-icon{margin-left:6px}:host .status-wrapper{display:flex;overflow:hidden;text-overflow:ellipsis}.pod-messages li{padding-left:8px}.pod-messages li em{color:rgb(var(--aui-color-n-4));margin-right:4px;margin-left:-8px;font-size:14px}\n"] }]
+                ], changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container *ngIf=\"pod | pure: getPodStatus as status; else nodata\">\n  <div class=\"status-wrapper\">\n    <acl-status-icon\n      [status]=\"status | pure: getPodAggregatedStatus\"\n      [colorMapper]=\"PodStatusColorMapper\"\n      [iconMapper]=\"PodStatusIconMapper\"\n      [withText]=\"false\"\n      [ngStyle]=\"{ 'margin-right': 0 }\"\n    ></acl-status-icon>\n    <div class=\"tw-flex\">\n      {{ status }}\n      <ng-container\n        [ngTemplateOutlet]=\"readyContainerTmpl\"\n        [ngTemplateOutletContext]=\"{\n          $implicit: pod | pure: getReadyContainer,\n        }\"\n      ></ng-container>\n      <ng-template\n        #readyContainerTmpl\n        let-data\n      >\n        ({{ data.ready }}/{{ data.all }})\n      </ng-template>\n      <ng-container *ngIf=\"pod | pure: getPodErrorMessages as messages\">\n        <aui-icon\n          icon=\"file_magnifier\"\n          *ngIf=\"messages?.length && !disableMessageOverview\"\n          class=\"message-tip-icon\"\n          [auiTooltip]=\"messages.length === 1 ? onlyOnePodMessage : podMessages\"\n          [auiTooltipContext]=\"{ messages: messages }\"\n          size=\"14\"\n          auiTooltipClass=\"condition-message-tip\"\n        ></aui-icon>\n      </ng-container>\n    </div>\n  </div>\n</ng-container>\n<ng-template #nodata>-</ng-template>\n<ng-template\n  #podMessages\n  let-messages=\"messages\"\n>\n  <ul class=\"pod-messages\">\n    <li *ngFor=\"let msg of messages\"><em>&bull;</em>{{ msg }}</li>\n  </ul>\n</ng-template>\n<ng-template\n  #onlyOnePodMessage\n  let-messages=\"messages\"\n>\n  {{ messages[0] }}\n</ng-template>\n", styles: [":host{display:flex}:host ::ng-deep .condition-message-tip{white-space:pre-line}:host .message-tip-icon{margin-left:6px}:host .status-wrapper{display:flex;overflow:hidden;text-overflow:ellipsis}.pod-messages li{padding-left:8px}.pod-messages li em{color:rgb(var(--aui-color-n-4));margin-right:4px;margin-left:-8px;font-size:14px}\n"] }]
     }], null, { pod: [{
             type: Input
-        }], showNativeStatus: [{
-            type: Input
-        }], showNativeStatusWrap: [{
-            type: Input
         }], disableMessageOverview: [{
             type: Input
         }] }); })();
 (() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(PodStatusComponent, { className: "PodStatusComponent" }); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component.js","sourceRoot":"","sources":["../../../../../libs/common/src/pod-status/component.ts","../../../../../libs/common/src/pod-status/template.html"],"names":[],"mappings":"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","sourcesContent":["import { IconModule, TooltipModule } from '@alauda/ui';\nimport {\n  NgClass,\n  NgFor,\n  NgIf,\n  NgStyle,\n  NgTemplateOutlet,\n} from '@angular/common';\nimport { ChangeDetectionStrategy, Component, Input } from '@angular/core';\n\nimport { Pod, PurePipe } from '../core/public-api';\nimport { StatusIconComponent } from '../widget/public-api';\n\nimport { getPodAggregatedStatus, getPodStatus } from './status';\nimport { PodStatusColorMapper, PodStatusIconMapper } from './typings';\n\n@Component({\n  selector: 'acl-pod-status',\n  templateUrl: 'template.html',\n  styleUrls: ['style.scss'],\n  standalone: true,\n  imports: [\n    StatusIconComponent,\n    NgIf,\n    IconModule,\n    TooltipModule,\n    NgStyle,\n    NgClass,\n    NgTemplateOutlet,\n    PurePipe,\n    NgFor,\n  ],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class PodStatusComponent {\n  @Input()\n  pod: Pod;\n\n  @Input()\n  showNativeStatus: boolean;\n\n  @Input()\n  showNativeStatusWrap: boolean;\n\n  @Input()\n  disableMessageOverview: boolean;\n\n  getReadyContainer(pod: Pod) {\n    return {\n      ready: (pod.status.containerStatuses || []).filter(i => i.ready).length,\n      all: pod.spec.containers.length,\n    };\n  }\n\n  getPodErrorMessages = (pod: Pod) =>\n    getPodStatus(pod).includes('Pending')\n      ? pod.status.conditions?.map(item => item.message).filter(msg => !!msg)\n      : pod.status.containerStatuses\n          ?.filter(c => !c.ready)\n          .map(c => c.state?.waiting?.message)\n          .filter(msg => !!msg);\n\n  getPodAggregatedStatus = getPodAggregatedStatus;\n  getPodStatus = getPodStatus;\n  PodStatusColorMapper = PodStatusColorMapper;\n  PodStatusIconMapper = PodStatusIconMapper;\n}\n","<ng-container *ngIf=\"pod | pure: getPodStatus as status; else nodata\">\n  <div class=\"status-wrapper\">\n    <acl-status-icon\n      [status]=\"status | pure: getPodAggregatedStatus\"\n      [colorMapper]=\"PodStatusColorMapper\"\n      [iconMapper]=\"PodStatusIconMapper\"\n      [withText]=\"false\"\n      [ngStyle]=\"{ 'margin-right': 0 }\"\n    ></acl-status-icon>\n    <div [ngClass]=\"{ 'tw-flex': showNativeStatusWrap }\">\n      <div\n        class=\"tw-mb-4 tw-mr-4\"\n        *ngIf=\"showNativeStatus && pod?.status?.phase !== status\"\n      >\n        {{ pod?.status?.phase }} -\n      </div>\n      <div class=\"tw-flex\">\n        {{ status }}\n        <ng-container\n          [ngTemplateOutlet]=\"readyContainerTmpl\"\n          [ngTemplateOutletContext]=\"{\n            $implicit: pod | pure: getReadyContainer\n          }\"\n        ></ng-container>\n        <ng-template\n          #readyContainerTmpl\n          let-data\n        >\n          ({{ data.ready }}/{{ data.all }})\n        </ng-template>\n        <ng-container *ngIf=\"pod | pure: getPodErrorMessages as messages\">\n          <aui-icon\n            icon=\"file_magnifier\"\n            *ngIf=\"messages?.length && !disableMessageOverview\"\n            class=\"message-tip-icon\"\n            [auiTooltip]=\"\n              messages.length === 1 ? onlyOnePodMessage : podMessages\n            \"\n            [auiTooltipContext]=\"{ messages: messages }\"\n            size=\"14\"\n            auiTooltipClass=\"condition-message-tip\"\n          ></aui-icon>\n        </ng-container>\n      </div>\n    </div>\n  </div>\n</ng-container>\n<ng-template #nodata>-</ng-template>\n<ng-template\n  #podMessages\n  let-messages=\"messages\"\n>\n  <ul class=\"pod-messages\">\n    <li *ngFor=\"let msg of messages\"><em>&bull;</em>{{ msg }}</li>\n  </ul>\n</ng-template>\n<ng-template\n  #onlyOnePodMessage\n  let-messages=\"messages\"\n>\n  {{ messages[0] }}\n</ng-template>\n"]}
+//# sourceMappingURL=data:application/json;base64,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