@alauda-fe/storage 0.0.1

package/lib/components/pvc-form/component.d.ts

@@ -0,0 +1,106 @@
+import { AccessMode, VolumeMode, LabelSelector, PersistentVolumeClaim, PersistentVolumeClaimDataSource, TranslateService, K8sApiService, ValueOf, StringMap, WorkspaceParams } from '@alauda-fe/common';
+import { Observable } from 'rxjs';
+import { StorageSelectOption, StorageCommonUtilService } from '../../services/common-util.service';
+import { StorageClass, VolumeSnapshotClass } from '../../types/k8s';
+import * as i0 from "@angular/core";
+declare const PvcStorageClassCreateType: {
+    readonly DYNAMIC: "dynamic";
+    readonly STATIC: "static";
+};
+type PvcStorageClassCreateType = ValueOf<typeof PvcStorageClassCreateType>;
+interface PersistentVolumeFormModel {
+    name: string;
+    labels: StringMap;
+    annotations: StringMap;
+    storageClassName: string;
+    accessModes: AccessMode;
+    volumeMode: VolumeMode;
+    storage: string;
+    dataSource?: PersistentVolumeClaimDataSource;
+    selector: LabelSelector;
+}
+type DisplayField = keyof PersistentVolumeFormModel | 'createType';
+declare const PersistentVolumeClaimFormComponent_base: new () => import("@alauda-fe/common").BaseNestedFormControl<PersistentVolumeClaim, PersistentVolumeFormModel>;
+export declare class PersistentVolumeClaimFormComponent extends PersistentVolumeClaimFormComponent_base {
+    protected storageCommonUtil: StorageCommonUtilService;
+    private readonly translate;
+    private readonly k8sApi;
+    baseParams: WorkspaceParams;
+    baseParams$: Observable<WorkspaceParams>;
+    storageClasses: StorageClass[];
+    storageClasses$: Observable<StorageClass[]>;
+    isFromSnapshot: boolean;
+    createType: PvcStorageClassCreateType;
+    volumeMode: VolumeMode;
+    displayFields: DisplayField[];
+    get showAdvancedField(): boolean;
+    accessModes: ("ReadWriteOnce" | "ReadOnlyMany" | "ReadWriteMany")[];
+    volumeModes: ("Filesystem" | "Block")[];
+    POSITIVE_INT_PATTERN: {
+        pattern: RegExp;
+        tip: string;
+    };
+    model: PersistentVolumeFormModel;
+    resourceNameReg: {
+        pattern: RegExp;
+        tip: string;
+    };
+    labelValidator: {
+        key: typeof import("@alauda-fe/common").k8sResourceLabelKeyValidator;
+        value: import("@angular/forms").ValidatorFn;
+    };
+    AccessModeTranslateKey: {
+        ReadWriteOnce: string;
+        ReadOnlyMany: string;
+        ReadWriteMany: string;
+    };
+    VolumeModeTranslateKey: {
+        Filesystem: string;
+        Block: string;
+    };
+    labelErrorMapper$: Observable<{
+        key: {
+            namePattern: string;
+            prefixPattern: string;
+            nameTooLong: string;
+            prefixTooLong: string;
+        };
+        value: {
+            pattern: string;
+            maxlength: string;
+        };
+    }>;
+    annotationValidator: {
+        key: typeof import("@alauda-fe/common").k8sResourceLabelKeyValidator;
+    };
+    annotationErrorMapper$: Observable<{
+        key: {
+            namePattern: string;
+            prefixPattern: string;
+            nameTooLong: string;
+            prefixTooLong: string;
+        };
+    }>;
+    createMethod: PvcStorageClassCreateType;
+    PvcStorageClassCreateType: {
+        readonly DYNAMIC: "dynamic";
+        readonly STATIC: "static";
+    };
+    selectedStorageSelectOption: StorageSelectOption;
+    UNITS: readonly ["Gi", "Ti"];
+    unit: string;
+    storageClassList$: Observable<StorageClass[]>;
+    volumeSnapshotClassList$: Observable<VolumeSnapshotClass[]>;
+    writeValue(value: PersistentVolumeClaim): void;
+    constructor(storageCommonUtil: StorageCommonUtilService, translate: TranslateService, k8sApi: K8sApiService);
+    createMethodChange(createType: PvcStorageClassCreateType): void;
+    storageclassChange(selectedOption: StorageSelectOption): void;
+    displayFieldSupported(fieldName: DisplayField): boolean;
+    private setAccessModeToSupportValueIfNeed;
+    private setVolumeModeToSupportValueIfNeed;
+    private readonly adaptResourceModel;
+    private readonly overrideResource;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PersistentVolumeClaimFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PersistentVolumeClaimFormComponent, "acl-pvc-form", never, { "baseParams": { "alias": "baseParams"; "required": true; }; "storageClasses": { "alias": "storageClasses"; "required": false; }; "isFromSnapshot": { "alias": "isFromSnapshot"; "required": false; }; "createType": { "alias": "createType"; "required": false; }; "volumeMode": { "alias": "volumeMode"; "required": false; }; "displayFields": { "alias": "displayFields"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/components/rebuild-volume-dialog/component.d.ts

@@ -0,0 +1,28 @@
+import { DialogRef } from '@alauda/ui';
+import { K8sApiService, PersistentVolumeClaim, ResourceType } from '@alauda-fe/common';
+import { BehaviorSubject } from 'rxjs';
+import { PVCUtilService } from '../../services/pvc-util.service';
+import * as i0 from "@angular/core";
+export declare class RebuildVolumeDialogComponent {
+    readonly modalData: {
+        cluster: string;
+        namespace: string;
+        pvc: PersistentVolumeClaim;
+    };
+    private readonly k8sApi;
+    private readonly dialogRef;
+    protected readonly pvcUtil: PVCUtilService;
+    COLUMNS: string[];
+    inputValue: string;
+    submitting$$: BehaviorSubject<boolean>;
+    loading$$: BehaviorSubject<boolean>;
+    pods$: import("rxjs").Observable<import("@alauda-fe/common").Pod[]>;
+    constructor(modalData: {
+        cluster: string;
+        namespace: string;
+        pvc: PersistentVolumeClaim;
+    }, k8sApi: K8sApiService<ResourceType>, dialogRef: DialogRef, pvcUtil: PVCUtilService);
+    confirm(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RebuildVolumeDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RebuildVolumeDialogComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}

package/lib/components/source-link/component.d.ts

@@ -0,0 +1,17 @@
+import { TranslateService } from '@alauda-fe/common';
+import * as i0 from "@angular/core";
+interface SourceLink {
+    name?: string;
+    routerLink?: string[];
+    kind?: string;
+    apiVersion?: string;
+}
+export declare class SourceLinkComponent {
+    translate: TranslateService;
+    sourceLink: SourceLink;
+    formatSourceLinkFn: (sourceLink: SourceLink, _locale?: string) => string;
+    constructor(translate: TranslateService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<SourceLinkComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SourceLinkComponent, "acl-source-link", never, { "sourceLink": { "alias": "sourceLink"; "required": true; }; "formatSourceLinkFn": { "alias": "formatSourceLinkFn"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/components/spec-form/component.d.ts

@@ -0,0 +1,71 @@
+import { StringMap, TranslateService } from '@alauda-fe/common';
+import { Injector, OnInit, TemplateRef } from '@angular/core';
+import { ValidatorFn } from '@angular/forms';
+import { BaseResourceFormGroupComponent } from 'ng-resource-form-util';
+import { ResourceSize, ResourceSizeTip, ResourceSpecification } from '../../types/resource-exports';
+import { ResourceRequirements } from '../../types/resource-internals';
+import * as i0 from "@angular/core";
+interface ResourceValidatorFn {
+    limits?: {
+        cpu: ValidatorFn[];
+        memory: ValidatorFn[];
+    };
+    requests?: {
+        cpu: ValidatorFn[];
+        memory: ValidatorFn[];
+    };
+}
+export declare class ResourceSpecFormComponent extends BaseResourceFormGroupComponent<ResourceRequirements, ResourceSpecification> implements OnInit {
+    private readonly translate;
+    resourceSizeTips: ResourceSizeTip[];
+    resourceSpecificationDescription: string | TemplateRef<any>;
+    resourceSpecification: ResourceSpecification[];
+    showResourceRequests: boolean;
+    validatorFn: ResourceValidatorFn;
+    set errorMapper(errorMapper: StringMap);
+    get errorMapper(): StringMap;
+    get resourceSpecificationMapper(): Partial<Record<ResourceSize, ResourceSpecification>>;
+    private _errorMapper;
+    ResourceSize: typeof ResourceSize;
+    POSITIVE_INT_PATTERN: {
+        pattern: RegExp;
+        tip: string;
+    };
+    isTemplateRef: (label: any) => label is TemplateRef<unknown>;
+    constructor(injector: Injector, translate: TranslateService);
+    ngOnInit(): void;
+    createForm(): import("@angular/forms").FormGroup<{
+        requests: import("@angular/forms").FormGroup<{
+            cpu: import("@angular/forms").FormGroup<{
+                value: import("@angular/forms").FormControl<number>;
+                unit: import("@angular/forms").FormControl<"core" | "m">;
+            }>;
+            memory: import("@angular/forms").FormGroup<{
+                value: import("@angular/forms").FormControl<number>;
+                unit: import("@angular/forms").FormControl<"Gi" | "Mi">;
+            }>;
+        }>;
+        size: import("@angular/forms").FormControl<ResourceSize>;
+        limits: import("@angular/forms").FormGroup<{
+            cpu: import("@angular/forms").FormGroup<{
+                value: import("@angular/forms").FormControl<number>;
+                unit: import("@angular/forms").FormControl<"core" | "m">;
+            }>;
+            memory: import("@angular/forms").FormGroup<{
+                value: import("@angular/forms").FormControl<number>;
+                unit: import("@angular/forms").FormControl<"Gi" | "Mi">;
+            }>;
+        }>;
+    }>;
+    getDefaultFormModel(): {
+        requests: import("../../types/resource-internals").ResourceModel;
+        size: ResourceSize;
+        limits: import("../../types/resource-internals").ResourceModel;
+    };
+    adaptFormModel(formModel: ResourceSpecification): ResourceRequirements;
+    adaptResourceModel(resource: ResourceRequirements): ResourceSpecification;
+    onResourceSizeChange(size: ResourceSize): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceSpecFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResourceSpecFormComponent, "acl-resource-spec-form", never, { "resourceSizeTips": { "alias": "resourceSizeTips"; "required": true; }; "resourceSpecificationDescription": { "alias": "resourceSpecificationDescription"; "required": false; }; "resourceSpecification": { "alias": "resourceSpecification"; "required": false; }; "showResourceRequests": { "alias": "showResourceRequests"; "required": false; }; "validatorFn": { "alias": "validatorFn"; "required": false; }; "errorMapper": { "alias": "errorMapper"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/components/storage-feature-tags/component.d.ts

@@ -0,0 +1,25 @@
+import { K8sUtilService } from '@alauda-fe/common';
+import { Observable } from 'rxjs';
+import { StorageCommonUtilService } from '../../services/common-util.service';
+import { StorageProvisioner, StorageclassFeature } from '../../types/commons';
+import { StorageClass, VolumeSnapshotClass } from '../../types/k8s';
+import * as i0 from "@angular/core";
+export declare class StorageFeatureTagsComponent {
+    private readonly k8sUtil;
+    private readonly storageUtil;
+    provisioner: StorageProvisioner;
+    provisioner$: Observable<StorageProvisioner>;
+    storageClass: StorageClass;
+    storageClass$: Observable<StorageClass>;
+    hasDefault: boolean;
+    volumeSnapshotClasses: VolumeSnapshotClass[];
+    volumeSnapshotClasses$: Observable<VolumeSnapshotClass[]>;
+    features$: Observable<StorageclassFeature[]>;
+    constructor(k8sUtil: K8sUtilService, storageUtil: StorageCommonUtilService);
+    private updateStorageClassFeature;
+    private updateVolumeSnapshotFeature;
+    private hasVolumeSnapshotFeature;
+    private updateThirdPartySnapshotFeature;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StorageFeatureTagsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StorageFeatureTagsComponent, "acl-storage-feature-tags", never, { "provisioner": { "alias": "provisioner"; "required": true; }; "storageClass": { "alias": "storageClass"; "required": false; }; "hasDefault": { "alias": "hasDefault"; "required": false; }; "volumeSnapshotClasses": { "alias": "volumeSnapshotClasses"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/components/storageclass-select/component.d.ts

@@ -0,0 +1,26 @@
+import { AttrBoolean } from '@alauda/ui';
+import { EventEmitter } from '@angular/core';
+import { BaseResourceFormComponent } from 'ng-resource-form-util';
+import { Observable } from 'rxjs';
+import { StorageCommonUtilService, StorageSelectOption } from '../../services/common-util.service';
+import { StorageClass, VolumeSnapshotClass } from '../../types/k8s';
+import * as i0 from "@angular/core";
+export declare class StorageClassSelectComponent extends BaseResourceFormComponent<string> {
+    storageClasses: StorageClass[];
+    storageClasses$: Observable<StorageClass[]>;
+    set required(value: AttrBoolean);
+    get required(): AttrBoolean;
+    volumeSnapshotClasses: VolumeSnapshotClass[];
+    selectDefault: boolean;
+    isFromSnapshot: boolean;
+    storageClassChange: EventEmitter<StorageSelectOption>;
+    storageCommonUtil: StorageCommonUtilService;
+    storageClassOptions$: Observable<StorageSelectOption[]>;
+    private _required;
+    createForm(): import("@angular/forms").FormControl<string>;
+    errorsInDetail: boolean;
+    getStorageClassOption(value: string, options?: StorageSelectOption[]): StorageSelectOption;
+    onStorageClassChange(storageClassName: string, storageClassOptions?: StorageSelectOption[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StorageClassSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StorageClassSelectComponent, "acl-storageclass-select", never, { "storageClasses": { "alias": "storageClasses"; "required": true; }; "required": { "alias": "required"; "required": false; }; "volumeSnapshotClasses": { "alias": "volumeSnapshotClasses"; "required": false; }; "selectDefault": { "alias": "selectDefault"; "required": false; }; "isFromSnapshot": { "alias": "isFromSnapshot"; "required": false; }; }, { "storageClassChange": "storageClassChange"; }, never, never, true, never>;
+}

package/lib/pipes/actual-capacity.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PersistentVolumeClaim } from '@alauda-fe/common';
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ActualCapacityPipe implements PipeTransform {
+    transform(value: PersistentVolumeClaim, withUnit?: boolean): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActualCapacityPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ActualCapacityPipe, "rcActualCapacity", true>;
+}

package/lib/services/common-util.service.d.ts

@@ -0,0 +1,48 @@
+import { AccessMode, VolumeMode, K8sUtilService, K8sApiService, StringMap, CacheStore } from '@alauda-fe/common';
+import { StorageclassFeature, StorageProvisioner } from '../types/commons';
+import { CommonStorageClass, StorageClass } from '../types/k8s';
+import * as i0 from "@angular/core";
+export interface StorageSelectOption {
+    key: string;
+    value: string;
+    isDefault: boolean;
+    accessModes: AccessMode[];
+    features: StorageclassFeature[];
+    volumeModes: VolumeMode[];
+    provisioner: StorageProvisioner;
+    storageClass: StorageClass;
+}
+export declare class StorageCommonUtilService {
+    private readonly k8sUtil;
+    private readonly k8sApi;
+    readonly storageDescriptionMapCache: CacheStore<unknown, StringMap[]>;
+    constructor(k8sUtil: K8sUtilService, k8sApi: K8sApiService);
+    getStorageClassFeatures(storageClass: StorageClass): StorageclassFeature[];
+    isStorageClassFeatureSupported(storageclass: StorageClass, feature: StorageclassFeature): boolean;
+    mapToStorageClassOption(sc: StorageClass, storageDescriptionMaps?: StringMap[], isFromSnapshot?: boolean): StorageSelectOption;
+    isClusterSnapshotPluginEnabled$(cluster: string): import("rxjs").Observable<boolean>;
+    /**
+     * 获取第三方快照能力支持情况，若返回 null 表示未匹配到三方存储
+     */
+    getThirdPartySnapshotSupported(sc: CommonStorageClass, storageDescriptionMaps: StringMap[]): boolean | null;
+    getProvisionerType(sc: CommonStorageClass, storageDescriptionMaps: StringMap[]): string;
+    getStorageclassAccessModes(sc: CommonStorageClass, storageDescriptionMaps: StringMap[], isFromSnapshot: boolean): ("ReadWriteOnce" | "ReadOnlyMany" | "ReadWriteMany")[];
+    getStorageclassVolumeModes(sc: CommonStorageClass, storageDescriptionMaps: StringMap[]): ("Filesystem" | "Block")[];
+    isAccessModeDisabled(accessMode: AccessMode, storageClassOption: StorageSelectOption): boolean;
+    isVolumeModeDisabled(volumeMode: VolumeMode, storageClassOption: StorageSelectOption): boolean;
+    private findStorageDescriptionMap;
+    private getThirdPartyStorageclassAccessModes;
+    private getThirdPartyStorageclassVolumeModes;
+    /**
+     * 解析 ConfigMap 中的 AccessModes 和 VolumeModes, 要求 cm 中的配置不区分大小，满足 AccessModes 或 VolumeModes 中定义即可
+     *
+     * @example
+     * ```
+     * const result = filterByAllowedValues(['ReadOnlyMany', 'Invalid'],['ReadOnlyMany', 'ReadWriteOnce', 'ReadWriteMany'])
+     * console.log(result) // ['ReadOnlyMany']
+     * ```
+     */
+    private filterByAllowedValues;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StorageCommonUtilService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StorageCommonUtilService>;
+}

package/lib/services/pvc-util.service.d.ts

@@ -0,0 +1,130 @@
+import { DialogService } from '@alauda/ui';
+import { K8sApiService, PersistentVolumeClaim, Workspace, StringMap, CacheStore, AcpCommonApiService, Pod } from '@alauda-fe/common';
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { DeletePvcDialogComponent } from '../components/pvc-delete-dialog/component';
+import { StorageCommonUtilService } from '../services/common-util.service';
+import { StorageclassFeature, StorageProvisioner } from '../types/commons';
+import { StorageClass, VolumeSnapshotClass, VolumeSnapshot } from '../types/k8s';
+import * as i0 from "@angular/core";
+export declare const PVC_SNAPSHOT_FEATURE_GATE = "volume-snapshot";
+export declare function pvcUpdateEnabled(resource: PersistentVolumeClaim): boolean;
+export declare function getPvcDeletingDisabledState(pvc: PersistentVolumeClaim): {
+    tooltip: string;
+    disabled: boolean;
+};
+export declare function getPvcRebuildingDisabledState(pvc: PersistentVolumeClaim): {
+    tooltip: string;
+    disabled: boolean;
+};
+export declare const STORAGECLASS_FEATURE_FEATURE_GATE_MAP: Partial<Record<StorageclassFeature, Partial<Record<StorageProvisioner, string>>>>;
+export declare enum PVCExpandDisabledReason {
+    PVC_STATUS_FORBID = "expand_pvc_status_forbid",
+    WITHOUT_STORAGE_CLASS = "expand_without_storage_class",
+    STORAGE_CLASS_FORBID = "expand_storage_class_forbid",
+    STORAGE_CLASS_NOTFOUND = "pvc_storage_class_not_found",
+    PVC_REBUILDING = "pvc_rebuilding",
+    PVC_DELETING = "pvc_deleting",
+    TOPOLVM_PVC_EXISTED_SNAPSHOT = "pvc_existed_snapshot"
+}
+export declare enum PVCSnapshotDisabledReason {
+    PVC_STATUS_FORBID = "snapshot_pvc_status_forbid",
+    WITHOUT_STORAGE_CLASS = "snapshot_without_storage_class",
+    STORAGE_CLASS_FORBID = "snapshot_storage_class_forbid",
+    SNAPSHOT_PLUGIN_NOT_INSTALLED = "snapshot_plugin_not_installed",
+    STORAGE_CLASS_NOTFOUND = "pvc_storage_class_not_found",
+    SNAPSHOT_UNSUPPORTED = "snapshot_unsupported",
+    PVC_REBUILDING = "pvc_rebuilding",
+    PVC_DELETING = "pvc_deleting",
+    PVC_EXPANDING = "pvc_expanding"
+}
+export type PVCActionStateFn = (pvc: PersistentVolumeClaim, mapper?: PVCActionTooltipMapper) => PVCActionState;
+export interface PVCActionState {
+    disabled: boolean;
+    reason?: PVCExpandDisabledReason | PVCSnapshotDisabledReason;
+    tooltip?: string;
+}
+export type PVCActionTooltipMapper = (reason: PVCExpandDisabledReason | PVCSnapshotDisabledReason) => string;
+export declare function defaultPVCExpandTooltipMapper(reason: PVCExpandDisabledReason): "" | "pvc_deleting_can_not_operate" | "pvc_rebuilding_can_not_operate" | "pvc_storage_class_not_found" | "pvc_status_forbid_expansion" | "pvc_static_forbid_expansion" | "pvc_storageclass_forbid_expansion" | "pvc_existed_snapshot_forbid_expansion";
+export declare function defaultPVCSnapshotTooltipMapper(reason: PVCSnapshotDisabledReason): "" | "pvc_deleting_can_not_operate" | "pvc_storage_class_not_found" | "pvc_status_forbid_snapshot" | "unsupported_volume_snapshot" | "snapshot_disabled_tip" | "snapshot_plugin_disabled_tip" | "pvc_expansion_forbid_snapshot";
+export declare class PVCUtilService {
+    private readonly dialog;
+    private readonly k8sApi;
+    private readonly acpApi;
+    private readonly storageCommonUtil;
+    private readonly http;
+    constructor(dialog: DialogService, k8sApi: K8sApiService, acpApi: AcpCommonApiService, storageCommonUtil: StorageCommonUtilService, http: HttpClient);
+    getRelatedPods(cluster: string, namespace: string, pvcName: string): Observable<Pod[]>;
+    storageClassListCache: CacheStore<Readonly<{
+        project: string;
+        cluster: string;
+        namespace: string;
+    }>, StorageClass[]>;
+    volumeSnapshotListCatch: CacheStore<Readonly<{
+        project: string;
+        cluster: string;
+        namespace: string;
+    }>, VolumeSnapshot[]>;
+    volumeSnapshotClassListCache: CacheStore<Readonly<{
+        project: string;
+        cluster: string;
+        namespace: string;
+    }>, VolumeSnapshotClass[]>;
+    snapshotPluginCache: CacheStore<Readonly<{
+        project: string;
+        cluster: string;
+        namespace: string;
+    }>, boolean>;
+    getSource$(pod: Pod, cluster: string, namespace: string): Observable<{
+        name: string;
+        kind: string;
+    }>;
+    private getSourceInfo$;
+    private sameOwnerReference;
+    delete(pvc: PersistentVolumeClaim, cluster: string, namespace: string): import("@alauda/ui").DialogRef<DeletePvcDialogComponent, any>;
+    rebuild(pvc: PersistentVolumeClaim, cluster: string, namespace: string): void;
+    getVolumeSnapshotEnabled$({ namespace, cluster }: Workspace): Observable<boolean>;
+    private getStorageClassList$;
+    private getVolumeSnapshotList$;
+    private getVolumeSnapshotClassList$;
+    getPvcExpandStateFn$(workspace: Workspace): Observable<PVCActionStateFn>;
+    getPvcSnapshotStateFn$(workspace: Workspace): Observable<PVCActionStateFn>;
+    getPvcExpandState({ pvc, scList, vsList, mapper, }: {
+        pvc: PersistentVolumeClaim;
+        scList: StorageClass[];
+        vsList: VolumeSnapshot[];
+        mapper?: PVCActionTooltipMapper;
+    }): {
+        disabled: boolean;
+        reason: PVCExpandDisabledReason;
+        tooltip: string;
+    };
+    private getPvcExpandDisabledReason;
+    getPvcSnapshotState({ pvc, scList, vscList, pluginEnabled, storageDescriptionList, mapper, }: {
+        pvc: PersistentVolumeClaim;
+        scList: StorageClass[];
+        vscList: VolumeSnapshotClass[];
+        pluginEnabled: boolean;
+        storageDescriptionList: StringMap[];
+        mapper?: PVCActionTooltipMapper;
+    }): {
+        disabled: boolean;
+        reason: PVCSnapshotDisabledReason;
+        tooltip: string;
+    };
+    getPvcUpdateDisabledState(pvc: PersistentVolumeClaim): {
+        disabled: boolean;
+        tooltip?: string;
+    };
+    getPvcRebuildDisabledState$(pvc: PersistentVolumeClaim, cluster: string, namespace: string): Observable<{
+        disabled: boolean;
+        tooltip?: string;
+    }>;
+    getPvcDeleteDisabledState(pvc: PersistentVolumeClaim): {
+        disabled: boolean;
+        tooltip?: string;
+    };
+    private getPvcSnapshotDisabledReason;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PVCUtilService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PVCUtilService>;
+}

package/lib/types/commons.d.ts

@@ -0,0 +1,85 @@
+import { AccessMode, VolumeMode, ValueOf, Translation, GenericStatusColor, GenericStatusIcon } from '@alauda-fe/common';
+import { StorageProvider } from './internal';
+export declare enum StorageProvisioner {
+    CEPH_FS_INTERNAL = "rook-ceph.cephfs.csi.ceph.com",
+    CEPH_FS_RBD = "rook-ceph.rbd.csi.ceph.com",
+    CEPH_OBJECT = "rook-ceph.ceph.rook.io/bucket",
+    CEPH_COSI = "ceph.objectstorage.k8s.io",
+    CEPH_FS = "ceph.com/cephfs",
+    NFS = "cpaas.io/nfs-client",
+    TOPOLVM = "topolvm.cybozu.com",
+    HUAWEI_CSI = "csi.huawei.com",
+    NFS_CSI = "nfs.csi.k8s.io",
+    CSTOR_CSI = "cstor.csi.openebs.io",
+    MINIO = "minio.objectstorage.k8s.io"
+}
+export declare const StorageType: {
+    readonly FILE_STORAGE: "file_storage";
+    readonly OBJECT_STORAGE: "object_storage";
+    readonly BLOCK_STORAGE: "block_storage";
+};
+export type StorageType = ValueOf<typeof StorageType>;
+export declare enum StorageclassFeature {
+    SNAPSHOT = "snapshot",
+    EXPANSION = "expansion"
+}
+export interface StorageOption {
+    provisioner: StorageProvisioner;
+    gate?: string;
+    clusterGate?: string;
+    module?: string;
+    provider: StorageProvider;
+    type?: StorageType;
+    display?: Translation;
+    accessModes: AccessMode[];
+    /** features字段中有StorageclassFeature.SNAPSHOT才有这个 */
+    snapshotAccessModes?: AccessMode[];
+    features: StorageclassFeature[];
+    volumeModes: VolumeMode[];
+    supportTypes?: StorageType[];
+    disabled?: boolean;
+}
+export declare enum VolumeBindingMode {
+    Immediate = "Immediate",
+    WaitForFirstConsumer = "WaitForFirstConsumer"
+}
+export declare enum ReclaimPolicy {
+    Retain = "Retain",
+    Delete = "Delete"
+}
+export declare enum PvcStatusEnum {
+    processing = "processing",
+    bound = "bound",
+    invalid = "invalid",
+    waiting = "waiting_to_bind_after_mounting"
+}
+export declare const PvcStatusColorMapper: {
+    processing: GenericStatusColor;
+    waiting_to_bind_after_mounting: GenericStatusColor;
+    bound: GenericStatusColor;
+    invalid: GenericStatusColor;
+};
+export declare const PvcStatusIconMapper: {
+    processing: GenericStatusIcon;
+    waiting_to_bind_after_mounting: GenericStatusIcon;
+    bound: string;
+    invalid: GenericStatusIcon;
+};
+export declare enum PvStatusEnum {
+    AVAILABLE = "available",
+    BOUND = "bound",
+    WAITING_RECYCLE = "waiting_recycle",
+    RECYCLE_FAILED = "recycle_failed"
+}
+export declare const PvStatusColorMapper: {
+    available: GenericStatusColor;
+    bound: GenericStatusColor;
+    waiting_recycle: GenericStatusColor;
+    recycle_failed: GenericStatusColor;
+};
+export declare const PvStatusIconMapper: {
+    available: GenericStatusIcon;
+    bound: string;
+    waiting_recycle: string;
+    recycle_failed: GenericStatusIcon;
+};

package/lib/types/internal.d.ts

@@ -0,0 +1,4 @@
+export declare enum StorageProvider {
+    PLATFORM = "platform",
+    THIRD_PARTY = "third_party"
+}

package/lib/types/k8s.d.ts

@@ -0,0 +1,105 @@
+import { AccessMode, KubernetesResource, StringMap } from '@alauda-fe/common';
+import { ReclaimPolicy, StorageProvisioner, VolumeBindingMode } from './commons';
+export interface VolumeSnapshotClass extends KubernetesResource {
+    driver: string;
+    parameters?: StringMap;
+    deletionPolicy?: string;
+}
+export interface VolumeSnapshot extends KubernetesResource {
+    spec: VolumeSnapshotSpec;
+    status?: {
+        boundVolumeSnapshotContentName?: string;
+        readyToUse?: boolean;
+        error?: string;
+        restoreSize?: string;
+    };
+}
+export interface VolumeSnapshotSpec {
+    volumeSnapshotClassName: string;
+    source?: {
+        persistentVolumeClaimName?: string;
+    };
+}
+export interface StorageClass extends KubernetesResource {
+    apiVersion: 'storage.k8s.io/v1';
+    kind: 'StorageClass';
+    mountOptions?: string[];
+    parameters?: StringMap;
+    provisioner?: StorageProvisioner;
+    reclaimPolicy?: ReclaimPolicy;
+    volumeBindingMode?: VolumeBindingMode;
+    allowVolumeExpansion?: boolean;
+}
+export interface BucketClass extends KubernetesResource {
+    kind: 'BucketClass';
+    driverName: StorageProvisioner;
+    deletionPolicy?: ReclaimPolicy;
+    isDefaultBucketClass?: boolean;
+    parameters?: StringMap;
+    protocol?: {
+        s3: {
+            region: string;
+            signatureVersion: string;
+        };
+    };
+}
+export type CommonStorageClass = StorageClass | BucketClass;
+export type CommonStorageClassKind = CommonStorageClass extends {
+    kind: infer K;
+} ? K : never;
+export interface CephFSPersistentVolumeSource {
+    monitors: string[];
+    path?: string;
+    secretRef: SecretReference;
+    user: string;
+}
+export interface SecretReference {
+    name: string;
+    namespace: string;
+}
+export interface PersistentVolumeSpec extends PersistentVolumeSpecMeta {
+    accessModes: [AccessMode];
+    storageClassName?: string;
+}
+export interface PersistentVolume extends KubernetesResource {
+    apiVersion: string;
+    kind: string;
+    spec: PersistentVolumeSpec;
+    status?: {
+        phase: string;
+    };
+}
+export interface PersistentVolumeSpecMeta {
+    capacity: {
+        storage: string;
+    };
+    claimRef?: {
+        apiVersion: string;
+        kind: 'PersistentVolumeClaim';
+        name: string;
+        namespace: string;
+        uid: string;
+    };
+    persistentVolumeReclaimPolicy: 'Retain' | 'Delete';
+    hostPath?: {
+        path: string;
+    };
+    nfs?: {
+        server: string;
+        path: string;
+    };
+    cephfs?: CephFSPersistentVolumeSource;
+    mountOptions?: string[];
+    csi?: {
+        driver?: string;
+        readOnly?: boolean;
+        /** 该字段由UI生成， 需保证集群唯一， 可采用uuid */
+        volumeHandle?: string;
+        volumeAttributes: {
+            /** nfs 服务端地址 */
+            server: string;
+            /** nfs 服务端fs目录 */
+            share: string;
+        };
+    };
+}