@alauda-fe/workload-util-shared 0.0.1

package/esm2022/alauda-fe-workload-util-shared.mjs

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

package/esm2022/index.mjs

@@ -0,0 +1,6 @@
+export * from './lib/directives';
+export * from './lib/pipes';
+export * from './lib/services';
+export * from './lib/typings';
+export * from './lib/utils';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9tb2R1bGVzL3dvcmtsb2FkL3V0aWwtc2hhcmVkL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxhQUFhLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi9kaXJlY3RpdmVzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3BpcGVzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3NlcnZpY2VzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3R5cGluZ3MnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdXRpbHMnO1xuIl19

package/esm2022/lib/directives/index.mjs

@@ -0,0 +1,3 @@
+export * from './oam-resource-disabled-container.directive';
+export * from './sync-control.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9tb2R1bGVzL3dvcmtsb2FkL3V0aWwtc2hhcmVkL3NyYy9saWIvZGlyZWN0aXZlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDZDQUE2QyxDQUFDO0FBQzVELGNBQWMsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL29hbS1yZXNvdXJjZS1kaXNhYmxlZC1jb250YWluZXIuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vc3luYy1jb250cm9sLmRpcmVjdGl2ZSc7XG4iXX0=

package/esm2022/lib/directives/oam-resource-disabled-container.directive.mjs

