@alauda-fe/dynamic-plugin-shared 0.0.1-alpha.0

package/esm2022/k8s-resource-list/k8s-resource-paged-list.mjs

@@ -0,0 +1,174 @@
+import { WatchEvent } from '@alauda-fe/dynamic-plugin-sdk';
+import { inject } from '@angular/core';
+import { toObservable, toSignal } from '@angular/core/rxjs-interop';
+import { ActivatedRoute, Router } from '@angular/router';
+import { NEVER, Subject, catchError, filter, interval, isObservable, map, of, startWith, switchMap, switchScan, take, withLatestFrom, } from 'rxjs';
+import { DOWNGRADE_WATCH_ENABLED, DOWNGRADE_WATCH_POLLING } from '../constants';
+import { publishRef } from '../utils';
+export class K8SResourcePagedList {
+    constructor(config) {
+        this.config = config;
+        this.reload$$ = new Subject();
+        this.addedUid = new Set();
+        this.deletedUid = new Set();
+        this.params$ = isObservable(this.config.params)
+            ? this.config.params
+            : toObservable(this.config.params);
+        this.loadState$ = this.config.watcher && !DOWNGRADE_WATCH_ENABLED
+            ? this.loadStateWithWatcher()
+            : this.config.watcher || this.config.polling
+                ? this.loadStateWithPolling()
+                : this.sourceLoadState();
+        this.loading$ = this.loadState$.pipe(map(state => state.loading));
+        this.items$ = this.loadState$.pipe(map(state => state.items));
+        this.totalItems$ = this.loadState$.pipe(map(state => state.totalItems));
+        this.loadError$ = this.loadState$.pipe(map(state => state.loadError));
+        this.$loading = toSignal(this.loading$);
+        this.$items = toSignal(this.items$);
+        this.$totalItems = toSignal(this.totalItems$);
+        this.$loadError = toSignal(this.loadError$);
+    }
+    reload() {
+        this.reload$$.next();
+    }
+    sourceLoadState() {
+        return this.params$.pipe(map(parseListParams), switchMap(({ listParams, extraParams }) => {
+            return this.reload$$.pipe(startWith(null), switchMap(() => {
+                return this.config.fetcher(listParams, extraParams).pipe(map(list => ({
+                    loading: false,
+                    loadSuccess: true,
+                    items: list.items ?? [],
+                    totalItems: list.metadata.totalItems ?? 0,
+                })), startWith({
+                    loading: true,
+                    loadSuccess: false,
+                    items: [],
+                    totalItems: 0,
+                }), catchError((err) => of({
+                    loading: false,
+                    loadSuccess: false,
+                    loadError: err,
+                    items: [],
+                    totalItems: 0,
+                })));
+            }));
+        }), publishRef());
+    }
+    loadStateWithPolling() {
+        return this.sourceLoadState().pipe(switchMap(sourceState => sourceState.loadSuccess
+            ? interval(this.config.polling || DOWNGRADE_WATCH_POLLING).pipe(withLatestFrom(this.params$), map(([_, params]) => parseListParams(params)), switchMap(({ listParams, extraParams }) => this.config.fetcher(listParams, extraParams).pipe(map(list => ({
+                ...sourceState,
+                items: list.items,
+                totalItems: list.metadata.totalItems,
+            })), catchError(() => NEVER))), startWith(sourceState))
+            : of(sourceState)), publishRef());
+    }
+    loadStateWithWatcher() {
+        return this.sourceLoadState().pipe(switchMap(sourceState => sourceState.loadSuccess
+            ? this.params$.pipe(take(1), switchMap(params => {
+                const watchParams = parseListParams({
+                    keyword: params.keyword,
+                    extra: params.extra,
+                });
+                const fetchParams = parseListParams(params);
+                return this.config
+                    .watcher(watchParams.listParams, watchParams.extraParams)
+                    .pipe(filter(({ type, object }) => {
+                    switch (type) {
+                        case WatchEvent.Added: {
+                            if (this.addedUid.has(object.metadata.uid)) {
+                                return false;
+                            }
+                            this.addedUid.add(object.metadata.uid);
+                            return true;
+                        }
+                        case WatchEvent.Deleted: {
+                            if (this.deletedUid.has(object.metadata.uid)) {
+                                return false;
+                            }
+                            this.deletedUid.add(object.metadata.uid);
+                            return true;
+                        }
+                        default: {
+                            return true;
+                        }
+                    }
+                }), switchScan((state, { type, object }) => {
+                    switch (type) {
+                        case WatchEvent.Modified: {
+                            return of({
+                                ...state,
+                                items: state.items.map(item => item.metadata.uid === object.metadata.uid
+                                    ? object
+                                    : item),
+                            });
+                        }
+                        case WatchEvent.Added:
+                        case WatchEvent.Deleted: {
+                            return this.config
+                                .fetcher(fetchParams.listParams, fetchParams.extraParams)
+                                .pipe(map(list => ({
+                                ...state,
+                                items: list.items,
+                                totalItems: list.metadata.totalItems,
+                            })), catchError(() => NEVER));
+                        }
+                        default: {
+                            return NEVER;
+                        }
+                    }
+                }, sourceState));
+            }), startWith(sourceState))
+            : of(sourceState)), publishRef());
+    }
+}
+export function extractPagedListParams(defaultParams = {}, extraParams) {
+    const route = inject(ActivatedRoute);
+    const params$ = route.queryParams.pipe(map(params => ({
+        pageIndex: 0,
+        pageSize: 20,
+        ...defaultParams,
+        ...(params.pageIndex ? { pageIndex: params.pageIndex } : {}),
+        ...(params.pageSize ? { pageSize: params.pageSize } : {}),
+        ...(params.keyword ? { keyword: params.keyword } : {}),
+        ...(params.sortField ? { sortField: params.sortField } : {}),
+        ...(params.sortOrder ? { sortOrder: params.sortOrder } : {}),
+        ...(params.fieldSelector ? { fieldSelector: params.fieldSelector } : {}),
+        ...(params.labelSelector ? { labelSelector: params.labelSelector } : {}),
+        ...(extraParams ? { extra: extraParams(params) } : {}),
+    })));
+    return {
+        stream: () => params$,
+        signal: () => toSignal(params$),
+    };
+}
+export function queryListParams() {
+    const router = inject(Router);
+    const route = inject(ActivatedRoute);
+    return (queryParams) => {
+        router.navigate(['./'], {
+            relativeTo: route,
+            queryParamsHandling: 'merge',
+            queryParams,
+        });
+    };
+}
+function parseListParams({ pageIndex, pageSize, sortField, sortOrder, keyword, fieldSelector: originFieldSelector, labelSelector, extra: extraParams, }) {
+    const search = keyword ? `search=${keyword}` : '';
+    const sortBy = sortField
+        ? `sortby=${sortOrder === 'desc' ? '-' : ''}${sortField}`
+        : '';
+    const fieldSelector = [search, sortBy, originFieldSelector]
+        .filter(v => !!v)
+        .join(',');
+    return {
+        listParams: {
+            limit: (pageSize || 20) + '',
+            continue: +(pageIndex || 0) * +(pageSize || 20) + '',
+            ...(labelSelector ? { labelSelector } : {}),
+            ...(fieldSelector ? { fieldSelector } : {}),
+        },
+        extraParams,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"k8s-resource-paged-list.js","sourceRoot":"","sources":["../../../../../libs/dynamic-plugin-shared/src/k8s-resource-list/k8s-resource-paged-list.ts"],"names":[],"mappings":"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","sourcesContent":["import { WatchAPIResponse, WatchEvent } from '@alauda-fe/dynamic-plugin-sdk';\nimport { HttpErrorResponse } from '@angular/common/http';\nimport { Signal, inject } from '@angular/core';\nimport { toObservable, toSignal } from '@angular/core/rxjs-interop';\nimport { ActivatedRoute, Params, Router } from '@angular/router';\nimport {\n  NEVER,\n  Observable,\n  Subject,\n  catchError,\n  filter,\n  interval,\n  isObservable,\n  map,\n  of,\n  startWith,\n  switchMap,\n  switchScan,\n  take,\n  withLatestFrom,\n} from 'rxjs';\n\nimport { DOWNGRADE_WATCH_ENABLED, DOWNGRADE_WATCH_POLLING } from '../constants';\nimport { KubernetesResource, KubernetesResourceList, Status } from '../types';\nimport { publishRef } from '../utils';\n\nexport class K8SResourcePagedList<\n  R extends KubernetesResource = KubernetesResource,\n  P = unknown,\n> {\n  private readonly reload$$ = new Subject<void>();\n  private readonly addedUid = new Set<string>();\n  private readonly deletedUid = new Set<string>();\n\n  params$ = isObservable(this.config.params)\n    ? this.config.params\n    : toObservable(this.config.params);\n\n  loadState$ =\n    this.config.watcher && !DOWNGRADE_WATCH_ENABLED\n      ? this.loadStateWithWatcher()\n      : this.config.watcher || this.config.polling\n        ? this.loadStateWithPolling()\n        : this.sourceLoadState();\n\n  loading$ = this.loadState$.pipe(map(state => state.loading));\n  items$ = this.loadState$.pipe(map(state => state.items));\n  totalItems$ = this.loadState$.pipe(map(state => state.totalItems));\n  loadError$ = this.loadState$.pipe(map(state => state.loadError));\n\n  $loading = toSignal(this.loading$);\n  $items = toSignal(this.items$);\n  $totalItems = toSignal(this.totalItems$);\n  $loadError = toSignal(this.loadError$);\n\n  constructor(private readonly config: PagedListConfig<R, P>) {}\n\n  reload() {\n    this.reload$$.next();\n  }\n\n  private sourceLoadState() {\n    return this.params$.pipe(\n      map(parseListParams),\n      switchMap(({ listParams, extraParams }) => {\n        return this.reload$$.pipe(\n          startWith(null),\n          switchMap((): Observable<LoadState<R>> => {\n            return this.config.fetcher(listParams, extraParams).pipe(\n              map(list => ({\n                loading: false,\n                loadSuccess: true,\n                items: list.items ?? [],\n                totalItems: list.metadata.totalItems ?? 0,\n              })),\n              startWith({\n                loading: true,\n                loadSuccess: false,\n                items: [],\n                totalItems: 0,\n              }),\n              catchError((err: Status | HttpErrorResponse) =>\n                of({\n                  loading: false,\n                  loadSuccess: false,\n                  loadError: err,\n                  items: [],\n                  totalItems: 0,\n                }),\n              ),\n            );\n          }),\n        );\n      }),\n      publishRef(),\n    );\n  }\n\n  private loadStateWithPolling(): Observable<LoadState<R>> {\n    return this.sourceLoadState().pipe(\n      switchMap(sourceState =>\n        sourceState.loadSuccess\n          ? interval(this.config.polling || DOWNGRADE_WATCH_POLLING).pipe(\n              withLatestFrom(this.params$),\n              map(([_, params]) => parseListParams(params)),\n              switchMap(({ listParams, extraParams }) =>\n                this.config.fetcher(listParams, extraParams).pipe(\n                  map(list => ({\n                    ...sourceState,\n                    items: list.items,\n                    totalItems: list.metadata.totalItems,\n                  })),\n                  catchError(() => NEVER),\n                ),\n              ),\n              startWith(sourceState),\n            )\n          : of(sourceState),\n      ),\n      publishRef(),\n    );\n  }\n\n  private loadStateWithWatcher(): Observable<LoadState<R>> {\n    return this.sourceLoadState().pipe(\n      switchMap(sourceState =>\n        sourceState.loadSuccess\n          ? this.params$.pipe(\n              take(1),\n              switchMap(params => {\n                const watchParams = parseListParams({\n                  keyword: params.keyword,\n                  extra: params.extra,\n                });\n                const fetchParams = parseListParams(params);\n                return this.config\n                  .watcher(watchParams.listParams, watchParams.extraParams)\n                  .pipe(\n                    filter(({ type, object }) => {\n                      switch (type) {\n                        case WatchEvent.Added: {\n                          if (this.addedUid.has(object.metadata.uid)) {\n                            return false;\n                          }\n                          this.addedUid.add(object.metadata.uid);\n                          return true;\n                        }\n                        case WatchEvent.Deleted: {\n                          if (this.deletedUid.has(object.metadata.uid)) {\n                            return false;\n                          }\n                          this.deletedUid.add(object.metadata.uid);\n                          return true;\n                        }\n                        default: {\n                          return true;\n                        }\n                      }\n                    }),\n                    switchScan((state, { type, object }) => {\n                      switch (type) {\n                        case WatchEvent.Modified: {\n                          return of({\n                            ...state,\n                            items: state.items.map(item =>\n                              item.metadata.uid === object.metadata.uid\n                                ? object\n                                : item,\n                            ),\n                          });\n                        }\n                        case WatchEvent.Added:\n                        case WatchEvent.Deleted: {\n                          return this.config\n                            .fetcher(\n                              fetchParams.listParams,\n                              fetchParams.extraParams,\n                            )\n                            .pipe(\n                              map(list => ({\n                                ...state,\n                                items: list.items,\n                                totalItems: list.metadata.totalItems,\n                              })),\n                              catchError(() => NEVER),\n                            );\n                        }\n                        default: {\n                          return NEVER;\n                        }\n                      }\n                    }, sourceState),\n                  );\n              }),\n              startWith(sourceState),\n            )\n          : of(sourceState),\n      ),\n      publishRef(),\n    );\n  }\n}\n\nexport interface PagedListConfig<R, P> {\n  params: Signal<ListFetchParams<P>> | Observable<ListFetchParams<P>>;\n  fetcher: (\n    listParams: FetchSeed,\n    extraParams: P,\n  ) => Observable<KubernetesResourceList<R>>;\n  watcher?: (\n    listParams: FetchSeed,\n    extraParams: P,\n  ) => Observable<WatchAPIResponse<R>>;\n  polling?: number;\n}\n\nexport interface ListFetchParams<P = never> {\n  pageIndex?: number | string;\n  pageSize?: number | string;\n  sortField?: string;\n  sortOrder?: 'asc' | 'desc';\n  keyword?: string;\n  fieldSelector?: string;\n  labelSelector?: string;\n  extra?: P;\n}\n\nexport interface FetchSeed extends Record<string, string> {\n  limit?: string;\n  continue?: string;\n  fieldSelector?: string;\n}\n\ninterface LoadState<R> {\n  items: R[];\n  totalItems: number;\n  loading: boolean;\n  loadSuccess: boolean;\n  loadError?: HttpErrorResponse | Status;\n}\n\nexport function extractPagedListParams<P>(\n  defaultParams: ListFetchParams = {},\n  extraParams?: (queryParams: Params) => P,\n): Readonly<{\n  stream: () => Observable<ListFetchParams<P>>;\n  signal: () => Signal<ListFetchParams<P>>;\n}> {\n  const route = inject(ActivatedRoute);\n  const params$ = route.queryParams.pipe(\n    map(params => ({\n      pageIndex: 0,\n      pageSize: 20,\n      ...defaultParams,\n      ...(params.pageIndex ? { pageIndex: params.pageIndex } : {}),\n      ...(params.pageSize ? { pageSize: params.pageSize } : {}),\n      ...(params.keyword ? { keyword: params.keyword } : {}),\n      ...(params.sortField ? { sortField: params.sortField } : {}),\n      ...(params.sortOrder ? { sortOrder: params.sortOrder } : {}),\n      ...(params.fieldSelector ? { fieldSelector: params.fieldSelector } : {}),\n      ...(params.labelSelector ? { labelSelector: params.labelSelector } : {}),\n      ...(extraParams ? { extra: extraParams(params) } : {}),\n    })),\n  );\n\n  return {\n    stream: () => params$,\n    signal: () => toSignal(params$),\n  };\n}\n\nexport function queryListParams() {\n  const router = inject(Router);\n  const route = inject(ActivatedRoute);\n\n  return (queryParams: Params) => {\n    router.navigate(['./'], {\n      relativeTo: route,\n      queryParamsHandling: 'merge',\n      queryParams,\n    });\n  };\n}\n\nfunction parseListParams<P>({\n  pageIndex,\n  pageSize,\n  sortField,\n  sortOrder,\n  keyword,\n  fieldSelector: originFieldSelector,\n  labelSelector,\n  extra: extraParams,\n}: ListFetchParams<P>) {\n  const search = keyword ? `search=${keyword}` : '';\n  const sortBy = sortField\n    ? `sortby=${sortOrder === 'desc' ? '-' : ''}${sortField}`\n    : '';\n  const fieldSelector = [search, sortBy, originFieldSelector]\n    .filter(v => !!v)\n    .join(',');\n  return {\n    listParams: {\n      limit: (pageSize || 20) + '',\n      continue: +(pageIndex || 0) * +(pageSize || 20) + '',\n      ...(labelSelector ? { labelSelector } : {}),\n      ...(fieldSelector ? { fieldSelector } : {}),\n    } as FetchSeed,\n    extraParams,\n  };\n}\n"]}

package/esm2022/k8s-resource-list/types.mjs

@@ -0,0 +1,11 @@
+/**
+ * @packageDocumentation
+ * @module k8s-resource-list
+ */
+export var LoadAction;
+(function (LoadAction) {
+    LoadAction["Reload"] = "Reload";
+    LoadAction["SilentReload"] = "SilentReload";
+    LoadAction["LoadMore"] = "LoadMore";
+})(LoadAction || (LoadAction = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/k8s-resource-list/utils.mjs

@@ -0,0 +1,84 @@
+/**
+ * @packageDocumentation
+ * @module k8s-resource-list
+ */
+import { equals } from 'ramda';
+import { distinctUntilChanged, map } from 'rxjs';
+/**
+ * convert selector.matchLabels to string
+ * refers to: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api
+ */
+export function matchLabelsToString(params = {}) {
+    return Object.keys(params)
+        .map(key => `${key}=${params[key] || ''}`)
+        .join(',');
+}
+/**
+ * convert string to selector.matchLabels
+ */
+export function stringToMatchLabels(str) {
+    const labels = {};
+    if (str) {
+        return str.split(',').reduce((acc, item) => {
+            const [key, value] = item.split('=');
+            if (key && value) {
+                acc[key] = value;
+            }
+            return acc;
+        }, labels);
+    }
+    return labels;
+}
+export function matchExpressionsToString(params) {
+    return params
+        .map(param => {
+        switch (param.operator.toLowerCase()) {
+            case '=':
+            case '==': {
+                return `${param.key}${param.operator}${param.values[0]}`;
+            }
+            case '!': {
+                return `!${param.key}`;
+            }
+            case '!=': {
+                return param.values
+                    .map(value => `${param.key}${param.operator}${value}`)
+                    .join(',');
+            }
+            case 'in':
+            case 'notin': {
+                return `${param.key} ${param.operator} (${param.values
+                    .filter(Boolean)
+                    .join(',')})`;
+            }
+            case 'exists': {
+                return `${param.key}`;
+            }
+            case 'doesnotexist': {
+                return `!${param.key}`;
+            }
+            default: {
+                return param.key;
+            }
+        }
+    })
+        .join(',');
+}
+export function extractListParamsFromRoute(route) {
+    return route.queryParamMap.pipe(map(paramMap => ({
+        labelSelector: paramMap.get('labelSelector'),
+        fieldSelector: paramMap.get('fieldSelector'),
+        keyword: paramMap.get('keyword'),
+        field: paramMap.get('field'),
+    })), distinctUntilChanged(equals));
+}
+export function normalizeParams(params) {
+    return Object.entries(params).reduce((acc, [key, value]) => {
+        value = typeof value === 'string' ? value.trim() : value;
+        if (value) {
+            acc[key] = value;
+        }
+        return acc;
+    }, {});
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/k8s-shared/constants.mjs

@@ -0,0 +1,53 @@
+import { AIT_API_GROUP, COMMON_RESOURCE_DEFINITIONS } from '../constants';
+export const CONTROLLED_RESOURCE_TRANSLATIONS = [
+    {
+        kind: 'Application',
+        definition: COMMON_RESOURCE_DEFINITIONS.OAM_APPLICATION,
+        kindAlias: 'oam_application',
+    },
+    { kind: 'Application', definition: COMMON_RESOURCE_DEFINITIONS.APPLICATION },
+    { kind: 'Deployment', definition: COMMON_RESOURCE_DEFINITIONS.DEPLOYMENT },
+    { kind: 'DaemonSet', definition: COMMON_RESOURCE_DEFINITIONS.DAEMON_SET },
+    { kind: 'StatefulSet', definition: COMMON_RESOURCE_DEFINITIONS.STATEFUL_SET },
+    { kind: 'Job', definition: COMMON_RESOURCE_DEFINITIONS.JOB },
+    { kind: 'CronJob', definition: COMMON_RESOURCE_DEFINITIONS.CRON_JOB },
+    { kind: 'Service', definition: COMMON_RESOURCE_DEFINITIONS.SERVICE },
+    { kind: 'Ingress', definition: COMMON_RESOURCE_DEFINITIONS.INGRESS },
+    {
+        kind: 'PersistentVolumeClaim',
+        definition: COMMON_RESOURCE_DEFINITIONS.PERSISTENT_VOLUME_CLAIM,
+    },
+    { kind: 'ConfigMap', definition: COMMON_RESOURCE_DEFINITIONS.CONFIG_MAP },
+    { kind: 'Secret', definition: COMMON_RESOURCE_DEFINITIONS.SECRET },
+    {
+        kind: 'HorizontalPodAutoscaler',
+        definition: COMMON_RESOURCE_DEFINITIONS.HORIZONTAL_POD_AUTOSCALER,
+    },
+    {
+        kind: 'PrometheusRule',
+        definition: COMMON_RESOURCE_DEFINITIONS.PROMETHEUS_RULE,
+        kindAlias: 'alarm',
+    },
+    {
+        kind: 'MonitorDashboard',
+        kindAlias: 'Monitor_Dashboard_New',
+        definition: {
+            apiGroup: 'ait.alauda.io',
+            type: 'dashboards',
+            apiVersion: 'v1alpha1',
+        },
+    },
+    {
+        kind: 'Dashboard',
+        definition: {
+            type: 'monitordashboards',
+            apiVersion: 'v1alpha2',
+            apiGroup: AIT_API_GROUP,
+        },
+    },
+    {
+        kind: 'ServiceMonitor',
+        definition: COMMON_RESOURCE_DEFINITIONS.SERVICE_MONITOR,
+    },
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGlicy9keW5hbWljLXBsdWdpbi1zaGFyZWQvc3JjL2s4cy1zaGFyZWQvY29uc3RhbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxhQUFhLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFRMUUsTUFBTSxDQUFDLE1BQU0sZ0NBQWdDLEdBQXlCO0lBQ3BFO1FBQ0UsSUFBSSxFQUFFLGFBQWE7UUFDbkIsVUFBVSxFQUFFLDJCQUEyQixDQUFDLGVBQWU7UUFDdkQsU0FBUyxFQUFFLGlCQUFpQjtLQUM3QjtJQUNELEVBQUUsSUFBSSxFQUFFLGFBQWEsRUFBRSxVQUFVLEVBQUUsMkJBQTJCLENBQUMsV0FBVyxFQUFFO0lBQzVFLEVBQUUsSUFBSSxFQUFFLFlBQVksRUFBRSxVQUFVLEVBQUUsMkJBQTJCLENBQUMsVUFBVSxFQUFFO0lBQzFFLEVBQUUsSUFBSSxFQUFFLFdBQVcsRUFBRSxVQUFVLEVBQUUsMkJBQTJCLENBQUMsVUFBVSxFQUFFO0lBQ3pFLEVBQUUsSUFBSSxFQUFFLGFBQWEsRUFBRSxVQUFVLEVBQUUsMkJBQTJCLENBQUMsWUFBWSxFQUFFO0lBQzdFLEVBQUUsSUFBSSxFQUFFLEtBQUssRUFBRSxVQUFVLEVBQUUsMkJBQTJCLENBQUMsR0FBRyxFQUFFO0lBQzVELEVBQUUsSUFBSSxFQUFFLFNBQVMsRUFBRSxVQUFVLEVBQUUsMkJBQTJCLENBQUMsUUFBUSxFQUFFO0lBQ3JFLEVBQUUsSUFBSSxFQUFFLFNBQVMsRUFBRSxVQUFVLEVBQUUsMkJBQTJCLENBQUMsT0FBTyxFQUFFO0lBQ3BFLEVBQUUsSUFBSSxFQUFFLFNBQVMsRUFBRSxVQUFVLEVBQUUsMkJBQTJCLENBQUMsT0FBTyxFQUFFO0lBQ3BFO1FBQ0UsSUFBSSxFQUFFLHVCQUF1QjtRQUM3QixVQUFVLEVBQUUsMkJBQTJCLENBQUMsdUJBQXVCO0tBQ2hFO0lBQ0QsRUFBRSxJQUFJLEVBQUUsV0FBVyxFQUFFLFVBQVUsRUFBRSwyQkFBMkIsQ0FBQyxVQUFVLEVBQUU7SUFDekUsRUFBRSxJQUFJLEVBQUUsUUFBUSxFQUFFLFVBQVUsRUFBRSwyQkFBMkIsQ0FBQyxNQUFNLEVBQUU7SUFDbEU7UUFDRSxJQUFJLEVBQUUseUJBQXlCO1FBQy9CLFVBQVUsRUFBRSwyQkFBMkIsQ0FBQyx5QkFBeUI7S0FDbEU7SUFDRDtRQUNFLElBQUksRUFBRSxnQkFBZ0I7UUFDdEIsVUFBVSxFQUFFLDJCQUEyQixDQUFDLGVBQWU7UUFDdkQsU0FBUyxFQUFFLE9BQU87S0FDbkI7SUFDRDtRQUNFLElBQUksRUFBRSxrQkFBa0I7UUFDeEIsU0FBUyxFQUFFLHVCQUF1QjtRQUNsQyxVQUFVLEVBQUU7WUFDVixRQUFRLEVBQUUsZUFBZTtZQUN6QixJQUFJLEVBQUUsWUFBWTtZQUNsQixVQUFVLEVBQUUsVUFBVTtTQUN2QjtLQUNGO0lBQ0Q7UUFDRSxJQUFJLEVBQUUsV0FBVztRQUNqQixVQUFVLEVBQUU7WUFDVixJQUFJLEVBQUUsbUJBQW1CO1lBQ3pCLFVBQVUsRUFBRSxVQUFVO1lBQ3RCLFFBQVEsRUFBRSxhQUFhO1NBQ3hCO0tBQ0Y7SUFDRDtRQUNFLElBQUksRUFBRSxnQkFBZ0I7UUFDdEIsVUFBVSxFQUFFLDJCQUEyQixDQUFDLGVBQWU7S0FDeEQ7Q0FDRixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSzhzUmVzb3VyY2VEZWZpbml0aW9uIH0gZnJvbSAnQGFsYXVkYS1mZS9keW5hbWljLXBsdWdpbi1zZGsnO1xuXG5pbXBvcnQgeyBBSVRfQVBJX0dST1VQLCBDT01NT05fUkVTT1VSQ0VfREVGSU5JVElPTlMgfSBmcm9tICcuLi9jb25zdGFudHMnO1xuXG5leHBvcnQgaW50ZXJmYWNlIE1hbmFnZVJlc291cmNlVHlwZSB7XG4gIGtpbmQ6IHN0cmluZztcbiAgZGVmaW5pdGlvbjogSzhzUmVzb3VyY2VEZWZpbml0aW9uO1xuICBraW5kQWxpYXM/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCBjb25zdCBDT05UUk9MTEVEX1JFU09VUkNFX1RSQU5TTEFUSU9OUzogTWFuYWdlUmVzb3VyY2VUeXBlW10gPSBbXG4gIHtcbiAgICBraW5kOiAnQXBwbGljYXRpb24nLFxuICAgIGRlZmluaXRpb246IENPTU1PTl9SRVNPVVJDRV9ERUZJTklUSU9OUy5PQU1fQVBQTElDQVRJT04sXG4gICAga2luZEFsaWFzOiAnb2FtX2FwcGxpY2F0aW9uJyxcbiAgfSxcbiAgeyBraW5kOiAnQXBwbGljYXRpb24nLCBkZWZpbml0aW9uOiBDT01NT05fUkVTT1VSQ0VfREVGSU5JVElPTlMuQVBQTElDQVRJT04gfSxcbiAgeyBraW5kOiAnRGVwbG95bWVudCcsIGRlZmluaXRpb246IENPTU1PTl9SRVNPVVJDRV9ERUZJTklUSU9OUy5ERVBMT1lNRU5UIH0sXG4gIHsga2luZDogJ0RhZW1vblNldCcsIGRlZmluaXRpb246IENPTU1PTl9SRVNPVVJDRV9ERUZJTklUSU9OUy5EQUVNT05fU0VUIH0sXG4gIHsga2luZDogJ1N0YXRlZnVsU2V0JywgZGVmaW5pdGlvbjogQ09NTU9OX1JFU09VUkNFX0RFRklOSVRJT05TLlNUQVRFRlVMX1NFVCB9LFxuICB7IGtpbmQ6ICdKb2InLCBkZWZpbml0aW9uOiBDT01NT05fUkVTT1VSQ0VfREVGSU5JVElPTlMuSk9CIH0sXG4gIHsga2luZDogJ0Nyb25Kb2InLCBkZWZpbml0aW9uOiBDT01NT05fUkVTT1VSQ0VfREVGSU5JVElPTlMuQ1JPTl9KT0IgfSxcbiAgeyBraW5kOiAnU2VydmljZScsIGRlZmluaXRpb246IENPTU1PTl9SRVNPVVJDRV9ERUZJTklUSU9OUy5TRVJWSUNFIH0sXG4gIHsga2luZDogJ0luZ3Jlc3MnLCBkZWZpbml0aW9uOiBDT01NT05fUkVTT1VSQ0VfREVGSU5JVElPTlMuSU5HUkVTUyB9LFxuICB7XG4gICAga2luZDogJ1BlcnNpc3RlbnRWb2x1bWVDbGFpbScsXG4gICAgZGVmaW5pdGlvbjogQ09NTU9OX1JFU09VUkNFX0RFRklOSVRJT05TLlBFUlNJU1RFTlRfVk9MVU1FX0NMQUlNLFxuICB9LFxuICB7IGtpbmQ6ICdDb25maWdNYXAnLCBkZWZpbml0aW9uOiBDT01NT05fUkVTT1VSQ0VfREVGSU5JVElPTlMuQ09ORklHX01BUCB9LFxuICB7IGtpbmQ6ICdTZWNyZXQnLCBkZWZpbml0aW9uOiBDT01NT05fUkVTT1VSQ0VfREVGSU5JVElPTlMuU0VDUkVUIH0sXG4gIHtcbiAgICBraW5kOiAnSG9yaXpvbnRhbFBvZEF1dG9zY2FsZXInLFxuICAgIGRlZmluaXRpb246IENPTU1PTl9SRVNPVVJDRV9ERUZJTklUSU9OUy5IT1JJWk9OVEFMX1BPRF9BVVRPU0NBTEVSLFxuICB9LFxuICB7XG4gICAga2luZDogJ1Byb21ldGhldXNSdWxlJyxcbiAgICBkZWZpbml0aW9uOiBDT01NT05fUkVTT1VSQ0VfREVGSU5JVElPTlMuUFJPTUVUSEVVU19SVUxFLFxuICAgIGtpbmRBbGlhczogJ2FsYXJtJyxcbiAgfSxcbiAge1xuICAgIGtpbmQ6ICdNb25pdG9yRGFzaGJvYXJkJyxcbiAgICBraW5kQWxpYXM6ICdNb25pdG9yX0Rhc2hib2FyZF9OZXcnLFxuICAgIGRlZmluaXRpb246IHtcbiAgICAgIGFwaUdyb3VwOiAnYWl0LmFsYXVkYS5pbycsXG4gICAgICB0eXBlOiAnZGFzaGJvYXJkcycsXG4gICAgICBhcGlWZXJzaW9uOiAndjFhbHBoYTEnLFxuICAgIH0sXG4gIH0sXG4gIHtcbiAgICBraW5kOiAnRGFzaGJvYXJkJyxcbiAgICBkZWZpbml0aW9uOiB7XG4gICAgICB0eXBlOiAnbW9uaXRvcmRhc2hib2FyZHMnLFxuICAgICAgYXBpVmVyc2lvbjogJ3YxYWxwaGEyJyxcbiAgICAgIGFwaUdyb3VwOiBBSVRfQVBJX0dST1VQLFxuICAgIH0sXG4gIH0sXG4gIHtcbiAgICBraW5kOiAnU2VydmljZU1vbml0b3InLFxuICAgIGRlZmluaXRpb246IENPTU1PTl9SRVNPVVJDRV9ERUZJTklUSU9OUy5TRVJWSUNFX01PTklUT1IsXG4gIH0sXG5dO1xuIl19

package/esm2022/k8s-shared/index.mjs

@@ -0,0 +1,12 @@
+/**
+ * @packageDocumentation
+ * @module k8s-shared
+ * @preferred
+ */
+export * from './update-description-dialog/component';
+export * from './update-display-name-dialog/component';
+export * from './update-key-value-dialog/component';
+export * from './k8s-shared-util.service';
+export * from './k8s-resource-translate-key.pipe';
+export * from './resource-mark/component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2R5bmFtaWMtcGx1Z2luLXNoYXJlZC9zcmMvazhzLXNoYXJlZC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBQ0gsY0FBYyx1Q0FBdUMsQ0FBQztBQUN0RCxjQUFjLHdDQUF3QyxDQUFDO0FBQ3ZELGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsMkJBQTJCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBwYWNrYWdlRG9jdW1lbnRhdGlvblxuICogQG1vZHVsZSBrOHMtc2hhcmVkXG4gKiBAcHJlZmVycmVkXG4gKi9cbmV4cG9ydCAqIGZyb20gJy4vdXBkYXRlLWRlc2NyaXB0aW9uLWRpYWxvZy9jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi91cGRhdGUtZGlzcGxheS1uYW1lLWRpYWxvZy9jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi91cGRhdGUta2V5LXZhbHVlLWRpYWxvZy9jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9rOHMtc2hhcmVkLXV0aWwuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2s4cy1yZXNvdXJjZS10cmFuc2xhdGUta2V5LnBpcGUnO1xuZXhwb3J0ICogZnJvbSAnLi9yZXNvdXJjZS1tYXJrL2NvbXBvbmVudCc7XG4iXX0=

package/esm2022/k8s-shared/k8s-resource-translate-key.pipe.mjs

@@ -0,0 +1,31 @@
+import { inject, InjectionToken, Pipe } from '@angular/core';
+import { CONTROLLED_RESOURCE_TRANSLATIONS } from './constants';
+import * as i0 from "@angular/core";
+export const K8S_RESOURCE_TRANSLATE_KEY = new InjectionToken('K8S_RESOURCE_TRANSLATE_KEY', {
+    providedIn: 'root',
+    factory: () => defaultTransform,
+});
+export class K8sResourceTranslateKeyPipe {
+    constructor() {
+        this.getKey = inject(K8S_RESOURCE_TRANSLATE_KEY);
+    }
+    transform(type, apiGroup) {
+        return this.getKey(type, apiGroup);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: K8sResourceTranslateKeyPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.1.1", ngImport: i0, type: K8sResourceTranslateKeyPipe, isStandalone: true, name: "aclK8sResourceTranslateKey" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: K8sResourceTranslateKeyPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'aclK8sResourceTranslateKey',
+                    standalone: true,
+                }]
+        }] });
+function defaultTransform(type, group) {
+    const { kind, kindAlias } = CONTROLLED_RESOURCE_TRANSLATIONS.find(meta => meta.definition.type === type &&
+        (group === meta.definition.apiGroup ||
+            (!group && !meta.definition.apiGroup))) || {};
+    return kindAlias ?? kind?.toLocaleLowerCase() ?? '';
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/k8s-shared/k8s-shared-util.service.mjs

@@ -0,0 +1,152 @@
+import { K8sUtilService, } from '@alauda-fe/dynamic-plugin-sdk';
+import { Injectable, Injector } from '@angular/core';
+import { cloneDeep, get } from 'lodash-es';
+import { Observable, Subject, tap } from 'rxjs';
+import { NAME, TRUE, LABELS, METADATA, PROJECT, } from '../constants';
+import { getK8sResourceAnnotationErrorMapper, getK8sResourceLabelErrorMapper, k8sResourceAnnotationValidator, k8sResourceLabelValidator, } from '../form/validators/utils';
+import { UpdateDescriptionDialogComponent } from './update-description-dialog/component';
+import { UpdateDisplayNameDialogComponent } from './update-display-name-dialog/component';
+import { UpdateKeyValueDialogComponent, } from './update-key-value-dialog/component';
+import * as i0 from "@angular/core";
+export class K8sSharedUtilService extends K8sUtilService {
+    constructor(injector) {
+        super(injector);
+        this.getProjectNames = this.getProjectNames.bind(this);
+    }
+    /**
+     * 更新 Annotation 或 Label
+     */
+    updatePart(params) {
+        const { part, resource, readonlyKeys, getResourceSpec, dialogClass } = params;
+        const keyValues = get(resource, `${METADATA}.${part}`, {});
+        const updated$$ = new Subject();
+        this.dialog.open(UpdateKeyValueDialogComponent, {
+            data: {
+                title: `update_${part}`,
+                keyValues,
+                readonlyKeys,
+                validator: part === 'labels'
+                    ? k8sResourceLabelValidator
+                    : k8sResourceAnnotationValidator,
+                errorMapper: part === 'labels'
+                    ? getK8sResourceLabelErrorMapper(this.translate)
+                    : getK8sResourceAnnotationErrorMapper(this.translate),
+                updateSuccessMsg: `update_${part}_succeeded`,
+                updateFailMsg: `update_${part}_failed`,
+                onUpdate: results => {
+                    const checkedResults = cloneDeep(results);
+                    for (const key of Object.keys(keyValues)) {
+                        if (!(key in checkedResults)) {
+                            checkedResults[key] = null;
+                        }
+                    }
+                    return this.k8sApi['cluster' in params && params.cluster
+                        ? 'patchResource'
+                        : 'patchGlobalResource']({
+                        ...params,
+                        part: {
+                            // @ts-expect-error
+                            metadata: {
+                                [part]: checkedResults,
+                            },
+                            ...(getResourceSpec
+                                ? { spec: getResourceSpec(checkedResults) }
+                                : {}),
+                        },
+                    }).pipe(tap((_resource) => updated$$.next(_resource)));
+                },
+            },
+            fitViewport: true,
+            customClass: dialogClass,
+        });
+        return updated$$.asObservable();
+    }
+    updateDisplayName({ type, cluster, resource, definition, }, validateMaxLength = false) {
+        return new Observable(observer => {
+            const dialogRef = this.dialog.open(UpdateDisplayNameDialogComponent, {
+                data: {
+                    definition,
+                    resource,
+                    cluster,
+                    type,
+                    validateMaxLength,
+                },
+            });
+            dialogRef.afterClosed().subscribe(updated => {
+                if (updated) {
+                    observer.next(updated);
+                }
+                observer.complete();
+            });
+        });
+    }
+    updateDescription({ type, cluster, resource, definition, }) {
+        return new Observable(observer => {
+            const dialogRef = this.dialog.open(UpdateDescriptionDialogComponent, {
+                data: {
+                    resource,
+                    cluster,
+                    type,
+                    definition,
+                },
+            });
+            dialogRef.afterClosed().subscribe(updated => {
+                if (updated) {
+                    observer.next(updated);
+                }
+                observer.complete();
+            });
+        });
+    }
+    /**
+     * 单项目绑定切换至多项目绑定时，兼容之前的 project name 形式
+     * 老格式 cpaas.io/project: "ALL_ALL" 或者  project.cpaas.io/name: "ALL_ALL"
+     * 新格式 project.cpaas.io/ALL_ALL: "true"
+     * @param {(KubernetesResource | string[])} resource
+     * @returns
+     * @memberof K8sUtilService
+     */
+    getProjectNames(resource) {
+        if (Array.isArray(resource)) {
+            return resource;
+        }
+        const projectLabelPrefix = `${PROJECT}.${this.baseDomain}/`;
+        const labels = get(resource, [METADATA, LABELS], {});
+        return Object.entries(labels)
+            .reduce((acc, [key, value]) => {
+            if (key.startsWith(projectLabelPrefix)) {
+                const projectName = key.slice(projectLabelPrefix.length);
+                if (value === TRUE) {
+                    acc.push(projectName);
+                }
+                else if (projectName === NAME) {
+                    acc.push(value);
+                }
+            }
+            else if (key === this.normalizeType(PROJECT)) {
+                acc.push(value);
+            }
+            return acc;
+        }, [])
+            .filter(Boolean);
+    }
+    getProjectLabels(projects, value = TRUE) {
+        return projects?.reduce((acc, project) => {
+            if (project) {
+                Object.assign(acc, {
+                    [this.normalizeType(project, PROJECT)]: value,
+                });
+            }
+            return acc;
+        }, {});
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: K8sSharedUtilService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: K8sSharedUtilService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: K8sSharedUtilService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"k8s-shared-util.service.js","sourceRoot":"","sources":["../../../../../libs/dynamic-plugin-shared/src/k8s-shared/k8s-shared-util.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  K8sResourceDefinition,\n  ResourceWriteParams,\n  K8sUtilService,\n} from '@alauda-fe/dynamic-plugin-sdk';\nimport { Injectable, Injector } from '@angular/core';\nimport { cloneDeep, get } from 'lodash-es';\nimport { Observable, Subject, tap } from 'rxjs';\n\nimport {\n  ANNOTATIONS,\n  NAME,\n  TRUE,\n  LABELS,\n  METADATA,\n  PROJECT,\n} from '../constants';\nimport {\n  getK8sResourceAnnotationErrorMapper,\n  getK8sResourceLabelErrorMapper,\n  k8sResourceAnnotationValidator,\n  k8sResourceLabelValidator,\n} from '../form/validators/utils';\nimport { KubernetesResource, StringMap } from '../types';\n\nimport { UpdateDescriptionDialogComponent } from './update-description-dialog/component';\nimport { UpdateDisplayNameDialogComponent } from './update-display-name-dialog/component';\nimport {\n  UpdateKeyValueDialogComponent,\n  UpdateKeyValueDialogData,\n} from './update-key-value-dialog/component';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class K8sSharedUtilService<\n  R extends string = string,\n> extends K8sUtilService<R> {\n  constructor(injector: Injector) {\n    super(injector);\n    this.getProjectNames = this.getProjectNames.bind(this);\n  }\n\n  /**\n   * 更新 Annotation 或 Label\n   */\n  updatePart<T extends KubernetesResource>(\n    params: ResourceWriteParams<R, T> & {\n      readonlyKeys?: Array<string | RegExp>;\n      part: typeof ANNOTATIONS | typeof LABELS;\n      getResourceSpec?: (stringMap: StringMap) => Record<string, unknown>;\n      dialogClass?: string;\n    },\n  ) {\n    const { part, resource, readonlyKeys, getResourceSpec, dialogClass } =\n      params;\n    const keyValues: StringMap = get(resource, `${METADATA}.${part}`, {});\n    const updated$$ = new Subject<T>();\n    this.dialog.open<\n      UpdateKeyValueDialogComponent<T>,\n      UpdateKeyValueDialogData<T>\n    >(UpdateKeyValueDialogComponent, {\n      data: {\n        title: `update_${part}`,\n        keyValues,\n        readonlyKeys,\n        validator:\n          part === 'labels'\n            ? k8sResourceLabelValidator\n            : k8sResourceAnnotationValidator,\n        errorMapper:\n          part === 'labels'\n            ? getK8sResourceLabelErrorMapper(this.translate)\n            : getK8sResourceAnnotationErrorMapper(this.translate),\n        updateSuccessMsg: `update_${part}_succeeded`,\n        updateFailMsg: `update_${part}_failed`,\n        onUpdate: results => {\n          const checkedResults = cloneDeep(results);\n          for (const key of Object.keys(keyValues)) {\n            if (!(key in checkedResults)) {\n              checkedResults[key] = null;\n            }\n          }\n          return this.k8sApi[\n            'cluster' in params && params.cluster\n              ? 'patchResource'\n              : 'patchGlobalResource'\n          ]({\n            ...params,\n            part: {\n              // @ts-expect-error\n              metadata: {\n                [part]: checkedResults,\n              },\n              ...(getResourceSpec\n                ? { spec: getResourceSpec(checkedResults) }\n                : {}),\n            },\n          }).pipe(tap((_resource: T) => updated$$.next(_resource)));\n        },\n      },\n      fitViewport: true,\n      customClass: dialogClass,\n    });\n    return updated$$.asObservable();\n  }\n\n  updateDisplayName<T extends KubernetesResource>(\n    {\n      type,\n      cluster,\n      resource,\n      definition,\n    }: {\n      definition?: K8sResourceDefinition;\n      /**\n       * @deprecated use `definition` instead\n       */\n      type?: R;\n      cluster?: string;\n      resource: T;\n    },\n    validateMaxLength = false,\n  ) {\n    return new Observable<T>(observer => {\n      const dialogRef = this.dialog.open<UpdateDisplayNameDialogComponent<T>>(\n        UpdateDisplayNameDialogComponent,\n        {\n          data: {\n            definition,\n            resource,\n            cluster,\n            type,\n            validateMaxLength,\n          },\n        },\n      );\n\n      dialogRef.afterClosed().subscribe(updated => {\n        if (updated) {\n          observer.next(updated);\n        }\n\n        observer.complete();\n      });\n    });\n  }\n\n  updateDescription<T extends KubernetesResource>({\n    type,\n    cluster,\n    resource,\n    definition,\n  }: {\n    /**\n     * @deprecated use `definition` instead\n     */\n    type?: R;\n    definition?: K8sResourceDefinition;\n    cluster?: string;\n    resource: T;\n  }) {\n    return new Observable<T>(observer => {\n      const dialogRef = this.dialog.open<UpdateDescriptionDialogComponent<T>>(\n        UpdateDescriptionDialogComponent,\n        {\n          data: {\n            resource,\n            cluster,\n            type,\n            definition,\n          },\n        },\n      );\n      dialogRef.afterClosed().subscribe(updated => {\n        if (updated) {\n          observer.next(updated);\n        }\n\n        observer.complete();\n      });\n    });\n  }\n\n  /**\n   * 单项目绑定切换至多项目绑定时，兼容之前的 project name 形式\n   * 老格式 cpaas.io/project: \"ALL_ALL\" 或者  project.cpaas.io/name: \"ALL_ALL\"\n   * 新格式 project.cpaas.io/ALL_ALL: \"true\"\n   * @param {(KubernetesResource | string[])} resource\n   * @returns\n   * @memberof K8sUtilService\n   */\n  getProjectNames(resource: KubernetesResource | string[]) {\n    if (Array.isArray(resource)) {\n      return resource;\n    }\n    const projectLabelPrefix = `${PROJECT}.${this.baseDomain}/`;\n    const labels = get(resource, [METADATA, LABELS], {});\n    return Object.entries(labels)\n      .reduce<string[]>((acc, [key, value]) => {\n        if (key.startsWith(projectLabelPrefix)) {\n          const projectName = key.slice(projectLabelPrefix.length);\n          if (value === TRUE) {\n            acc.push(projectName);\n          } else if (projectName === NAME) {\n            acc.push(value);\n          }\n        } else if (key === this.normalizeType(PROJECT)) {\n          acc.push(value);\n        }\n        return acc;\n      }, [])\n      .filter(Boolean);\n  }\n\n  getProjectLabels(projects: string[], value = TRUE) {\n    return projects?.reduce<StringMap>((acc, project) => {\n      if (project) {\n        Object.assign(acc, {\n          [this.normalizeType(project, PROJECT)]: value,\n        });\n      }\n      return acc;\n    }, {});\n  }\n}\n"]}