@alauda-fe/storage 0.0.1

package/esm2022/lib/components/storage-feature-tags/component.mjs

@@ -0,0 +1,146 @@
+import { __decorate, __metadata } from "tslib";
+import { TagModule } from '@alauda/ui';
+import { ObservableInput, publishRef, K8sUtilService, TRANSLATE_MODULE, } from '@alauda-fe/common';
+import { AsyncPipe, NgFor, NgIf } from '@angular/common';
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import { Observable, combineLatest, map, startWith } from 'rxjs';
+import { StorageCommonUtilService } from '../../services/common-util.service';
+import { StorageProvisioner, StorageclassFeature } from '../../types/commons';
+import { STORAGE_OPTION_MAP, CSI_TOP_SNAPSHOTCLASS_NAME, } from '../../utils/constants';
+import * as i0 from "@angular/core";
+import * as i1 from "@alauda-fe/common";
+import * as i2 from "../../services/common-util.service";
+import * as i3 from "@alauda/ui";
+function StorageFeatureTagsComponent_ng_container_0_aui_tag_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "aui-tag", 3);
+    i0.ɵɵtext(1);
+    i0.ɵɵpipe(2, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    i0.ɵɵproperty("border", true);
+    i0.ɵɵadvance();
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(2, 2, "default"), " ");
+} }
+function StorageFeatureTagsComponent_ng_container_0_aui_tag_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "aui-tag", 4);
+    i0.ɵɵtext(1);
+    i0.ɵɵpipe(2, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const tag_r1 = ctx.$implicit;
+    i0.ɵɵproperty("border", true);
+    i0.ɵɵadvance();
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(2, 2, "storage." + tag_r1));
+} }
+function StorageFeatureTagsComponent_ng_container_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵtemplate(1, StorageFeatureTagsComponent_ng_container_0_aui_tag_1_Template, 3, 4, "aui-tag", 1)(2, StorageFeatureTagsComponent_ng_container_0_aui_tag_2_Template, 3, 4, "aui-tag", 2);
+    i0.ɵɵpipe(3, "async");
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("ngIf", ctx_r1.hasDefault);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("ngForOf", i0.ɵɵpipeBind1(3, 2, ctx_r1.features$));
+} }
+export class StorageFeatureTagsComponent {
+    constructor(k8sUtil, storageUtil) {
+        this.k8sUtil = k8sUtil;
+        this.storageUtil = storageUtil;
+        this.features$ = combineLatest([
+            this.provisioner$,
+            this.storageClass$,
+            this.volumeSnapshotClasses$.pipe(startWith([])),
+            this.storageUtil.storageDescriptionMapCache.fetch(null),
+        ]).pipe(map(([provisioner, storageClass, volumeSnapshotClasses, storageDescriptionMaps,]) => {
+            const features = this.k8sUtil
+                .getAnnotation(storageClass, 'features')
+                ?.split(',');
+            // 存储类列表不再依赖卷快照类，这里展示 features 完整的能力，参见 https://jira.alauda.cn/browse/ACP-31043 comment
+            const featuresSet = new Set(features);
+            this.updateStorageClassFeature(featuresSet, provisioner, storageClass);
+            this.updateVolumeSnapshotFeature(featuresSet, provisioner, storageClass, volumeSnapshotClasses);
+            this.updateThirdPartySnapshotFeature(featuresSet, storageClass, storageDescriptionMaps);
+            return Array.from(featuresSet);
+        }), map(features => features.filter(Boolean)), publishRef());
+    }
+    updateStorageClassFeature(featuresSet, provisioner, storageClass) {
+        if (storageClass) {
+            storageClass.allowVolumeExpansion
+                ? featuresSet.add(StorageclassFeature.EXPANSION)
+                : featuresSet.delete(StorageclassFeature.EXPANSION);
+        }
+        else {
+            STORAGE_OPTION_MAP[provisioner]?.features?.forEach(feature => {
+                featuresSet.add(feature);
+            });
+        }
+    }
+    updateVolumeSnapshotFeature(featuresSet, provisioner, storageClass, volumeSnapshotClasses) {
+        if (!volumeSnapshotClasses?.length) {
+            return;
+        }
+        this.hasVolumeSnapshotFeature(provisioner, storageClass, volumeSnapshotClasses)
+            ? featuresSet.add(StorageclassFeature.SNAPSHOT)
+            : featuresSet.delete(StorageclassFeature.SNAPSHOT);
+    }
+    hasVolumeSnapshotFeature(provisioner, storageClass, volumeSnapshotClasses) {
+        switch (provisioner) {
+            case StorageProvisioner.CEPH_FS_INTERNAL:
+            case StorageProvisioner.CEPH_FS_RBD: {
+                return volumeSnapshotClasses?.some(item => item.parameters?.clusterID ===
+                    storageClass?.parameters?.clusterID &&
+                    item.driver === provisioner);
+            }
+            case StorageProvisioner.TOPOLVM: {
+                return volumeSnapshotClasses?.some(item => item.metadata.name === CSI_TOP_SNAPSHOTCLASS_NAME);
+            }
+        }
+    }
+    updateThirdPartySnapshotFeature(featuresSet, storageClass, storageDescriptionMaps) {
+        const thirdPartySnapshot = this.storageUtil.getThirdPartySnapshotSupported(storageClass, storageDescriptionMaps);
+        // null 表示未匹配到第三方存储
+        if (thirdPartySnapshot === null) {
+            return;
+        }
+        thirdPartySnapshot
+            ? featuresSet.add(StorageclassFeature.SNAPSHOT)
+            : featuresSet.delete(StorageclassFeature.SNAPSHOT);
+    }
+    static { this.ɵfac = function StorageFeatureTagsComponent_Factory(t) { return new (t || StorageFeatureTagsComponent)(i0.ɵɵdirectiveInject(i1.K8sUtilService), i0.ɵɵdirectiveInject(i2.StorageCommonUtilService)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: StorageFeatureTagsComponent, selectors: [["acl-storage-feature-tags"]], inputs: { provisioner: "provisioner", storageClass: "storageClass", hasDefault: "hasDefault", volumeSnapshotClasses: "volumeSnapshotClasses" }, standalone: true, features: [i0.ɵɵStandaloneFeature], decls: 2, vars: 3, consts: [[4, "ngIf"], ["type", "success", "size", "mini", 3, "border", 4, "ngIf"], ["type", "info", "size", "mini", 3, "border", 4, "ngFor", "ngForOf"], ["type", "success", "size", "mini", 3, "border"], ["type", "info", "size", "mini", 3, "border"]], template: function StorageFeatureTagsComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵtemplate(0, StorageFeatureTagsComponent_ng_container_0_Template, 4, 4, "ng-container", 0);
+            i0.ɵɵpipe(1, "async");
+        } if (rf & 2) {
+            let tmp_0_0;
+            i0.ɵɵproperty("ngIf", ((tmp_0_0 = i0.ɵɵpipeBind1(1, 1, ctx.features$)) == null ? null : tmp_0_0.length) || ctx.hasDefault);
+        } }, dependencies: [AsyncPipe, NgIf, NgFor, TagModule, i3.TagComponent, i1.TranslatePipe], encapsulation: 2, changeDetection: 0 }); }
+}
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], StorageFeatureTagsComponent.prototype, "provisioner$", void 0);
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], StorageFeatureTagsComponent.prototype, "storageClass$", void 0);
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], StorageFeatureTagsComponent.prototype, "volumeSnapshotClasses$", void 0);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(StorageFeatureTagsComponent, [{
+        type: Component,
+        args: [{ selector: 'acl-storage-feature-tags', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [AsyncPipe, NgIf, NgFor, TagModule, TRANSLATE_MODULE], template: "<ng-container *ngIf=\"(features$ | async)?.length || hasDefault\">\n  <aui-tag\n    *ngIf=\"hasDefault\"\n    type=\"success\"\n    size=\"mini\"\n    [border]=\"true\"\n  >\n    {{ 'default' | translate }}\n  </aui-tag>\n  <aui-tag\n    type=\"info\"\n    size=\"mini\"\n    [border]=\"true\"\n    *ngFor=\"let tag of features$ | async\"\n    >{{ 'storage.' + tag | translate }}</aui-tag\n  >\n</ng-container>\n" }]
+    }], () => [{ type: i1.K8sUtilService }, { type: i2.StorageCommonUtilService }], { provisioner: [{
+            type: Input,
+            args: [{ required: true }]
+        }], provisioner$: [], storageClass: [{
+            type: Input
+        }], storageClass$: [], hasDefault: [{
+            type: Input
+        }], volumeSnapshotClasses: [{
+            type: Input
+        }], volumeSnapshotClasses$: [] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(StorageFeatureTagsComponent, { className: "StorageFeatureTagsComponent", filePath: "lib/components/storage-feature-tags/component.ts", lineNumber: 28 }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component.js","sourceRoot":"","sources":["../../../../../../../modules/storage/src/lib/components/storage-feature-tags/component.ts","../../../../../../../modules/storage/src/lib/components/storage-feature-tags/template.html"],"names":[],"mappings":"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","sourcesContent":["import { TagModule } from '@alauda/ui';\nimport {\n  ObservableInput,\n  publishRef,\n  K8sUtilService,\n  StringMap,\n  TRANSLATE_MODULE,\n} from '@alauda-fe/common';\nimport { AsyncPipe, NgFor, NgIf } from '@angular/common';\nimport { ChangeDetectionStrategy, Component, Input } from '@angular/core';\nimport { Observable, combineLatest, map, startWith } from 'rxjs';\n\nimport { StorageCommonUtilService } from '../../services/common-util.service';\nimport { StorageProvisioner, StorageclassFeature } from '../../types/commons';\nimport { StorageClass, VolumeSnapshotClass } from '../../types/k8s';\nimport {\n  STORAGE_OPTION_MAP,\n  CSI_TOP_SNAPSHOTCLASS_NAME,\n} from '../../utils/constants';\n\n@Component({\n  selector: 'acl-storage-feature-tags',\n  templateUrl: 'template.html',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n  imports: [AsyncPipe, NgIf, NgFor, TagModule, TRANSLATE_MODULE],\n})\nexport class StorageFeatureTagsComponent {\n  @Input({ required: true })\n  provisioner: StorageProvisioner;\n\n  @ObservableInput()\n  provisioner$!: Observable<StorageProvisioner>;\n\n  @Input()\n  storageClass: StorageClass;\n\n  @ObservableInput()\n  storageClass$!: Observable<StorageClass>;\n\n  @Input()\n  hasDefault: boolean;\n\n  @Input()\n  volumeSnapshotClasses: VolumeSnapshotClass[];\n\n  @ObservableInput()\n  volumeSnapshotClasses$!: Observable<VolumeSnapshotClass[]>;\n\n  features$ = combineLatest([\n    this.provisioner$,\n    this.storageClass$,\n    this.volumeSnapshotClasses$.pipe(startWith([] as VolumeSnapshotClass[])),\n    this.storageUtil.storageDescriptionMapCache.fetch(null),\n  ]).pipe(\n    map(\n      ([\n        provisioner,\n        storageClass,\n        volumeSnapshotClasses,\n        storageDescriptionMaps,\n      ]) => {\n        const features = this.k8sUtil\n          .getAnnotation(storageClass, 'features')\n          ?.split(',') as StorageclassFeature[];\n        // 存储类列表不再依赖卷快照类，这里展示 features 完整的能力，参见 https://jira.alauda.cn/browse/ACP-31043 comment\n        const featuresSet = new Set(features);\n\n        this.updateStorageClassFeature(featuresSet, provisioner, storageClass);\n        this.updateVolumeSnapshotFeature(\n          featuresSet,\n          provisioner,\n          storageClass,\n          volumeSnapshotClasses,\n        );\n        this.updateThirdPartySnapshotFeature(\n          featuresSet,\n          storageClass,\n          storageDescriptionMaps,\n        );\n\n        return Array.from(featuresSet);\n      },\n    ),\n    map(features => features.filter(Boolean)),\n    publishRef(),\n  );\n\n  constructor(\n    private readonly k8sUtil: K8sUtilService,\n    private readonly storageUtil: StorageCommonUtilService,\n  ) {}\n\n  private updateStorageClassFeature(\n    featuresSet: Set<string>,\n    provisioner: StorageProvisioner,\n    storageClass: StorageClass | null,\n  ) {\n    if (storageClass) {\n      storageClass.allowVolumeExpansion\n        ? featuresSet.add(StorageclassFeature.EXPANSION)\n        : featuresSet.delete(StorageclassFeature.EXPANSION);\n    } else {\n      STORAGE_OPTION_MAP[provisioner]?.features?.forEach(feature => {\n        featuresSet.add(feature);\n      });\n    }\n  }\n\n  private updateVolumeSnapshotFeature(\n    featuresSet: Set<string>,\n    provisioner: StorageProvisioner,\n    storageClass: StorageClass | null,\n    volumeSnapshotClasses: VolumeSnapshotClass[],\n  ) {\n    if (!volumeSnapshotClasses?.length) {\n      return;\n    }\n\n    this.hasVolumeSnapshotFeature(\n      provisioner,\n      storageClass,\n      volumeSnapshotClasses,\n    )\n      ? featuresSet.add(StorageclassFeature.SNAPSHOT)\n      : featuresSet.delete(StorageclassFeature.SNAPSHOT);\n  }\n\n  private hasVolumeSnapshotFeature(\n    provisioner: StorageProvisioner,\n    storageClass: StorageClass,\n    volumeSnapshotClasses: VolumeSnapshotClass[],\n  ) {\n    switch (provisioner) {\n      case StorageProvisioner.CEPH_FS_INTERNAL:\n      case StorageProvisioner.CEPH_FS_RBD: {\n        return volumeSnapshotClasses?.some(\n          item =>\n            item.parameters?.clusterID ===\n              storageClass?.parameters?.clusterID &&\n            item.driver === provisioner,\n        );\n      }\n      case StorageProvisioner.TOPOLVM: {\n        return volumeSnapshotClasses?.some(\n          item => item.metadata.name === CSI_TOP_SNAPSHOTCLASS_NAME,\n        );\n      }\n    }\n  }\n\n  private updateThirdPartySnapshotFeature(\n    featuresSet: Set<string>,\n    storageClass: StorageClass,\n    storageDescriptionMaps: StringMap[],\n  ) {\n    const thirdPartySnapshot = this.storageUtil.getThirdPartySnapshotSupported(\n      storageClass,\n      storageDescriptionMaps,\n    );\n\n    // null 表示未匹配到第三方存储\n    if (thirdPartySnapshot === null) {\n      return;\n    }\n\n    thirdPartySnapshot\n      ? featuresSet.add(StorageclassFeature.SNAPSHOT)\n      : featuresSet.delete(StorageclassFeature.SNAPSHOT);\n  }\n}\n","<ng-container *ngIf=\"(features$ | async)?.length || hasDefault\">\n  <aui-tag\n    *ngIf=\"hasDefault\"\n    type=\"success\"\n    size=\"mini\"\n    [border]=\"true\"\n  >\n    {{ 'default' | translate }}\n  </aui-tag>\n  <aui-tag\n    type=\"info\"\n    size=\"mini\"\n    [border]=\"true\"\n    *ngFor=\"let tag of features$ | async\"\n    >{{ 'storage.' + tag | translate }}</aui-tag\n  >\n</ng-container>\n"]}

package/esm2022/lib/components/storageclass-select/component.mjs

@@ -0,0 +1,179 @@
+import { __decorate, __metadata } from "tslib";
+import { SelectModule, coerceAttrBoolean } from '@alauda/ui';
+import { FieldNotAvailablePipe, ObservableInput, PurePipe, ReadonlyFieldDirective, TranslateModule, publishRef, } from '@alauda-fe/common';
+import { AsyncPipe, NgFor, NgIf, NgTemplateOutlet } from '@angular/common';
+import { Component, ChangeDetectionStrategy, inject, Input, Output, EventEmitter, } from '@angular/core';
+import { ReactiveFormsModule } from '@angular/forms';
+import { BaseResourceFormComponent } from 'ng-resource-form-util';
+import { Observable, combineLatest, filter, map, tap } from 'rxjs';
+import { StorageCommonUtilService, } from '../../services/common-util.service';
+import { StorageFeatureTagsComponent } from '../storage-feature-tags/component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@alauda/ui";
+import * as i3 from "@alauda-fe/common";
+const _c0 = a0 => ({ storageClassOptions: a0 });
+const _c1 = a0 => ({ option: a0 });
+function StorageClassSelectComponent_aui_select_0_aui_option_2_ng_container_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainer(0);
+} }
+function StorageClassSelectComponent_aui_select_0_aui_option_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "aui-option", 6);
+    i0.ɵɵtemplate(1, StorageClassSelectComponent_aui_select_0_aui_option_2_ng_container_1_Template, 1, 0, "ng-container", 7);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const option_r4 = ctx.$implicit;
+    i0.ɵɵnextContext(2);
+    const storageClassLabel_r5 = i0.ɵɵreference(3);
+    i0.ɵɵproperty("value", option_r4.value)("label", storageClassLabel_r5)("labelContext", i0.ɵɵpureFunction1(5, _c1, option_r4));
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("ngTemplateOutlet", storageClassLabel_r5)("ngTemplateOutletContext", i0.ɵɵpureFunction1(7, _c1, option_r4));
+} }
+function StorageClassSelectComponent_aui_select_0_Template(rf, ctx) { if (rf & 1) {
+    const _r1 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "aui-select", 4);
+    i0.ɵɵpipe(1, "translate");
+    i0.ɵɵlistener("ngModelChange", function StorageClassSelectComponent_aui_select_0_Template_aui_select_ngModelChange_0_listener($event) { const __r2 = i0.ɵɵrestoreView(_r1).ngIf; const ctx_r2 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r2.onStorageClassChange($event, __r2.storageClassOptions)); });
+    i0.ɵɵtemplate(2, StorageClassSelectComponent_aui_select_0_aui_option_2_Template, 2, 9, "aui-option", 5);
+    i0.ɵɵelementStart(3, "aui-option-placeholder");
+    i0.ɵɵtext(4);
+    i0.ɵɵpipe(5, "translate");
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    const __r2 = ctx.ngIf;
+    const ctx_r2 = i0.ɵɵnextContext();
+    const storageClassTmpl_r6 = i0.ɵɵreference(5);
+    i0.ɵɵproperty("required", ctx_r2.required)("formControl", ctx_r2.form)("clearable", !ctx_r2.required)("placeholder", i0.ɵɵpipeBind1(1, 8, "storage.select_storageclass"))("aclReadonlyField", ctx_r2.isFromSnapshot)("aclReadonlyFieldTemplate", storageClassTmpl_r6);
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("ngForOf", __r2.storageClassOptions);
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(5, 10, "no_data"), " ");
+} }
+function StorageClassSelectComponent_ng_template_2_ng_container_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelementStart(1, "span", 9);
+    i0.ɵɵtext(2);
+    i0.ɵɵelementEnd();
+    i0.ɵɵelement(3, "acl-storage-feature-tags", 10);
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const option_r7 = i0.ɵɵnextContext().option;
+    const ctx_r2 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate(option_r7.key);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("provisioner", option_r7.provisioner)("storageClass", option_r7.storageClass)("hasDefault", option_r7.isDefault)("volumeSnapshotClasses", ctx_r2.volumeSnapshotClasses);
+} }
+function StorageClassSelectComponent_ng_template_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵtemplate(0, StorageClassSelectComponent_ng_template_2_ng_container_0_Template, 4, 5, "ng-container", 8);
+} if (rf & 2) {
+    const option_r7 = ctx.option;
+    i0.ɵɵnextContext();
+    const empty_r8 = i0.ɵɵreference(7);
+    i0.ɵɵproperty("ngIf", option_r7)("ngIfElse", empty_r8);
+} }
+function StorageClassSelectComponent_ng_template_4_ng_container_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainer(0);
+} }
+function StorageClassSelectComponent_ng_template_4_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵtemplate(0, StorageClassSelectComponent_ng_template_4_ng_container_0_Template, 1, 0, "ng-container", 7);
+    i0.ɵɵpipe(1, "async");
+    i0.ɵɵpipe(2, "pure");
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext();
+    const storageClassLabel_r5 = i0.ɵɵreference(3);
+    i0.ɵɵproperty("ngTemplateOutlet", storageClassLabel_r5)("ngTemplateOutletContext", i0.ɵɵpureFunction1(8, _c1, i0.ɵɵpipeBind3(2, 4, ctx_r2.form.value, ctx_r2.getStorageClassOption, i0.ɵɵpipeBind1(1, 2, ctx_r2.storageClassOptions$))));
+} }
+function StorageClassSelectComponent_ng_template_6_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵtext(0);
+    i0.ɵɵpipe(1, "aclFieldNotAvailable");
+} if (rf & 2) {
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(1, 1, null));
+} }
+export class StorageClassSelectComponent extends BaseResourceFormComponent {
+    constructor() {
+        super(...arguments);
+        this.selectDefault = true;
+        this.storageClassChange = new EventEmitter();
+        this.storageCommonUtil = inject(StorageCommonUtilService);
+        this.storageClassOptions$ = combineLatest([
+            this.storageClasses$.pipe(filter(list => !!list)),
+            this.storageCommonUtil.storageDescriptionMapCache.fetch(null),
+        ]).pipe(map(([storageClasses, storageDescriptionMaps]) => storageClasses.map(item => this.storageCommonUtil.mapToStorageClassOption(item, storageDescriptionMaps, this.isFromSnapshot))), tap(items => {
+            if (this.selectDefault && !this.isFromSnapshot && !this.form.value) {
+                const defaultSc = items.find(item => item.isDefault);
+                if (defaultSc) {
+                    this.form.setValue(defaultSc.value);
+                }
+            }
+            this.onStorageClassChange(this.form.value, items);
+        }), publishRef());
+        this.errorsInDetail = true;
+    }
+    set required(value) {
+        this._required = coerceAttrBoolean(value);
+    }
+    get required() {
+        return this._required;
+    }
+    createForm() {
+        return this.fb.control('');
+    }
+    getStorageClassOption(value, options) {
+        return options?.find(option => option.value === value);
+    }
+    onStorageClassChange(storageClassName, storageClassOptions) {
+        const storageClassOption = this.getStorageClassOption(storageClassName, storageClassOptions);
+        this.storageClassChange.emit(storageClassOption);
+    }
+    static { this.ɵfac = /*@__PURE__*/ (() => { let ɵStorageClassSelectComponent_BaseFactory; return function StorageClassSelectComponent_Factory(t) { return (ɵStorageClassSelectComponent_BaseFactory || (ɵStorageClassSelectComponent_BaseFactory = i0.ɵɵgetInheritedFactory(StorageClassSelectComponent)))(t || StorageClassSelectComponent); }; })(); }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: StorageClassSelectComponent, selectors: [["acl-storageclass-select"]], inputs: { storageClasses: "storageClasses", required: "required", volumeSnapshotClasses: "volumeSnapshotClasses", selectDefault: "selectDefault", isFromSnapshot: "isFromSnapshot" }, outputs: { storageClassChange: "storageClassChange" }, standalone: true, features: [i0.ɵɵInheritDefinitionFeature, i0.ɵɵStandaloneFeature], decls: 8, vars: 5, consts: [["storageClassLabel", ""], ["storageClassTmpl", ""], ["empty", ""], [3, "required", "formControl", "clearable", "placeholder", "aclReadonlyField", "aclReadonlyFieldTemplate", "ngModelChange", 4, "ngIf"], [3, "ngModelChange", "required", "formControl", "clearable", "placeholder", "aclReadonlyField", "aclReadonlyFieldTemplate"], [3, "value", "label", "labelContext", 4, "ngFor", "ngForOf"], [3, "value", "label", "labelContext"], [4, "ngTemplateOutlet", "ngTemplateOutletContext"], [4, "ngIf", "ngIfElse"], [1, "tw-mr-8"], [3, "provisioner", "storageClass", "hasDefault", "volumeSnapshotClasses"]], template: function StorageClassSelectComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵtemplate(0, StorageClassSelectComponent_aui_select_0_Template, 6, 12, "aui-select", 3);
+            i0.ɵɵpipe(1, "async");
+            i0.ɵɵtemplate(2, StorageClassSelectComponent_ng_template_2_Template, 1, 2, "ng-template", null, 0, i0.ɵɵtemplateRefExtractor)(4, StorageClassSelectComponent_ng_template_4_Template, 3, 10, "ng-template", null, 1, i0.ɵɵtemplateRefExtractor)(6, StorageClassSelectComponent_ng_template_6_Template, 2, 3, "ng-template", null, 2, i0.ɵɵtemplateRefExtractor);
+        } if (rf & 2) {
+            i0.ɵɵproperty("ngIf", i0.ɵɵpureFunction1(3, _c0, i0.ɵɵpipeBind1(1, 1, ctx.storageClassOptions$)));
+        } }, dependencies: [AsyncPipe,
+            NgIf,
+            NgFor,
+            NgTemplateOutlet,
+            ReactiveFormsModule, i1.NgControlStatus, i1.RequiredValidator, i1.FormControlDirective, SelectModule, i2.SelectComponent, i2.OptionComponent, i2.OptionPlaceholderComponent, PurePipe,
+            FieldNotAvailablePipe,
+            TranslateModule, i3.TranslatePipe, ReadonlyFieldDirective,
+            StorageFeatureTagsComponent], encapsulation: 2, changeDetection: 0 }); }
+}
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], StorageClassSelectComponent.prototype, "storageClasses$", void 0);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(StorageClassSelectComponent, [{
+        type: Component,
+        args: [{ selector: 'acl-storageclass-select', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [
+                    AsyncPipe,
+                    NgIf,
+                    NgFor,
+                    NgTemplateOutlet,
+                    ReactiveFormsModule,
+                    SelectModule,
+                    PurePipe,
+                    FieldNotAvailablePipe,
+                    TranslateModule,
+                    ReadonlyFieldDirective,
+                    StorageFeatureTagsComponent,
+                ], template: "<aui-select\n  *ngIf=\"{ storageClassOptions: storageClassOptions$ | async } as _\"\n  [required]=\"required\"\n  [formControl]=\"form\"\n  [clearable]=\"!required\"\n  [placeholder]=\"'storage.select_storageclass' | translate\"\n  [aclReadonlyField]=\"isFromSnapshot\"\n  [aclReadonlyFieldTemplate]=\"storageClassTmpl\"\n  (ngModelChange)=\"onStorageClassChange($event, _.storageClassOptions)\"\n>\n  <aui-option\n    *ngFor=\"let option of _.storageClassOptions\"\n    [value]=\"option.value\"\n    [label]=\"storageClassLabel\"\n    [labelContext]=\"{ option }\"\n  >\n    <ng-container\n      *ngTemplateOutlet=\"storageClassLabel; context: { option }\"\n    ></ng-container>\n  </aui-option>\n  <aui-option-placeholder>\n    {{ 'no_data' | translate }}\n  </aui-option-placeholder>\n</aui-select>\n\n<ng-template\n  #storageClassLabel\n  let-option=\"option\"\n>\n  <ng-container *ngIf=\"option; else empty\">\n    <span class=\"tw-mr-8\">{{ option.key }}</span>\n    <acl-storage-feature-tags\n      [provisioner]=\"option.provisioner\"\n      [storageClass]=\"option.storageClass\"\n      [hasDefault]=\"option.isDefault\"\n      [volumeSnapshotClasses]=\"volumeSnapshotClasses\"\n    ></acl-storage-feature-tags>\n  </ng-container>\n</ng-template>\n\n<ng-template #storageClassTmpl>\n  <ng-container\n    *ngTemplateOutlet=\"\n      storageClassLabel;\n      context: {\n        option:form.value | pure: getStorageClassOption:(storageClassOptions$ | async)\n      }\n    \"\n  ></ng-container>\n</ng-template>\n\n<ng-template #empty>{{ null | aclFieldNotAvailable }}</ng-template>\n" }]
+    }], null, { storageClasses: [{
+            type: Input,
+            args: [{ required: true }]
+        }], storageClasses$: [], required: [{
+            type: Input
+        }], volumeSnapshotClasses: [{
+            type: Input
+        }], selectDefault: [{
+            type: Input
+        }], isFromSnapshot: [{
+            type: Input
+        }], storageClassChange: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(StorageClassSelectComponent, { className: "StorageClassSelectComponent", filePath: "lib/components/storageclass-select/component.ts", lineNumber: 49 }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component.js","sourceRoot":"","sources":["../../../../../../../modules/storage/src/lib/components/storageclass-select/component.ts","../../../../../../../modules/storage/src/lib/components/storageclass-select/template.html"],"names":[],"mappings":"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","sourcesContent":["import { AttrBoolean, SelectModule, coerceAttrBoolean } from '@alauda/ui';\nimport {\n  FieldNotAvailablePipe,\n  ObservableInput,\n  PurePipe,\n  ReadonlyFieldDirective,\n  TranslateModule,\n  publishRef,\n} from '@alauda-fe/common';\nimport { AsyncPipe, NgFor, NgIf, NgTemplateOutlet } from '@angular/common';\nimport {\n  Component,\n  ChangeDetectionStrategy,\n  inject,\n  Input,\n  Output,\n  EventEmitter,\n} from '@angular/core';\nimport { ReactiveFormsModule } from '@angular/forms';\nimport { BaseResourceFormComponent } from 'ng-resource-form-util';\nimport { Observable, combineLatest, filter, map, tap } from 'rxjs';\n\nimport {\n  StorageCommonUtilService,\n  StorageSelectOption,\n} from '../../services/common-util.service';\nimport { StorageClass, VolumeSnapshotClass } from '../../types/k8s';\nimport { StorageFeatureTagsComponent } from '../storage-feature-tags/component';\n\n@Component({\n  selector: 'acl-storageclass-select',\n  templateUrl: 'template.html',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n  imports: [\n    AsyncPipe,\n    NgIf,\n    NgFor,\n    NgTemplateOutlet,\n    ReactiveFormsModule,\n    SelectModule,\n    PurePipe,\n    FieldNotAvailablePipe,\n    TranslateModule,\n    ReadonlyFieldDirective,\n    StorageFeatureTagsComponent,\n  ],\n})\nexport class StorageClassSelectComponent extends BaseResourceFormComponent<string> {\n  @Input({ required: true })\n  storageClasses: StorageClass[];\n\n  @ObservableInput()\n  storageClasses$!: Observable<StorageClass[]>;\n\n  @Input()\n  set required(value: AttrBoolean) {\n    this._required = coerceAttrBoolean(value);\n  }\n\n  get required() {\n    return this._required;\n  }\n\n  @Input()\n  volumeSnapshotClasses: VolumeSnapshotClass[];\n\n  @Input()\n  selectDefault = true;\n\n  @Input()\n  isFromSnapshot: boolean;\n\n  @Output()\n  storageClassChange = new EventEmitter<StorageSelectOption>();\n\n  storageCommonUtil = inject(StorageCommonUtilService);\n\n  storageClassOptions$ = combineLatest([\n    this.storageClasses$.pipe(filter(list => !!list)),\n    this.storageCommonUtil.storageDescriptionMapCache.fetch(null),\n  ]).pipe(\n    map(([storageClasses, storageDescriptionMaps]) =>\n      storageClasses.map(item =>\n        this.storageCommonUtil.mapToStorageClassOption(\n          item,\n          storageDescriptionMaps,\n          this.isFromSnapshot,\n        ),\n      ),\n    ),\n    tap(items => {\n      if (this.selectDefault && !this.isFromSnapshot && !this.form.value) {\n        const defaultSc = items.find(item => item.isDefault);\n        if (defaultSc) {\n          this.form.setValue(defaultSc.value);\n        }\n      }\n      this.onStorageClassChange(this.form.value, items);\n    }),\n    publishRef(),\n  );\n\n  private _required: boolean;\n\n  override createForm() {\n    return this.fb.control('');\n  }\n\n  override errorsInDetail = true;\n\n  getStorageClassOption(value: string, options?: StorageSelectOption[]) {\n    return options?.find(option => option.value === value);\n  }\n\n  onStorageClassChange(\n    storageClassName: string,\n    storageClassOptions?: StorageSelectOption[],\n  ) {\n    const storageClassOption = this.getStorageClassOption(\n      storageClassName,\n      storageClassOptions,\n    );\n    this.storageClassChange.emit(storageClassOption);\n  }\n}\n","<aui-select\n  *ngIf=\"{ storageClassOptions: storageClassOptions$ | async } as _\"\n  [required]=\"required\"\n  [formControl]=\"form\"\n  [clearable]=\"!required\"\n  [placeholder]=\"'storage.select_storageclass' | translate\"\n  [aclReadonlyField]=\"isFromSnapshot\"\n  [aclReadonlyFieldTemplate]=\"storageClassTmpl\"\n  (ngModelChange)=\"onStorageClassChange($event, _.storageClassOptions)\"\n>\n  <aui-option\n    *ngFor=\"let option of _.storageClassOptions\"\n    [value]=\"option.value\"\n    [label]=\"storageClassLabel\"\n    [labelContext]=\"{ option }\"\n  >\n    <ng-container\n      *ngTemplateOutlet=\"storageClassLabel; context: { option }\"\n    ></ng-container>\n  </aui-option>\n  <aui-option-placeholder>\n    {{ 'no_data' | translate }}\n  </aui-option-placeholder>\n</aui-select>\n\n<ng-template\n  #storageClassLabel\n  let-option=\"option\"\n>\n  <ng-container *ngIf=\"option; else empty\">\n    <span class=\"tw-mr-8\">{{ option.key }}</span>\n    <acl-storage-feature-tags\n      [provisioner]=\"option.provisioner\"\n      [storageClass]=\"option.storageClass\"\n      [hasDefault]=\"option.isDefault\"\n      [volumeSnapshotClasses]=\"volumeSnapshotClasses\"\n    ></acl-storage-feature-tags>\n  </ng-container>\n</ng-template>\n\n<ng-template #storageClassTmpl>\n  <ng-container\n    *ngTemplateOutlet=\"\n      storageClassLabel;\n      context: {\n        option:form.value | pure: getStorageClassOption:(storageClassOptions$ | async)\n      }\n    \"\n  ></ng-container>\n</ng-template>\n\n<ng-template #empty>{{ null | aclFieldNotAvailable }}</ng-template>\n"]}

package/esm2022/lib/pipes/actual-capacity.pipe.mjs

@@ -0,0 +1,17 @@
+import { toUnitGi } from '@alauda-fe/common';
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ActualCapacityPipe {
+    transform(value, withUnit = true) {
+        const capacity = value?.status?.capacity?.storage ||
+            value?.spec?.resources?.requests?.storage;
+        return withUnit ? capacity : toUnitGi(capacity);
+    }
+    static { this.ɵfac = function ActualCapacityPipe_Factory(t) { return new (t || ActualCapacityPipe)(); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "rcActualCapacity", type: ActualCapacityPipe, pure: true, standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ActualCapacityPipe, [{
+        type: Pipe,
+        args: [{ standalone: true, name: 'rcActualCapacity' }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN0dWFsLWNhcGFjaXR5LnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9tb2R1bGVzL3N0b3JhZ2Uvc3JjL2xpYi9waXBlcy9hY3R1YWwtY2FwYWNpdHkucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQXlCLFFBQVEsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ3BFLE9BQU8sRUFBRSxJQUFJLEVBQWlCLE1BQU0sZUFBZSxDQUFDOztBQUdwRCxNQUFNLE9BQU8sa0JBQWtCO0lBQzdCLFNBQVMsQ0FBQyxLQUE0QixFQUFFLFFBQVEsR0FBRyxJQUFJO1FBQ3JELE1BQU0sUUFBUSxHQUNaLEtBQUssRUFBRSxNQUFNLEVBQUUsUUFBUSxFQUFFLE9BQU87WUFDaEMsS0FBSyxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUUsUUFBUSxFQUFFLE9BQU8sQ0FBQztRQUM1QyxPQUFPLFFBQVEsQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDbEQsQ0FBQzttRkFOVSxrQkFBa0I7MEZBQWxCLGtCQUFrQjs7aUZBQWxCLGtCQUFrQjtjQUQ5QixJQUFJO2VBQUMsRUFBRSxVQUFVLEVBQUUsSUFBSSxFQUFFLElBQUksRUFBRSxrQkFBa0IsRUFBRSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBlcnNpc3RlbnRWb2x1bWVDbGFpbSwgdG9Vbml0R2kgfSBmcm9tICdAYWxhdWRhLWZlL2NvbW1vbic7XG5pbXBvcnQgeyBQaXBlLCBQaXBlVHJhbnNmb3JtIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBQaXBlKHsgc3RhbmRhbG9uZTogdHJ1ZSwgbmFtZTogJ3JjQWN0dWFsQ2FwYWNpdHknIH0pXG5leHBvcnQgY2xhc3MgQWN0dWFsQ2FwYWNpdHlQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG4gIHRyYW5zZm9ybSh2YWx1ZTogUGVyc2lzdGVudFZvbHVtZUNsYWltLCB3aXRoVW5pdCA9IHRydWUpIHtcbiAgICBjb25zdCBjYXBhY2l0eSA9XG4gICAgICB2YWx1ZT8uc3RhdHVzPy5jYXBhY2l0eT8uc3RvcmFnZSB8fFxuICAgICAgdmFsdWU/LnNwZWM/LnJlc291cmNlcz8ucmVxdWVzdHM/LnN0b3JhZ2U7XG4gICAgcmV0dXJuIHdpdGhVbml0ID8gY2FwYWNpdHkgOiB0b1VuaXRHaShjYXBhY2l0eSk7XG4gIH1cbn1cbiJdfQ==

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

@@ -0,0 +1,163 @@
+import { matchLabelsToString, K8sUtilService, publishRef, RESOURCE_TYPES, K8sApiService, skipError, parse, CacheStore, VolumeModes, AccessModes, } from '@alauda-fe/common';
+import { Injectable } from '@angular/core';
+import { isBoolean } from 'lodash-es';
+import { map, shareReplay } from 'rxjs';
+import { StorageclassFeature } from '../types/commons';
+import { getProvisioner, getProvisionerType, getStorageclassAccessModes, getStorageclassVolumeModes, isDefaultStorageclass, } from '../utils/util';
+import * as i0 from "@angular/core";
+import * as i1 from "@alauda-fe/common";
+export class StorageCommonUtilService {
+    constructor(k8sUtil, k8sApi) {
+        this.k8sUtil = k8sUtil;
+        this.k8sApi = k8sApi;
+        this.storageDescriptionMapCache = new CacheStore({
+            fetcher: () => this.k8sApi
+                .getGlobalResourceList({
+                type: RESOURCE_TYPES.CONFIG_MAP,
+                // 获取第三方存储能力配置，其中 ns 和 label 都固定
+                namespace: 'kube-public',
+                queryParams: {
+                    labelSelector: 'features.alauda.io/type=StorageDescription',
+                },
+            })
+                .pipe(map(res => [...res.items].sort((a, b) => +new Date(a.metadata.creationTimestamp) -
+                +new Date(b.metadata.creationTimestamp))), map(items => items.map(item => item.data)), skipError([])),
+            share: () => shareReplay(1),
+        });
+        this.isStorageClassFeatureSupported =
+            this.isStorageClassFeatureSupported.bind(this);
+    }
+    getStorageClassFeatures(storageClass) {
+        const featuresSet = new Set(this.k8sUtil
+            .getAnnotation(storageClass, 'features')
+            ?.split(',') || []);
+        if (storageClass?.allowVolumeExpansion) {
+            featuresSet.add(StorageclassFeature.EXPANSION);
+        }
+        else {
+            featuresSet.delete(StorageclassFeature.EXPANSION);
+        }
+        return [...featuresSet];
+    }
+    isStorageClassFeatureSupported(storageclass, feature) {
+        return this.getStorageClassFeatures(storageclass).includes(feature);
+    }
+    mapToStorageClassOption(sc, storageDescriptionMaps, isFromSnapshot) {
+        return {
+            key: sc.metadata.name,
+            value: sc.metadata.name,
+            isDefault: isDefaultStorageclass(sc),
+            accessModes: this.getStorageclassAccessModes(sc, storageDescriptionMaps, isFromSnapshot) || [],
+            features: this.getStorageClassFeatures(sc),
+            volumeModes: this.getStorageclassVolumeModes(sc, storageDescriptionMaps),
+            provisioner: sc.provisioner,
+            storageClass: sc,
+        };
+    }
+    isClusterSnapshotPluginEnabled$(cluster) {
+        return this.k8sApi
+            .getGlobalResourceList({
+            type: RESOURCE_TYPES.MODULE_INFO,
+            queryParams: {
+                labelSelector: matchLabelsToString({
+                    [this.k8sUtil.normalizeType('module-type')]: 'plugin',
+                    [this.k8sUtil.normalizeType('cluster-name')]: cluster,
+                    [this.k8sUtil.normalizeType('module-name')]: 'snapshot',
+                }),
+            },
+        })
+            .pipe(map(r => !!r.items?.[0]), publishRef());
+    }
+    /**
+     * 获取第三方快照能力支持情况，若返回 null 表示未匹配到三方存储
+     */
+    getThirdPartySnapshotSupported(sc, storageDescriptionMaps) {
+        const provisioner = getProvisioner(sc);
+        const config = this.findStorageDescriptionMap(storageDescriptionMaps, provisioner);
+        // 如果匹配到三方 provisioner 未定义和非法都按 false 处理
+        if (config) {
+            const snapshot = parse(config)?.snapshot;
+            return isBoolean(snapshot) ? snapshot : false;
+        }
+        return null;
+    }
+    getProvisionerType(sc, storageDescriptionMaps) {
+        const provisioner = getProvisioner(sc);
+        const config = this.findStorageDescriptionMap(storageDescriptionMaps, provisioner);
+        // 解析第三方存储类型
+        if (config) {
+            const type = parse(config).type;
+            if (!type) {
+                return 'unknown';
+            }
+            const result = this.filterByAllowedValues([type], ['Filesystem', 'Block'])[0];
+            return result
+                ? {
+                    Filesystem: 'file_storage',
+                    Block: 'block_storage',
+                }[result]
+                : 'unknown';
+        }
+        return getProvisionerType(provisioner);
+    }
+    getStorageclassAccessModes(sc, storageDescriptionMaps, isFromSnapshot) {
+        const provisioner = getProvisioner(sc);
+        const config = this.findStorageDescriptionMap(storageDescriptionMaps, provisioner);
+        // 解析第三方 AccessModes
+        if (config) {
+            return this.getThirdPartyStorageclassAccessModes(parse(config));
+        }
+        return getStorageclassAccessModes(provisioner, isFromSnapshot);
+    }
+    getStorageclassVolumeModes(sc, storageDescriptionMaps) {
+        const provisioner = getProvisioner(sc);
+        const config = this.findStorageDescriptionMap(storageDescriptionMaps, provisioner);
+        // 解析第三方 VolumeModes
+        if (config) {
+            return this.getThirdPartyStorageclassVolumeModes(parse(config));
+        }
+        return getStorageclassVolumeModes(provisioner);
+    }
+    isAccessModeDisabled(accessMode, storageClassOption) {
+        return storageClassOption
+            ? !storageClassOption.accessModes.includes(accessMode)
+            : false;
+    }
+    isVolumeModeDisabled(volumeMode, storageClassOption) {
+        return storageClassOption
+            ? !storageClassOption.volumeModes.includes(volumeMode)
+            : false;
+    }
+    // 获取首个匹配 provisioner 的 storageDescriptionConfig
+    findStorageDescriptionMap(configs, provisioner) {
+        const storageDescriptionMap = configs?.find(config => !!config[provisioner]);
+        return storageDescriptionMap?.[provisioner];
+    }
+    getThirdPartyStorageclassAccessModes(storageDescription) {
+        return this.filterByAllowedValues(storageDescription?.accessModes ?? [], AccessModes);
+    }
+    getThirdPartyStorageclassVolumeModes(storageDescription) {
+        return this.filterByAllowedValues(storageDescription?.volumeMode ?? [], VolumeModes);
+    }
+    /**
+     * 解析 ConfigMap 中的 AccessModes 和 VolumeModes, 要求 cm 中的配置不区分大小，满足 AccessModes 或 VolumeModes 中定义即可
+     *
+     * @example
+     * ```
+     * const result = filterByAllowedValues(['ReadOnlyMany', 'Invalid'],['ReadOnlyMany', 'ReadWriteOnce', 'ReadWriteMany'])
+     * console.log(result) // ['ReadOnlyMany']
+     * ```
+     */
+    filterByAllowedValues(inputArray, allowedValues) {
+        return allowedValues.filter(allowedValue => inputArray.some(input => input.trim().toLowerCase() === allowedValue.trim().toLowerCase()));
+    }
+    static { this.ɵfac = function StorageCommonUtilService_Factory(t) { return new (t || StorageCommonUtilService)(i0.ɵɵinject(i1.K8sUtilService), i0.ɵɵinject(i1.K8sApiService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: StorageCommonUtilService, factory: StorageCommonUtilService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(StorageCommonUtilService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], () => [{ type: i1.K8sUtilService }, { type: i1.K8sApiService }], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common-util.service.js","sourceRoot":"","sources":["../../../../../../modules/storage/src/lib/services/common-util.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AccessMode,\n  VolumeMode,\n  matchLabelsToString,\n  K8sUtilService,\n  ModuleInfo,\n  publishRef,\n  RESOURCE_TYPES,\n  K8sApiService,\n  ConfigMap,\n  skipError,\n  StringMap,\n  parse,\n  CacheStore,\n  VolumeModes,\n  AccessModes,\n} from '@alauda-fe/common';\nimport { Injectable } from '@angular/core';\nimport { isBoolean } from 'lodash-es';\nimport { map, shareReplay } from 'rxjs';\n\nimport { StorageclassFeature, StorageProvisioner } from '../types/commons';\nimport { CommonStorageClass, StorageClass } from '../types/k8s';\nimport {\n  getProvisioner,\n  getProvisionerType,\n  getStorageclassAccessModes,\n  getStorageclassVolumeModes,\n  isDefaultStorageclass,\n} from '../utils/util';\n\ninterface StorageDescription {\n  type: VolumeMode;\n  accessModes: AccessMode[];\n  volumeMode: VolumeMode[];\n  snapshot?: boolean;\n}\n\nexport interface StorageSelectOption {\n  key: string;\n  value: string;\n  isDefault: boolean;\n  accessModes: AccessMode[];\n  features: StorageclassFeature[];\n  volumeModes: VolumeMode[];\n  provisioner: StorageProvisioner;\n  storageClass: StorageClass;\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class StorageCommonUtilService {\n  readonly storageDescriptionMapCache = new CacheStore({\n    fetcher: () =>\n      this.k8sApi\n        .getGlobalResourceList<ConfigMap>({\n          type: RESOURCE_TYPES.CONFIG_MAP,\n          // 获取第三方存储能力配置，其中 ns 和 label 都固定\n          namespace: 'kube-public',\n          queryParams: {\n            labelSelector: 'features.alauda.io/type=StorageDescription',\n          },\n        })\n        .pipe(\n          map(res =>\n            [...res.items].sort(\n              (a, b) =>\n                +new Date(a.metadata.creationTimestamp) -\n                +new Date(b.metadata.creationTimestamp),\n            ),\n          ),\n          map(items => items.map(item => item.data)),\n          skipError([] as StringMap[]),\n        ),\n    share: () => shareReplay(1),\n  });\n\n  constructor(\n    private readonly k8sUtil: K8sUtilService,\n    private readonly k8sApi: K8sApiService,\n  ) {\n    this.isStorageClassFeatureSupported =\n      this.isStorageClassFeatureSupported.bind(this);\n  }\n\n  getStorageClassFeatures(storageClass: StorageClass) {\n    const featuresSet = new Set(\n      (this.k8sUtil\n        .getAnnotation(storageClass, 'features')\n        ?.split(',') as StorageclassFeature[]) || [],\n    );\n    if (storageClass?.allowVolumeExpansion) {\n      featuresSet.add(StorageclassFeature.EXPANSION);\n    } else {\n      featuresSet.delete(StorageclassFeature.EXPANSION);\n    }\n    return [...featuresSet];\n  }\n\n  isStorageClassFeatureSupported(\n    storageclass: StorageClass,\n    feature: StorageclassFeature,\n  ) {\n    return this.getStorageClassFeatures(storageclass).includes(feature);\n  }\n\n  mapToStorageClassOption(\n    sc: StorageClass,\n    storageDescriptionMaps?: StringMap[],\n    isFromSnapshot?: boolean,\n  ): StorageSelectOption {\n    return {\n      key: sc.metadata.name,\n      value: sc.metadata.name,\n      isDefault: isDefaultStorageclass(sc),\n      accessModes:\n        this.getStorageclassAccessModes(\n          sc,\n          storageDescriptionMaps,\n          isFromSnapshot,\n        ) || [],\n      features: this.getStorageClassFeatures(sc),\n      volumeModes: this.getStorageclassVolumeModes(sc, storageDescriptionMaps),\n      provisioner: sc.provisioner,\n      storageClass: sc,\n    };\n  }\n\n  isClusterSnapshotPluginEnabled$(cluster: string) {\n    return this.k8sApi\n      .getGlobalResourceList<ModuleInfo>({\n        type: RESOURCE_TYPES.MODULE_INFO,\n        queryParams: {\n          labelSelector: matchLabelsToString({\n            [this.k8sUtil.normalizeType('module-type')]: 'plugin',\n            [this.k8sUtil.normalizeType('cluster-name')]: cluster,\n            [this.k8sUtil.normalizeType('module-name')]: 'snapshot',\n          }),\n        },\n      })\n      .pipe(\n        map(r => !!r.items?.[0]),\n        publishRef(),\n      );\n  }\n\n  /**\n   * 获取第三方快照能力支持情况，若返回 null 表示未匹配到三方存储\n   */\n  getThirdPartySnapshotSupported(\n    sc: CommonStorageClass,\n    storageDescriptionMaps: StringMap[],\n  ): boolean | null {\n    const provisioner = getProvisioner(sc);\n    const config = this.findStorageDescriptionMap(\n      storageDescriptionMaps,\n      provisioner,\n    );\n\n    // 如果匹配到三方 provisioner 未定义和非法都按 false 处理\n    if (config) {\n      const snapshot = parse<StorageDescription>(config)?.snapshot;\n      return isBoolean(snapshot) ? snapshot : false;\n    }\n\n    return null;\n  }\n\n  getProvisionerType(\n    sc: CommonStorageClass,\n    storageDescriptionMaps: StringMap[],\n  ) {\n    const provisioner = getProvisioner(sc);\n    const config = this.findStorageDescriptionMap(\n      storageDescriptionMaps,\n      provisioner,\n    );\n\n    // 解析第三方存储类型\n    if (config) {\n      const type = parse<StorageDescription>(config).type;\n      if (!type) {\n        return 'unknown';\n      }\n\n      const result = this.filterByAllowedValues<VolumeMode>(\n        [type],\n        ['Filesystem', 'Block'],\n      )[0];\n      return result\n        ? {\n            Filesystem: 'file_storage',\n            Block: 'block_storage',\n          }[result]\n        : 'unknown';\n    }\n\n    return getProvisionerType(provisioner);\n  }\n\n  getStorageclassAccessModes(\n    sc: CommonStorageClass,\n    storageDescriptionMaps: StringMap[],\n    isFromSnapshot: boolean,\n  ) {\n    const provisioner = getProvisioner(sc);\n    const config = this.findStorageDescriptionMap(\n      storageDescriptionMaps,\n      provisioner,\n    );\n\n    // 解析第三方 AccessModes\n    if (config) {\n      return this.getThirdPartyStorageclassAccessModes(\n        parse<StorageDescription>(config),\n      );\n    }\n    return getStorageclassAccessModes(provisioner, isFromSnapshot);\n  }\n\n  getStorageclassVolumeModes(\n    sc: CommonStorageClass,\n    storageDescriptionMaps: StringMap[],\n  ) {\n    const provisioner = getProvisioner(sc);\n    const config = this.findStorageDescriptionMap(\n      storageDescriptionMaps,\n      provisioner,\n    );\n\n    // 解析第三方 VolumeModes\n    if (config) {\n      return this.getThirdPartyStorageclassVolumeModes(\n        parse<StorageDescription>(config),\n      );\n    }\n    return getStorageclassVolumeModes(provisioner);\n  }\n\n  isAccessModeDisabled(\n    accessMode: AccessMode,\n    storageClassOption: StorageSelectOption,\n  ) {\n    return storageClassOption\n      ? !storageClassOption.accessModes.includes(accessMode)\n      : false;\n  }\n\n  isVolumeModeDisabled(\n    volumeMode: VolumeMode,\n    storageClassOption: StorageSelectOption,\n  ) {\n    return storageClassOption\n      ? !storageClassOption.volumeModes.includes(volumeMode)\n      : false;\n  }\n\n  // 获取首个匹配 provisioner 的 storageDescriptionConfig\n  private findStorageDescriptionMap(\n    configs: StringMap[],\n    provisioner: StorageProvisioner,\n  ) {\n    const storageDescriptionMap = configs?.find(\n      config => !!config[provisioner],\n    );\n    return storageDescriptionMap?.[provisioner];\n  }\n\n  private getThirdPartyStorageclassAccessModes(\n    storageDescription: StorageDescription,\n  ) {\n    return this.filterByAllowedValues<AccessMode>(\n      storageDescription?.accessModes ?? [],\n      AccessModes,\n    );\n  }\n\n  private getThirdPartyStorageclassVolumeModes(\n    storageDescription: StorageDescription,\n  ) {\n    return this.filterByAllowedValues<VolumeMode>(\n      storageDescription?.volumeMode ?? [],\n      VolumeModes,\n    );\n  }\n\n  /**\n   * 解析 ConfigMap 中的 AccessModes 和 VolumeModes, 要求 cm 中的配置不区分大小，满足 AccessModes 或 VolumeModes 中定义即可\n   *\n   * @example\n   * ```\n   * const result = filterByAllowedValues(['ReadOnlyMany', 'Invalid'],['ReadOnlyMany', 'ReadWriteOnce', 'ReadWriteMany'])\n   * console.log(result) // ['ReadOnlyMany']\n   * ```\n   */\n  private filterByAllowedValues<T extends string>(\n    inputArray: T[],\n    allowedValues: T[],\n  ) {\n    return allowedValues.filter(allowedValue =>\n      inputArray.some(\n        input =>\n          input.trim().toLowerCase() === allowedValue.trim().toLowerCase(),\n      ),\n    );\n  }\n}\n"]}