@@ -0,0 +1,53 @@
+import { __decorate, __metadata } from "tslib";
+import { DisabledContainerComponent, TranslateService, ValueHook, } from '@alauda-fe/common';
+import { ChangeDetectorRef, Directive, Input } from '@angular/core';
+import { distinctUntilChanged } from 'rxjs';
+import { isOamResource } from '../pipes/is-oam-resource.pipe';
+import * as i0 from "@angular/core";
+import * as i1 from "@alauda-fe/common";
+/**
+ * @description acl-disabled-container 增强指令。
+ *
+ * 需要注意对 acl-disabled-container的副作用，一旦满足 isOam 的条件，禁用的 tip 会一直保留，并且优先级最高，除非数据源本身发生变化。
+ */
+export class OamResourceDisabledContainerDirective {
+    constructor(disabledContainer, translate, cdr) {
+        this.disabledContainer = disabledContainer;
+        this.translate = translate;
+        this.cdr = cdr;
+    }
+    static { this.ɵfac = function OamResourceDisabledContainerDirective_Factory(t) { return new (t || OamResourceDisabledContainerDirective)(i0.ɵɵdirectiveInject(i1.DisabledContainerComponent), i0.ɵɵdirectiveInject(i1.TranslateService), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: OamResourceDisabledContainerDirective, selectors: [["acl-disabled-container", "rcIsOamDisabled", ""]], inputs: { rcIsOamDisabled: "rcIsOamDisabled" }, standalone: true }); }
+}
+__decorate([
+    ValueHook(function (resource) {
+        const oamDisabledTooltip = this.translate.get('oam_asset_action_disabled_tip');
+        if (isOamResource(resource)) {
+            this.disabledContainer.isDisabled$
+                .pipe(distinctUntilChanged())
+                .subscribe(() => {
+                Promise.resolve().then(() => {
+                    this.disabledContainer.isDisabled = true;
+                    this.cdr.markForCheck();
+                });
+            });
+            this.disabledContainer.tooltip$
+                .pipe(distinctUntilChanged())
+                .subscribe(() => {
+                this.disabledContainer.tooltip = oamDisabledTooltip;
+                this.cdr.markForCheck();
+            });
+        }
+    }),
+    __metadata("design:type", Object)
+], OamResourceDisabledContainerDirective.prototype, "rcIsOamDisabled", void 0);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(OamResourceDisabledContainerDirective, [{
+        type: Directive,
+        args: [{
+                standalone: true,
+                selector: 'acl-disabled-container[rcIsOamDisabled]',
+            }]
+    }], () => [{ type: i1.DisabledContainerComponent }, { type: i1.TranslateService }, { type: i0.ChangeDetectorRef }], { rcIsOamDisabled: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/sync-control.directive.mjs

@@ -0,0 +1,52 @@
+import { Directive, EventEmitter, Injector, } from '@angular/core';
+import { FormControlDirective, FormControlName, } from '@angular/forms';
+import { takeUntil } from 'rxjs';
+import * as i0 from "@angular/core";
+const formDirectives = [FormControlName, FormControlDirective];
+export class SyncControlDirective {
+    constructor(injector) {
+        this.injector = injector;
+        this.destroy$$ = new EventEmitter();
+    }
+    ngOnDestroy() {
+        this.destroy$$.emit();
+        this.destroy$$.complete();
+    }
+    ngAfterViewInit() {
+        const control = this.getControl();
+        if (!control) {
+            return;
+        }
+        control.valueChanges.pipe(takeUntil(this.destroy$$)).subscribe(value => {
+            control.setValue(value, { emitEvent: false });
+        });
+    }
+    getControl() {
+        let foundDirective;
+        for (const directive of formDirectives) {
+            foundDirective = this.getDirective(directive);
+            if (foundDirective) {
+                return foundDirective.control;
+            }
+        }
+    }
+    getDirective(directive) {
+        return (this.injector.get(directive, 
+        // setting 'notFoundValue' to 'undefined' will make the method throw an error
+        null, {
+            optional: true,
+            self: true,
+        }) || undefined);
+    }
+    static { this.ɵfac = function SyncControlDirective_Factory(t) { return new (t || SyncControlDirective)(i0.ɵɵdirectiveInject(i0.Injector)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: SyncControlDirective, selectors: [["", "syncControl", ""]], standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SyncControlDirective, [{
+        type: Directive,
+        args: [{
+                standalone: true,
+                // eslint-disable-next-line @angular-eslint/directive-selector
+                selector: '[syncControl]',
+            }]
+    }], () => [{ type: i0.Injector }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/pipes/index.mjs

@@ -0,0 +1,4 @@
+export * from './is-oam-resource.pipe';
+export * from './range.pipe';
+export * from './short-num.pipe';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9tb2R1bGVzL3dvcmtsb2FkL3V0aWwtc2hhcmVkL3NyYy9saWIvcGlwZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9pcy1vYW0tcmVzb3VyY2UucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL3JhbmdlLnBpcGUnO1xuZXhwb3J0ICogZnJvbSAnLi9zaG9ydC1udW0ucGlwZSc7XG4iXX0=

package/esm2022/lib/pipes/is-oam-resource.pipe.mjs

@@ -0,0 +1,17 @@
+import { LABELS, METADATA } from '@alauda-fe/common';
+import { Pipe } from '@angular/core';
+import { get } from 'lodash-es';
+import * as i0 from "@angular/core";
+export const isOamResource = (resource) => !!get(resource, [METADATA, LABELS, 'app.oam.dev/name']);
+export class isOamResourcePipe {
+    constructor() {
+        this.transform = isOamResource;
+    }
+    static { this.ɵfac = function isOamResourcePipe_Factory(t) { return new (t || isOamResourcePipe)(); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "rcIsOamResource", type: isOamResourcePipe, pure: true, standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(isOamResourcePipe, [{
+        type: Pipe,
+        args: [{ name: 'rcIsOamResource', standalone: true }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtb2FtLXJlc291cmNlLnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9tb2R1bGVzL3dvcmtsb2FkL3V0aWwtc2hhcmVkL3NyYy9saWIvcGlwZXMvaXMtb2FtLXJlc291cmNlLnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFzQixNQUFNLEVBQUUsUUFBUSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDekUsT0FBTyxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUM7QUFDcEQsT0FBTyxFQUFFLEdBQUcsRUFBRSxNQUFNLFdBQVcsQ0FBQzs7QUFFaEMsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFHLENBQStCLFFBQVcsRUFBRSxFQUFFLENBQ3pFLENBQUMsQ0FBQyxHQUFHLENBQUMsUUFBUSxFQUFFLENBQUMsUUFBUSxFQUFFLE1BQU0sRUFBRSxrQkFBa0IsQ0FBQyxDQUFDLENBQUM7QUFHMUQsTUFBTSxPQUFPLGlCQUFpQjtJQUQ5QjtRQUVFLGNBQVMsR0FBRyxhQUFhLENBQUM7S0FDM0I7a0ZBRlksaUJBQWlCO3lGQUFqQixpQkFBaUI7O2lGQUFqQixpQkFBaUI7Y0FEN0IsSUFBSTtlQUFDLEVBQUUsSUFBSSxFQUFFLGlCQUFpQixFQUFFLFVBQVUsRUFBRSxJQUFJLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBLdWJlcm5ldGVzUmVzb3VyY2UsIExBQkVMUywgTUVUQURBVEEgfSBmcm9tICdAYWxhdWRhLWZlL2NvbW1vbic7XG5pbXBvcnQgeyBQaXBlLCBQaXBlVHJhbnNmb3JtIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBnZXQgfSBmcm9tICdsb2Rhc2gtZXMnO1xuXG5leHBvcnQgY29uc3QgaXNPYW1SZXNvdXJjZSA9IDxUIGV4dGVuZHMgS3ViZXJuZXRlc1Jlc291cmNlPihyZXNvdXJjZTogVCkgPT5cbiAgISFnZXQocmVzb3VyY2UsIFtNRVRBREFUQSwgTEFCRUxTLCAnYXBwLm9hbS5kZXYvbmFtZSddKTtcblxuQFBpcGUoeyBuYW1lOiAncmNJc09hbVJlc291cmNlJywgc3RhbmRhbG9uZTogdHJ1ZSB9KVxuZXhwb3J0IGNsYXNzIGlzT2FtUmVzb3VyY2VQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG4gIHRyYW5zZm9ybSA9IGlzT2FtUmVzb3VyY2U7XG59XG4iXX0=

package/esm2022/lib/pipes/range.pipe.mjs

@@ -0,0 +1,17 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class RangePipe {
+    transform(value) {
+        return Array.from({ length: value }, (_, index) => index);
+    }
+    static { this.ɵfac = function RangePipe_Factory(t) { return new (t || RangePipe)(); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "range", type: RangePipe, pure: true, standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(RangePipe, [{
+        type: Pipe,
+        args: [{
+                standalone: true,
+                name: 'range',
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmFuZ2UucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL21vZHVsZXMvd29ya2xvYWQvdXRpbC1zaGFyZWQvc3JjL2xpYi9waXBlcy9yYW5nZS5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQWlCLE1BQU0sZUFBZSxDQUFDOztBQU1wRCxNQUFNLE9BQU8sU0FBUztJQUNwQixTQUFTLENBQUMsS0FBYTtRQUNyQixPQUFPLEtBQUssQ0FBQyxJQUFJLENBQUMsRUFBRSxNQUFNLEVBQUUsS0FBSyxFQUFFLEVBQUUsQ0FBQyxDQUFDLEVBQUUsS0FBSyxFQUFFLEVBQUUsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUM1RCxDQUFDOzBFQUhVLFNBQVM7K0VBQVQsU0FBUzs7aUZBQVQsU0FBUztjQUpyQixJQUFJO2VBQUM7Z0JBQ0osVUFBVSxFQUFFLElBQUk7Z0JBQ2hCLElBQUksRUFBRSxPQUFPO2FBQ2QiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQaXBlLCBQaXBlVHJhbnNmb3JtIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBQaXBlKHtcbiAgc3RhbmRhbG9uZTogdHJ1ZSxcbiAgbmFtZTogJ3JhbmdlJyxcbn0pXG5leHBvcnQgY2xhc3MgUmFuZ2VQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG4gIHRyYW5zZm9ybSh2YWx1ZTogbnVtYmVyKTogbnVtYmVyW10ge1xuICAgIHJldHVybiBBcnJheS5mcm9tKHsgbGVuZ3RoOiB2YWx1ZSB9LCAoXywgaW5kZXgpID0+IGluZGV4KTtcbiAgfVxufVxuIl19

package/esm2022/lib/pipes/short-num.pipe.mjs

@@ -0,0 +1,15 @@
+import { shortNum } from '@alauda-fe/common';
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ShortNumPipe {
+    transform(value, digits) {
+        return shortNum(value, digits);
+    }
+    static { this.ɵfac = function ShortNumPipe_Factory(t) { return new (t || ShortNumPipe)(); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "shortNum", type: ShortNumPipe, pure: true, standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ShortNumPipe, [{
+        type: Pipe,
+        args: [{ standalone: true, name: 'shortNum' }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hvcnQtbnVtLnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9tb2R1bGVzL3dvcmtsb2FkL3V0aWwtc2hhcmVkL3NyYy9saWIvcGlwZXMvc2hvcnQtbnVtLnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQzdDLE9BQU8sRUFBRSxJQUFJLEVBQWlCLE1BQU0sZUFBZSxDQUFDOztBQUdwRCxNQUFNLE9BQU8sWUFBWTtJQUN2QixTQUFTLENBQUMsS0FBc0IsRUFBRSxNQUFlO1FBQy9DLE9BQU8sUUFBUSxDQUFDLEtBQUssRUFBRSxNQUFNLENBQUMsQ0FBQztJQUNqQyxDQUFDOzZFQUhVLFlBQVk7a0ZBQVosWUFBWTs7aUZBQVosWUFBWTtjQUR4QixJQUFJO2VBQUMsRUFBRSxVQUFVLEVBQUUsSUFBSSxFQUFFLElBQUksRUFBRSxVQUFVLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBzaG9ydE51bSB9IGZyb20gJ0BhbGF1ZGEtZmUvY29tbW9uJztcbmltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQFBpcGUoeyBzdGFuZGFsb25lOiB0cnVlLCBuYW1lOiAnc2hvcnROdW0nIH0pXG5leHBvcnQgY2xhc3MgU2hvcnROdW1QaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG4gIHRyYW5zZm9ybSh2YWx1ZTogc3RyaW5nIHwgbnVtYmVyLCBkaWdpdHM/OiBudW1iZXIpIHtcbiAgICByZXR1cm4gc2hvcnROdW0odmFsdWUsIGRpZ2l0cyk7XG4gIH1cbn1cbiJdfQ==

package/esm2022/lib/services/cluster-api.service.mjs

@@ -0,0 +1,93 @@
+import { CacheStore, compareVersion, K8sApiService, K8sUtilService, publishRef, skipError, TRUE, } from '@alauda-fe/common';
+import { isPublicCloud } from '@alauda-fe/network';
+import { Injectable } from '@angular/core';
+import { combineLatest, map, of, shareReplay } from 'rxjs';
+import { RESOURCE_TYPES } from '../typings';
+import { HARDWARE_ARCHITECTURE_MAPPER } from '../utils/constants';
+import * as i0 from "@angular/core";
+import * as i1 from "@alauda-fe/common";
+export class ClusterApiService {
+    constructor(k8sApi, k8sUtil) {
+        this.k8sApi = k8sApi;
+        this.k8sUtil = k8sUtil;
+        this.globalClusterVersion$ = this.k8sApi
+            .getResource({
+            type: RESOURCE_TYPES.PRODUCT_BASE,
+            name: 'base',
+        })
+            .pipe(shareReplay(1));
+        this.globalInfoCache = new CacheStore({
+            fetcher: cluster => cluster
+                ? this.k8sApi
+                    .getResource({
+                    type: RESOURCE_TYPES.CONFIG_MAP,
+                    cluster,
+                    namespace: 'kube-public',
+                    name: 'global-info',
+                })
+                    .pipe(skipError(null))
+                : of(null),
+            share: () => shareReplay(1),
+        });
+    }
+    isClusterNonUpgraded(cluster) {
+        return combineLatest([
+            this.globalClusterVersion$,
+            typeof cluster === 'string'
+                ? this.k8sApi.getGlobalResource({
+                    type: RESOURCE_TYPES.CLUSTER_MODULE,
+                    name: cluster,
+                })
+                : of(cluster),
+        ]).pipe(map(([global, current]) => {
+            const globalVersion = global.status.version.split('-')[0];
+            const currentVersion = current.spec.version.split('-')[0];
+            return globalVersion !== currentVersion;
+        }));
+    }
+    gteVersion(cluster, version) {
+        const clusterModule$ = typeof cluster === 'string'
+            ? this.k8sApi.getGlobalResource({
+                type: RESOURCE_TYPES.CLUSTER_MODULE,
+                name: cluster,
+            })
+            : of(cluster);
+        return clusterModule$.pipe(map(module => compareVersion.gte(module.spec.version.split('-')[0], version)), publishRef());
+    }
+    getGlobalInfo(cluster) {
+        return this.globalInfoCache
+            .fetch(cluster)
+            .pipe(map(configMap => configMap?.data));
+    }
+    getClusterType(cluster) {
+        return this.getGlobalInfo(cluster).pipe(map(configMap => configMap?.clusterType));
+    }
+    isPublicCloud(cluster) {
+        return this.getClusterType(cluster).pipe(map(clusterType => isPublicCloud(clusterType)));
+    }
+    getClusterArches(cluster) {
+        return this.k8sApi
+            .getGlobalResource({
+            type: RESOURCE_TYPES.CLUSTER,
+            name: cluster,
+            namespaced: true,
+        })
+            .pipe(map(c => {
+            const isArchAmd64 = this.k8sUtil.getLabel(c, 'arch-amd64') === TRUE;
+            const isArchArm64 = this.k8sUtil.getLabel(c, 'arch-arm64') === TRUE;
+            return [
+                ...(isArchAmd64 ? [HARDWARE_ARCHITECTURE_MAPPER.amd64] : []),
+                ...(isArchArm64 ? [HARDWARE_ARCHITECTURE_MAPPER.arm64] : []),
+            ];
+        }));
+    }
+    static { this.ɵfac = function ClusterApiService_Factory(t) { return new (t || ClusterApiService)(i0.ɵɵinject(i1.K8sApiService), i0.ɵɵinject(i1.K8sUtilService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ClusterApiService, factory: ClusterApiService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ClusterApiService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], () => [{ type: i1.K8sApiService }, { type: i1.K8sUtilService }], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cluster-api.service.js","sourceRoot":"","sources":["../../../../../../../modules/workload/util-shared/src/lib/services/cluster-api.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  CacheStore,\n  compareVersion,\n  ConfigMap,\n  K8sApiService,\n  K8sUtilService,\n  publishRef,\n  skipError,\n  TRUE,\n  ProductBase,\n} from '@alauda-fe/common';\nimport { ClusterType, isPublicCloud } from '@alauda-fe/network';\nimport { Injectable } from '@angular/core';\nimport { combineLatest, map, of, shareReplay } from 'rxjs';\n\nimport { ClusterModule, RESOURCE_TYPES, ResourceType } from '../typings';\nimport { HARDWARE_ARCHITECTURE_MAPPER } from '../utils/constants';\n\nexport interface ClusterGlobalInfo {\n  chartMuseumURL: string;\n  clusterName: string;\n  clusterType: ClusterType;\n  globalClusterName: string;\n  labelBaseDomain: string;\n  oidcClientID: string;\n  oidcClientSecret: string;\n  oidcIssuer: string;\n  oidcResponseType: 'code';\n  oidcScopes: string;\n  platformHttpPort: string;\n  platformHttpsPort: string;\n  platformNodeSelector: string;\n  platformURL: string;\n  registryAddress: string;\n  systemAlbIngressClassName: string;\n  systemNamespace: string;\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ClusterApiService {\n  globalClusterVersion$ = this.k8sApi\n    .getResource<ProductBase>({\n      type: RESOURCE_TYPES.PRODUCT_BASE,\n      name: 'base',\n    })\n    .pipe(shareReplay(1));\n\n  private readonly globalInfoCache = new CacheStore<\n    string,\n    ConfigMap<ClusterGlobalInfo>\n  >({\n    fetcher: cluster =>\n      cluster\n        ? this.k8sApi\n            .getResource({\n              type: RESOURCE_TYPES.CONFIG_MAP,\n              cluster,\n              namespace: 'kube-public',\n              name: 'global-info',\n            })\n            .pipe(skipError(null))\n        : of(null),\n    share: () => shareReplay(1),\n  });\n\n  constructor(\n    private readonly k8sApi: K8sApiService<ResourceType>,\n    private readonly k8sUtil: K8sUtilService,\n  ) {}\n\n  isClusterNonUpgraded(cluster: string | ClusterModule) {\n    return combineLatest([\n      this.globalClusterVersion$,\n      typeof cluster === 'string'\n        ? this.k8sApi.getGlobalResource<ClusterModule>({\n            type: RESOURCE_TYPES.CLUSTER_MODULE,\n            name: cluster,\n          })\n        : of(cluster),\n    ]).pipe(\n      map(([global, current]) => {\n        const globalVersion = global.status.version.split('-')[0];\n        const currentVersion = current.spec.version.split('-')[0];\n        return globalVersion !== currentVersion;\n      }),\n    );\n  }\n\n  gteVersion(cluster: string | ClusterModule, version: string) {\n    const clusterModule$ =\n      typeof cluster === 'string'\n        ? this.k8sApi.getGlobalResource<ClusterModule>({\n            type: RESOURCE_TYPES.CLUSTER_MODULE,\n            name: cluster,\n          })\n        : of(cluster);\n    return clusterModule$.pipe(\n      map(module =>\n        compareVersion.gte(module.spec.version.split('-')[0], version),\n      ),\n      publishRef(),\n    );\n  }\n\n  getGlobalInfo(cluster?: string) {\n    return this.globalInfoCache\n      .fetch(cluster)\n      .pipe(map(configMap => configMap?.data));\n  }\n\n  getClusterType(cluster?: string) {\n    return this.getGlobalInfo(cluster).pipe(\n      map(configMap => configMap?.clusterType),\n    );\n  }\n\n  isPublicCloud(cluster?: string) {\n    return this.getClusterType(cluster).pipe(\n      map(clusterType => isPublicCloud(clusterType)),\n    );\n  }\n\n  getClusterArches(cluster?: string) {\n    return this.k8sApi\n      .getGlobalResource({\n        type: RESOURCE_TYPES.CLUSTER,\n        name: cluster,\n        namespaced: true,\n      })\n      .pipe(\n        map(c => {\n          const isArchAmd64 = this.k8sUtil.getLabel(c, 'arch-amd64') === TRUE;\n          const isArchArm64 = this.k8sUtil.getLabel(c, 'arch-arm64') === TRUE;\n          return [\n            ...(isArchAmd64 ? [HARDWARE_ARCHITECTURE_MAPPER.amd64] : []),\n            ...(isArchArm64 ? [HARDWARE_ARCHITECTURE_MAPPER.arm64] : []),\n          ];\n        }),\n      );\n  }\n}\n"]}

package/esm2022/lib/services/feature-gate.service.mjs

@@ -0,0 +1,50 @@
+import { API_GATEWAY, } from '@alauda-fe/common';
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+// http://confluence.alauda.cn/pages/viewpage.action?pageId=54853992
+export class FeatureGateApiService {
+    constructor(http) {
+        this.http = http;
+    }
+    getGlobalGateList() {
+        return this.http.get(`${API_GATEWAY}/fg/v1/featuregates`);
+    }
+    getGlobalGate(name) {
+        return this.http.get(`${API_GATEWAY}/fg/v1/featuregates/${name}`);
+    }
+    getClusterGateList(cluster) {
+        return this.http.get(`${API_GATEWAY}/fg/v1/${cluster}/featuregates`);
+    }
+    getClusterGate(cluster, name) {
+        return this.http.get(`${API_GATEWAY}/fg/v1/${cluster}/featuregates/${name}`);
+    }
+    static { this.ɵfac = function FeatureGateApiService_Factory(t) { return new (t || FeatureGateApiService)(i0.ɵɵinject(i1.HttpClient)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: FeatureGateApiService, factory: FeatureGateApiService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FeatureGateApiService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], () => [{ type: i1.HttpClient }], null); })();
+export function toMap(items) {
+    return items.reduce((acc, curr) => ({
+        ...acc,
+        [curr.metadata.name]: curr.status.enabled,
+    }), {});
+}
+export var DependencyType;
+(function (DependencyType) {
+    DependencyType["Any"] = "any";
+    DependencyType["All"] = "all";
+})(DependencyType || (DependencyType = {}));
+export var FeatureStage;
+(function (FeatureStage) {
+    FeatureStage["Alpha"] = "Alpha";
+    FeatureStage["Beta"] = "Beta";
+    FeatureStage["GA"] = "GA";
+    FeatureStage["EOF"] = "EOF";
+})(FeatureStage || (FeatureStage = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/index.mjs

@@ -0,0 +1,6 @@
+export * from './cluster-api.service';
+export * from './feature-gate.service';
+export * from './pod-util.service';
+export * from './resource-quota.service';
+export * from './terminal.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9tb2R1bGVzL3dvcmtsb2FkL3V0aWwtc2hhcmVkL3NyYy9saWIvc2VydmljZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jbHVzdGVyLWFwaS5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vZmVhdHVyZS1nYXRlLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9wb2QtdXRpbC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vcmVzb3VyY2UtcXVvdGEuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3Rlcm1pbmFsLnNlcnZpY2UnO1xuIl19

package/esm2022/lib/services/pod-util.service.mjs

@@ -0,0 +1,70 @@
+import { DialogService } from '@alauda/ui';
+import { K8sApiService, TRUE, TranslateService, catchPromise, } from '@alauda-fe/common';
+import { Injectable } from '@angular/core';
+import { concatMapTo } from 'rxjs';
+import { RESOURCE_TYPES } from '../typings';
+import { TerminalService } from './terminal.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@alauda/ui";
+import * as i2 from "@alauda-fe/common";
+import * as i3 from "./terminal.service";
+export const DEBUG_CONTAINER_SUFFIX = '-debug';
+export class PodUtilService {
+    constructor(dialog, translate, k8sApi, terminal) {
+        this.dialog = dialog;
+        this.translate = translate;
+        this.k8sApi = k8sApi;
+        this.terminal = terminal;
+    }
+    deletePod(pod, cluster) {
+        return catchPromise(this.dialog.confirm({
+            title: this.translate.get('pod_delete_confirm', {
+                name: pod.metadata.name,
+            }),
+            content: this.translate.get('pod_delete_confirm_hint'),
+            confirmText: this.translate.get('delete'),
+            cancelText: this.translate.get('cancel'),
+        })).pipe(concatMapTo(this.k8sApi.deleteResource({
+            type: RESOURCE_TYPES.POD,
+            cluster,
+            resource: pod,
+        })));
+    }
+    handleExecInfo(pod, container, baseParams, data) {
+        if (!data) {
+            return;
+        }
+        const podName = pod.metadata.name;
+        this.terminal.openTerminal({
+            pods: podName,
+            selectedPod: podName,
+            container: container.name,
+            namespace: pod.metadata.namespace,
+            cluster: baseParams.cluster,
+            user: data.user,
+            command: data.command,
+        });
+    }
+    handleDebugInfo(pod, container, baseParams) {
+        const podName = pod.metadata.name;
+        const containerName = [container.name, DEBUG_CONTAINER_SUFFIX].join('');
+        this.terminal.openTerminal({
+            pods: podName,
+            selectedPod: podName,
+            container: containerName,
+            namespace: pod.metadata.namespace,
+            cluster: baseParams.cluster,
+            // 本期 debug 用户固定，后续支持自定义
+            user: 'root',
+            command: '/bin/sh',
+            isDebug: TRUE,
+        });
+    }
+    static { this.ɵfac = function PodUtilService_Factory(t) { return new (t || PodUtilService)(i0.ɵɵinject(i1.DialogService), i0.ɵɵinject(i2.TranslateService), i0.ɵɵinject(i2.K8sApiService), i0.ɵɵinject(i3.TerminalService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: PodUtilService, factory: PodUtilService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PodUtilService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], () => [{ type: i1.DialogService }, { type: i2.TranslateService }, { type: i2.K8sApiService }, { type: i3.TerminalService }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/resource-quota.service.mjs

@@ -0,0 +1,116 @@
+import { K8sApiService, K8sUtilService, PUBLIC_NAMESPACE, matchLabelsToString, publishRef, skipError, RESOURCE_TYPES, } from '@alauda-fe/common';
+import { Injectable } from '@angular/core';
+import { keys } from 'lodash-es';
+import { forkJoin, map, switchMap } from 'rxjs';
+import { DEFAULT, TYPE } from '../utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@alauda-fe/common";
+export class ResourceQuotaUtilService {
+    constructor(k8sUtil, k8sApi) {
+        this.k8sUtil = k8sUtil;
+        this.k8sApi = k8sApi;
+        this.limitRange$Cache = new Map();
+        this.resourceQuota$Cache = new Map();
+    }
+    getLimitRange$({ cluster, namespace, }) {
+        let limitRange$;
+        const cacheKey = [cluster, namespace].join(',');
+        if ((limitRange$ = this.limitRange$Cache.get(cacheKey))) {
+            return limitRange$;
+        }
+        limitRange$ = this.k8sApi
+            .getResource({
+            cluster,
+            namespace,
+            type: RESOURCE_TYPES.LIMIT_RANGE,
+            name: DEFAULT,
+        })
+            .pipe(skipError(null), publishRef());
+        this.limitRange$Cache.set(cacheKey, limitRange$);
+        return limitRange$;
+    }
+    getAvailableCustomResourceKeysInNodes(workspace) {
+        return this.k8sApi
+            .getResource({
+            type: RESOURCE_TYPES.NAMESPACE,
+            cluster: workspace.cluster,
+            name: workspace.namespace,
+        })
+            .pipe(switchMap(namespace => this.k8sApi
+            .getResourceList({
+            type: RESOURCE_TYPES.NODE,
+            cluster: workspace.cluster,
+        })
+            .pipe(map(({ items }) => {
+            const groupInNamespace = this.k8sUtil.getLabel(namespace, 'node-group-name', 'acp');
+            const availableNodes = items?.filter(node => {
+                const groupInNode = this.k8sUtil.getLabel(node, 'node-group-name', 'acp');
+                const groupInNodeSharedMode = this.k8sUtil.getLabel(node, 'node-group-share-mode', 'acp');
+                return (!groupInNode ||
+                    groupInNodeSharedMode === 'Share' ||
+                    groupInNode === groupInNamespace);
+            });
+            const allocatableInAllNodes = availableNodes?.reduce((acc, curr) => {
+                return {
+                    ...acc,
+                    ...curr?.status?.allocatable,
+                };
+            }, []);
+            return keys(allocatableInAllNodes);
+        }))));
+    }
+    getResourceQuota$({ cluster, namespace }) {
+        let resourceQuota$;
+        const cacheKey = [cluster, namespace].join(',');
+        if ((resourceQuota$ = this.resourceQuota$Cache.get(cacheKey))) {
+            return resourceQuota$;
+        }
+        resourceQuota$ = forkJoin([
+            this.k8sApi
+                .getResourceList({
+                type: RESOURCE_TYPES.CONFIG_MAP,
+                cluster,
+                namespace: PUBLIC_NAMESPACE,
+                queryParams: {
+                    labelSelector: matchLabelsToString({
+                        [this.k8sUtil.normalizeType(TYPE, 'features')]: 'CustomResourceLimitation',
+                    }),
+                },
+            })
+                .pipe(map(res => res.items), skipError([])),
+            this.k8sApi
+                .getResource({
+                type: RESOURCE_TYPES.RESOURCE_QUOTA,
+                cluster,
+                namespace,
+                name: DEFAULT,
+            })
+                .pipe(skipError(null)),
+            this.getAvailableCustomResourceKeysInNodes({
+                namespace,
+                cluster,
+            }),
+        ]).pipe(map(([configMaps, resourceQuota, availableKeys]) => {
+            return {
+                customResourceConfigs: configMaps
+                    .map(c => c.data)
+                    .filter(config => availableKeys.includes(config?.key)),
+                resourceQuota,
+            };
+        }), publishRef());
+        this.resourceQuota$Cache.set(cacheKey, resourceQuota$);
+        return resourceQuota$;
+    }
+    deleteCache({ cluster, namespace }) {
+        const cacheKey = [cluster, namespace].join(',');
+        this.limitRange$Cache.delete(cacheKey);
+        this.resourceQuota$Cache.delete(cacheKey);
+    }
+    static { this.ɵfac = function ResourceQuotaUtilService_Factory(t) { return new (t || ResourceQuotaUtilService)(i0.ɵɵinject(i1.K8sUtilService), i0.ɵɵinject(i1.K8sApiService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ResourceQuotaUtilService, factory: ResourceQuotaUtilService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ResourceQuotaUtilService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], () => [{ type: i1.K8sUtilService }, { type: i1.K8sApiService }], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resource-quota.service.js","sourceRoot":"","sources":["../../../../../../../modules/workload/util-shared/src/lib/services/resource-quota.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  K8sApiService,\n  K8sUtilService,\n  PUBLIC_NAMESPACE,\n  StringMap,\n  matchLabelsToString,\n  publishRef,\n  skipError,\n  LimitRange,\n  ConfigMap,\n  Workspace,\n  Namespace,\n  KubernetesResource,\n  Node,\n  ResourceType,\n  RESOURCE_TYPES,\n  ResourceRequirements,\n} from '@alauda-fe/common';\nimport { Injectable } from '@angular/core';\nimport { keys } from 'lodash-es';\nimport { Observable, forkJoin, map, switchMap } from 'rxjs';\n\nimport { DEFAULT, TYPE } from '../utils';\n\n@Injectable({ providedIn: 'root' })\nexport class ResourceQuotaUtilService {\n  private readonly limitRange$Cache = new Map<string, Observable<LimitRange>>();\n  private readonly resourceQuota$Cache = new Map<\n    string,\n    Observable<{\n      resourceQuota: ResourceRequirements;\n      customResourceConfigs: StringMap[];\n    }>\n  >();\n\n  constructor(\n    private readonly k8sUtil: K8sUtilService,\n    private readonly k8sApi: K8sApiService<ResourceType>,\n  ) {}\n\n  getLimitRange$({\n    cluster,\n    namespace,\n  }: {\n    cluster: string;\n    namespace: string;\n  }) {\n    let limitRange$: Observable<LimitRange>;\n\n    const cacheKey = [cluster, namespace].join(',');\n\n    if ((limitRange$ = this.limitRange$Cache.get(cacheKey))) {\n      return limitRange$;\n    }\n\n    limitRange$ = this.k8sApi\n      .getResource<LimitRange>({\n        cluster,\n        namespace,\n        type: RESOURCE_TYPES.LIMIT_RANGE,\n        name: DEFAULT,\n      })\n      .pipe(skipError(null as LimitRange), publishRef());\n\n    this.limitRange$Cache.set(cacheKey, limitRange$);\n\n    return limitRange$;\n  }\n\n  getAvailableCustomResourceKeysInNodes(\n    workspace: Workspace,\n  ): Observable<string[]> {\n    return this.k8sApi\n      .getResource<Namespace>({\n        type: RESOURCE_TYPES.NAMESPACE,\n        cluster: workspace.cluster,\n        name: workspace.namespace,\n      })\n      .pipe(\n        switchMap(namespace =>\n          this.k8sApi\n            .getResourceList<Node>({\n              type: RESOURCE_TYPES.NODE,\n              cluster: workspace.cluster,\n            })\n            .pipe(\n              map(({ items }) => {\n                const groupInNamespace = this.k8sUtil.getLabel(\n                  namespace,\n                  'node-group-name',\n                  'acp',\n                );\n                const availableNodes = items?.filter(node => {\n                  const groupInNode = this.k8sUtil.getLabel(\n                    node as KubernetesResource,\n                    'node-group-name',\n                    'acp',\n                  );\n                  const groupInNodeSharedMode = this.k8sUtil.getLabel(\n                    node as KubernetesResource,\n                    'node-group-share-mode',\n                    'acp',\n                  );\n                  return (\n                    !groupInNode ||\n                    groupInNodeSharedMode === 'Share' ||\n                    groupInNode === groupInNamespace\n                  );\n                });\n                const allocatableInAllNodes = availableNodes?.reduce(\n                  (acc, curr) => {\n                    return {\n                      ...acc,\n                      ...curr?.status?.allocatable,\n                    };\n                  },\n                  [] as string[],\n                );\n                return keys(allocatableInAllNodes);\n              }),\n            ),\n        ),\n      );\n  }\n\n  getResourceQuota$({ cluster, namespace }: Workspace) {\n    let resourceQuota$: Observable<{\n      resourceQuota: ResourceRequirements;\n      customResourceConfigs: StringMap[];\n    }>;\n\n    const cacheKey = [cluster, namespace].join(',');\n\n    if ((resourceQuota$ = this.resourceQuota$Cache.get(cacheKey))) {\n      return resourceQuota$;\n    }\n\n    resourceQuota$ = forkJoin([\n      this.k8sApi\n        .getResourceList<ConfigMap>({\n          type: RESOURCE_TYPES.CONFIG_MAP,\n          cluster,\n          namespace: PUBLIC_NAMESPACE,\n          queryParams: {\n            labelSelector: matchLabelsToString({\n              [this.k8sUtil.normalizeType(TYPE, 'features')]:\n                'CustomResourceLimitation',\n            }),\n          },\n        })\n        .pipe(\n          map(res => res.items),\n          skipError([] as ConfigMap[]),\n        ),\n      this.k8sApi\n        .getResource<any>({\n          type: RESOURCE_TYPES.RESOURCE_QUOTA,\n          cluster,\n          namespace,\n          name: DEFAULT,\n        })\n        .pipe(skipError(null as ResourceRequirements)),\n      this.getAvailableCustomResourceKeysInNodes({\n        namespace,\n        cluster,\n      } as Workspace),\n    ]).pipe(\n      map(([configMaps, resourceQuota, availableKeys]) => {\n        return {\n          customResourceConfigs: configMaps\n            .map(c => c.data)\n            .filter(config => availableKeys.includes(config?.key)),\n          resourceQuota,\n        };\n      }),\n      publishRef(),\n    );\n\n    this.resourceQuota$Cache.set(cacheKey, resourceQuota$);\n\n    return resourceQuota$;\n  }\n\n  deleteCache({ cluster, namespace }: { cluster: string; namespace: string }) {\n    const cacheKey = [cluster, namespace].join(',');\n    this.limitRange$Cache.delete(cacheKey);\n    this.resourceQuota$Cache.delete(cacheKey);\n  }\n}\n"]}