@alauda-fe/common 1.0.0-next.0

package/esm2022/permission/k8s-permission.service.mjs

@@ -0,0 +1,110 @@
+/**
+ * @packageDocumentation
+ * @module permission
+ */
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { forkJoin, of, map, switchMap } from 'rxjs';
+import { K8sApiResourceService, getApiPrefixParts } from '../api/public-api';
+import { K8sResourceAction, } from '../core';
+import { API_GATEWAY, ifExist, publishRef } from '../core/public-api';
+import { isAllowed } from './helpers';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../api/public-api";
+export class K8sPermissionService {
+    constructor(http, k8sApiResource) {
+        this.http = http;
+        this.k8sApiResource = k8sApiResource;
+        this.getAccess = this.getAccess.bind(this);
+        this.isAllowed = this.isAllowed.bind(this);
+    }
+    getAccess(typeOrResourceParams) {
+        let params;
+        let group;
+        let type$;
+        if ('resource' in typeOrResourceParams) {
+            const { advanced: resourceAdvanced, project: resourceProject, cluster: resourceCluster, resource, action, } = typeOrResourceParams;
+            params = {
+                advanced: resourceAdvanced,
+                project: resourceProject,
+                cluster: resourceCluster,
+                namespace: resource.metadata.namespace,
+                name: resource.metadata.name,
+                action,
+            };
+            group = getApiPrefixParts(resource.apiVersion).apiGroup;
+            type$ = this.k8sApiResource.getResourceType(resource, resourceCluster);
+        }
+        else {
+            params = typeOrResourceParams;
+            const { apiGroup, type } = this.k8sApiResource.getDefinition(params.type);
+            group = apiGroup;
+            type$ = of(type);
+        }
+        const { advanced, project, cluster, namespace, name, action, subResource } = params;
+        const isNameArray = Array.isArray(name);
+        const isActionArray = Array.isArray(action);
+        const isArray = isNameArray && isActionArray;
+        const names = (isNameArray ? name : [name]);
+        const actions = (isActionArray ? action : [action]);
+        return type$.pipe(switchMap(type => forkJoin(names.map(name => of(actions).pipe(switchMap(actionList => forkJoin(actionList.map(action => this._getAccess({
+            action,
+            project,
+            cluster,
+            group,
+            name,
+            namespace,
+            type,
+            advanced,
+            subResource,
+        })))))))), map(accesses => isArray
+            ? accesses
+            : isActionArray
+                ? accesses[0]
+                : isNameArray
+                    ? accesses.map(accessGroup => accessGroup[0])
+                    : accesses[0][0]), publishRef());
+    }
+    isAllowed(typeOrResourceParams) {
+        if (('name' in typeOrResourceParams &&
+            Array.isArray(typeOrResourceParams.name)) ||
+            (typeOrResourceParams.action !== K8sResourceAction.ALL &&
+                !Array.isArray(typeOrResourceParams.action) &&
+                typeOrResourceParams.transform == null)) {
+            typeOrResourceParams.transform = false;
+        }
+        // @ts-expect-error
+        return this.getAccess(typeOrResourceParams).pipe(isAllowed(typeOrResourceParams.transform));
+    }
+    // @internal
+    _getAccess({ action, project, cluster, group, name, namespace, type, advanced, subResource, }) {
+        return this.http.post(`${API_GATEWAY}${advanced
+            ? '/auth'
+            : `${ifExist(cluster, `/kubernetes/${cluster}`)}/apis/authorization.k8s.io`}/v1/selfsubjectaccessreviews`, {
+            apiVersion: 'authorization.k8s.io/v1',
+            kind: 'SelfSubjectAccessReview',
+            spec: {
+                resourceAttributes: {
+                    namespace,
+                    verb: action || (name ? K8sResourceAction.GET : K8sResourceAction.LIST),
+                    group,
+                    resource: type,
+                    name,
+                    cluster: advanced ? cluster : undefined,
+                    project: advanced ? project : undefined,
+                    ...(subResource ? { subResource } : {}),
+                },
+            },
+        });
+    }
+    static { this.ɵfac = function K8sPermissionService_Factory(t) { return new (t || K8sPermissionService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.K8sApiResourceService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: K8sPermissionService, factory: K8sPermissionService.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(K8sPermissionService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], function () { return [{ type: i1.HttpClient }, { type: i2.K8sApiResourceService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"k8s-permission.service.js","sourceRoot":"","sources":["../../../../../libs/common/src/permission/k8s-permission.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @packageDocumentation\n * @module permission\n */\n\nimport { HttpClient } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { Observable, forkJoin, of, map, switchMap } from 'rxjs';\n\nimport { K8sApiResourceService, getApiPrefixParts } from '../api/public-api';\nimport {\n  IfEqual,\n  K8sResourceAction,\n  KubernetesResource,\n  SelfSubjectAccessReview,\n} from '../core';\nimport { API_GATEWAY, ifExist, publishRef } from '../core/public-api';\n\nimport { isAllowed } from './helpers';\nimport {\n  AllPermissions,\n  K8sPermissionTransformable,\n  K8sResourcePermissionMultiParams,\n  K8sResourcePermissionNoneParams,\n  K8sResourcePermissionParams,\n  K8sResourcePermissionSingleParams,\n  K8sResourcePermissionWithTransformParams,\n  K8sTypePermissionActionsParams,\n  K8sTypePermissionMatrixParams,\n  K8sTypePermissionMultiParams,\n  K8sTypePermissionNamesParams,\n  K8sTypePermissionNoneParams,\n  K8sTypePermissionParams,\n  K8sTypePermissionSingleParams,\n  K8sTypePermissionWithTransformParams,\n} from './types';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class K8sPermissionService {\n  constructor(\n    private readonly http: HttpClient,\n    private readonly k8sApiResource: K8sApiResourceService,\n  ) {\n    this.getAccess = this.getAccess.bind(this);\n    this.isAllowed = this.isAllowed.bind(this);\n  }\n\n  /**\n   * 获取对 K8s 资源的操作权限，一般和 isAllowed 配合使用\n   */\n\n  /**\n   * 根据已有 K8s 资源，不传入 action 或为 null 时默认取 get 操作权限\n   */\n  getAccess<\n    K extends KubernetesResource,\n    T extends K8sResourceAction = K8sResourceAction.GET,\n  >(\n    params: K8sResourcePermissionNoneParams<K>,\n  ): Observable<SelfSubjectAccessReview<T>>;\n\n  /**\n   * 根据已有 K8s 资源，进行单个指定 action 操作权限\n   */\n  getAccess<T extends K8sResourceAction, K extends KubernetesResource>(\n    params: K8sResourcePermissionSingleParams<K, T>,\n  ): Observable<SelfSubjectAccessReview<T>>;\n\n  /**\n   * 根据已有 K8s 资源，进行多个指定 action 操作权限列表\n   */\n  getAccess<T extends K8sResourceAction, K extends KubernetesResource>(\n    params: K8sResourcePermissionMultiParams<K, T>,\n  ): Observable<Array<SelfSubjectAccessReview<T>>>;\n\n  /**\n   * 根据 K8s 资源类型，不传入 action 或为 null 时默认取 list 操作权限\n   */\n  getAccess(\n    params: K8sTypePermissionNoneParams,\n  ): Observable<SelfSubjectAccessReview<K8sResourceAction.LIST>>;\n\n  /**\n   * 根据 K8s 资源类型和名称进行单个指定 action 操作权限，默认取 get 操作权限\n   */\n  getAccess<T extends K8sResourceAction = K8sResourceAction.GET>(\n    params: K8sTypePermissionSingleParams<T>,\n  ): Observable<SelfSubjectAccessReview<T>>;\n\n  /**\n   * 根据 K8s 资源类型，进行多个指定 action 操作或者多个名称的权限列表\n   */\n  getAccess<T extends K8sResourceAction>(\n    params: K8sTypePermissionMultiParams<T>,\n  ): Observable<Array<SelfSubjectAccessReview<T>>>;\n\n  /**\n   * 根据 K8s 资源类型，进行多个指定 action 操作和多个名称的权限二位数组列表\n   */\n  getAccess<T extends K8sResourceAction>(\n    params: K8sTypePermissionMatrixParams<T>,\n  ): Observable<Array<Array<SelfSubjectAccessReview<T>>>>;\n\n  getAccess<T extends K8sResourceAction, K extends KubernetesResource>(\n    typeOrResourceParams:\n      | K8sTypePermissionParams<T>\n      | K8sResourcePermissionParams<K, T>,\n  ) {\n    let params: K8sTypePermissionParams<T>;\n    let group: string;\n    let type$: Observable<string>;\n    if ('resource' in typeOrResourceParams) {\n      const {\n        advanced: resourceAdvanced,\n        project: resourceProject,\n        cluster: resourceCluster,\n        resource,\n        action,\n      } = typeOrResourceParams;\n      params = {\n        advanced: resourceAdvanced,\n        project: resourceProject,\n        cluster: resourceCluster,\n        namespace: resource.metadata.namespace,\n        name: resource.metadata.name,\n        action,\n      } as K8sTypePermissionParams<T>;\n      group = getApiPrefixParts(resource.apiVersion).apiGroup;\n      type$ = this.k8sApiResource.getResourceType(resource, resourceCluster);\n    } else {\n      params = typeOrResourceParams;\n      const { apiGroup, type } = this.k8sApiResource.getDefinition(params.type);\n      group = apiGroup;\n      type$ = of(type);\n    }\n    const { advanced, project, cluster, namespace, name, action, subResource } =\n      params;\n    const isNameArray = Array.isArray(name);\n    const isActionArray = Array.isArray(action);\n    const isArray = isNameArray && isActionArray;\n    const names = (isNameArray ? name : [name]) as string[];\n    const actions = (isActionArray ? action : [action]) as T[];\n    return type$.pipe(\n      switchMap(type =>\n        forkJoin(\n          names.map(name =>\n            of(actions).pipe(\n              switchMap(actionList =>\n                forkJoin(\n                  actionList.map(action =>\n                    this._getAccess<T>({\n                      action,\n                      project,\n                      cluster,\n                      group,\n                      name,\n                      namespace,\n                      type,\n                      advanced,\n                      subResource,\n                    }),\n                  ),\n                ),\n              ),\n            ),\n          ),\n        ),\n      ),\n      map(accesses =>\n        isArray\n          ? accesses\n          : isActionArray\n          ? accesses[0]\n          : isNameArray\n          ? accesses.map(accessGroup => accessGroup[0])\n          : accesses[0][0],\n      ),\n      publishRef(),\n    );\n  }\n\n  /**\n   * 根据已经获取到的操作权限对象或列表转化为更方便使用的权限 record 或数组\n   */\n\n  /**\n   * 根据已有 K8s 资源，不传入 action 或为 null 时转化为 boolean\n   */\n  isAllowed<T extends K8sResourceAction, K extends KubernetesResource>(\n    params:\n      | K8sResourcePermissionNoneParams<K>\n      | K8sResourcePermissionSingleParams<K, T>,\n  ): Observable<boolean>;\n\n  /**\n   * 根据已有 K8s 资源，多个 action 默认转为 record，`transform === false` 时转为 `boolean[]`\n   */\n  isAllowed<\n    T extends K8sResourceAction,\n    K extends KubernetesResource,\n    R extends boolean = true,\n  >(\n    params: K8sResourcePermissionMultiParams<K, T> &\n      Partial<K8sPermissionTransformable<R>>,\n  ): Observable<IfEqual<R, false, boolean[], Record<T, boolean>>>;\n\n  /**\n   * 根据 K8s 资源类型，不传入 action/name 或为 null 时，默认取 get 权限，自动转化为 boolean，`transform !== false` 时转化为 record\n   */\n  isAllowed<\n    T extends K8sResourceAction = K8sResourceAction.GET,\n    K extends boolean = false,\n  >(\n    params: K8sTypePermissionNoneParams &\n      Partial<K8sPermissionTransformable<K>>,\n  ): Observable<IfEqual<K, false, boolean, Record<T, boolean>>>;\n\n  /**\n   * 根据 K8s 资源类型，传入单个 action 或 name 时，`action === ALL(*)` 时自动转化为所有权限的 record，否则转化为 `boolean`\n   */\n  isAllowed<T extends K8sResourceAction>(\n    params: K8sTypePermissionSingleParams<T>,\n  ): Observable<IfEqual<T, K8sResourceAction.ALL, AllPermissions, boolean>>;\n\n  /**\n   * 根据 K8s 资源类型，传入单个 action 或 name 时，自动转化为 record，`transform === false` 时转化为 `boolean`\n   */\n  isAllowed<T extends K8sResourceAction, K extends boolean>(\n    params: K8sTypePermissionSingleParams<T> & K8sPermissionTransformable<K>,\n  ): Observable<\n    IfEqual<\n      K,\n      false,\n      boolean,\n      IfEqual<T, K8sResourceAction.ALL, AllPermissions, Record<T, boolean>>\n    >\n  >;\n\n  /**\n   * 根据 K8s 资源类型，传入多个 action 时，自动转化为 record，`transform === false` 时转化为 `boolean[]`\n   */\n  isAllowed<T extends K8sResourceAction, K extends boolean = true>(\n    params: K8sTypePermissionActionsParams<T> &\n      Partial<K8sPermissionTransformable<K>>,\n  ): Observable<IfEqual<K, false, boolean[], Record<T, boolean>>>;\n\n  /**\n   * 根据 K8s 资源类型，传入多个 name 时，自动转化为 `boolean[]`\n   */\n  isAllowed<T extends K8sResourceAction>(\n    params: K8sTypePermissionNamesParams<T>,\n  ): Observable<boolean[]>;\n\n  isAllowed<\n    T extends K8sResourceAction,\n    K extends KubernetesResource,\n    R extends boolean = true,\n  >(\n    typeOrResourceParams:\n      | K8sTypePermissionWithTransformParams<T, R>\n      | K8sResourcePermissionWithTransformParams<K, T, R>,\n  ): Observable<any> {\n    if (\n      ('name' in typeOrResourceParams &&\n        Array.isArray(typeOrResourceParams.name)) ||\n      (typeOrResourceParams.action !== K8sResourceAction.ALL &&\n        !Array.isArray(typeOrResourceParams.action) &&\n        typeOrResourceParams.transform == null)\n    ) {\n      typeOrResourceParams.transform = false as R;\n    }\n    // @ts-expect-error\n    return this.getAccess(typeOrResourceParams).pipe(\n      isAllowed(typeOrResourceParams.transform),\n    );\n  }\n\n  // @internal\n  private _getAccess<T extends K8sResourceAction>({\n    action,\n    project,\n    cluster,\n    group,\n    name,\n    namespace,\n    type,\n    advanced,\n    subResource,\n  }: {\n    action: T;\n    project?: string;\n    cluster?: string;\n    group?: string;\n    name?: string;\n    namespace?: string;\n    type?: string;\n    advanced?: boolean;\n    subResource?: string;\n  }) {\n    return this.http.post<SelfSubjectAccessReview<T>>(\n      `${API_GATEWAY}${\n        advanced\n          ? '/auth'\n          : `${ifExist(\n              cluster,\n\n              `/kubernetes/${cluster}`,\n            )}/apis/authorization.k8s.io`\n      }/v1/selfsubjectaccessreviews`,\n      {\n        apiVersion: 'authorization.k8s.io/v1',\n        kind: 'SelfSubjectAccessReview',\n        spec: {\n          resourceAttributes: {\n            namespace,\n            verb:\n              action || (name ? K8sResourceAction.GET : K8sResourceAction.LIST),\n            group,\n            resource: type,\n            name,\n            cluster: advanced ? cluster : undefined,\n            project: advanced ? project : undefined,\n            ...(subResource ? { subResource } : {}),\n          },\n        },\n      },\n    );\n  }\n}\n"]}

package/esm2022/permission/permission.guard.mjs

@@ -0,0 +1,108 @@
+import { Injectable } from '@angular/core';
+import { shareReplay, Subject, takeUntil, tap } from 'rxjs';
+import { K8sResourceAction, parseWorkspace, skipError, SilentlyNavigateService, } from '../core';
+import { NO_PERMISSION } from './constants';
+import { K8sPermissionService } from './k8s-permission.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./k8s-permission.service";
+import * as i2 from "../core";
+const PROJECTS_DEF = {
+    type: {
+        apiGroup: 'auth.alauda.io',
+        type: 'projects',
+    },
+};
+const NAMESPACES_DEF = {
+    type: {
+        type: 'namespaces',
+    },
+    advanced: true,
+};
+/**
+ * @see https://confluence.alauda.cn/pages/viewpage.action?pageId=115520649
+ */
+export class PermissionGuardService {
+    constructor(k8sPermission, silentlyNavigate) {
+        this.k8sPermission = k8sPermission;
+        this.silentlyNavigate = silentlyNavigate;
+        this.destroy$$ = new Subject();
+        this.cache = new WeakMap();
+    }
+    canActivate(route, state) {
+        if (this.cache.has(state)) {
+            return this.cache.get(state);
+        }
+        const params = this.getParams(route, route.data.childFirst);
+        let permissionParams;
+        const validWorkspace = parseWorkspace(params.workspace);
+        if (validWorkspace) {
+            permissionParams = {
+                ...NAMESPACES_DEF,
+                ...validWorkspace,
+            };
+        }
+        else {
+            // params.workspace acts on something like gitops application
+            const project = params.project || params.workspace?.split('~')?.[0];
+            if (project && project !== '~all') {
+                const { cluster, namespace } = params;
+                permissionParams =
+                    cluster && namespace
+                        ? {
+                            ...NAMESPACES_DEF,
+                            project,
+                            cluster,
+                            namespace,
+                        }
+                        : { ...PROJECTS_DEF, name: project };
+            }
+        }
+        if (permissionParams) {
+            const allowed$ = this.k8sPermission
+                .isAllowed({
+                action: K8sResourceAction.GET,
+                ...permissionParams,
+            })
+                .pipe(skipError(false), tap(allowed => {
+                if (!allowed) {
+                    this.silentlyNavigate.navigate(state.url, NO_PERMISSION);
+                }
+            }), takeUntil(this.destroy$$), shareReplay(1));
+            this.cache.set(state, allowed$);
+            return allowed$;
+        }
+        return true;
+    }
+    canActivateChild(route, state) {
+        return this.canActivate(route, state);
+    }
+    ngOnDestroy() {
+        this.destroy$$.next();
+        this.destroy$$.complete();
+    }
+    getParams(route, childFirst = false) {
+        let params = {
+            ...route.queryParams,
+            ...route.params,
+        };
+        if (!childFirst) {
+            return params;
+        }
+        if (route.children.length) {
+            route.children.forEach(child => {
+                params = {
+                    ...params,
+                    ...this.getParams(child, childFirst),
+                };
+            });
+        }
+        return params;
+    }
+    static { this.ɵfac = function PermissionGuardService_Factory(t) { return new (t || PermissionGuardService)(i0.ɵɵinject(i1.K8sPermissionService), i0.ɵɵinject(i2.SilentlyNavigateService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: PermissionGuardService, factory: PermissionGuardService.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PermissionGuardService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], function () { return [{ type: i1.K8sPermissionService }, { type: i2.SilentlyNavigateService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permission.guard.js","sourceRoot":"","sources":["../../../../../libs/common/src/permission/permission.guard.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy } from '@angular/core';\nimport {\n  ActivatedRouteSnapshot,\n  CanActivate,\n  CanActivateChild,\n  RouterStateSnapshot,\n} from '@angular/router';\nimport { Observable, shareReplay, Subject, takeUntil, tap } from 'rxjs';\n\nimport { K8sResourceDefinition } from '../api/types';\nimport {\n  StringMap,\n  K8sResourceAction,\n  parseWorkspace,\n  skipError,\n  Workspace,\n  SilentlyNavigateService,\n} from '../core';\n\nimport { NO_PERMISSION } from './constants';\nimport { K8sPermissionService } from './k8s-permission.service';\nimport { PermissionGuardData } from './types';\n\nconst PROJECTS_DEF = {\n  type: {\n    apiGroup: 'auth.alauda.io',\n    type: 'projects',\n  },\n} as const;\n\nconst NAMESPACES_DEF = {\n  type: {\n    type: 'namespaces',\n  },\n  advanced: true,\n} as const;\n\n/**\n * @see https://confluence.alauda.cn/pages/viewpage.action?pageId=115520649\n */\n@Injectable({ providedIn: 'root' })\nexport class PermissionGuardService\n  implements CanActivate, CanActivateChild, OnDestroy\n{\n  private readonly destroy$$ = new Subject<void>();\n\n  private readonly cache = new WeakMap<\n    RouterStateSnapshot,\n    Observable<boolean>\n  >();\n\n  constructor(\n    private readonly k8sPermission: K8sPermissionService,\n    private readonly silentlyNavigate: SilentlyNavigateService,\n  ) {}\n\n  canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) {\n    if (this.cache.has(state)) {\n      return this.cache.get(state);\n    }\n    const params = this.getParams(\n      route,\n      (route.data as PermissionGuardData).childFirst,\n    );\n\n    let permissionParams: (\n      | { name: string }\n      | (Workspace & {\n          advanced: true;\n        })\n    ) & {\n      type: K8sResourceDefinition;\n    };\n\n    const validWorkspace = parseWorkspace(params.workspace);\n\n    if (validWorkspace) {\n      permissionParams = {\n        ...NAMESPACES_DEF,\n        ...validWorkspace,\n      };\n    } else {\n      // params.workspace acts on something like gitops application\n      const project = params.project || params.workspace?.split('~')?.[0];\n\n      if (project && project !== '~all') {\n        const { cluster, namespace } = params;\n        permissionParams =\n          cluster && namespace\n            ? {\n                ...NAMESPACES_DEF,\n                project,\n                cluster,\n                namespace,\n              }\n            : { ...PROJECTS_DEF, name: project };\n      }\n    }\n\n    if (permissionParams) {\n      const allowed$ = this.k8sPermission\n        .isAllowed({\n          action: K8sResourceAction.GET,\n          ...permissionParams,\n        })\n        .pipe(\n          skipError(false),\n          tap(allowed => {\n            if (!allowed) {\n              this.silentlyNavigate.navigate(state.url, NO_PERMISSION);\n            }\n          }),\n          takeUntil(this.destroy$$),\n          shareReplay(1),\n        );\n\n      this.cache.set(state, allowed$);\n\n      return allowed$;\n    }\n\n    return true;\n  }\n\n  canActivateChild(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) {\n    return this.canActivate(route, state);\n  }\n\n  ngOnDestroy(): void {\n    this.destroy$$.next();\n    this.destroy$$.complete();\n  }\n\n  getParams(route: ActivatedRouteSnapshot, childFirst = false): StringMap {\n    let params = {\n      ...route.queryParams,\n      ...route.params,\n    };\n    if (!childFirst) {\n      return params;\n    }\n    if (route.children.length) {\n      route.children.forEach(child => {\n        params = {\n          ...params,\n          ...this.getParams(child, childFirst),\n        };\n      });\n    }\n    return params;\n  }\n}\n"]}

package/esm2022/permission/public-api.mjs

@@ -0,0 +1,13 @@
+/**
+ * [[include:permission/README.md]]
+ * @module permission
+ * @preferred
+ */
+/** imports */
+export * from './admin.guard';
+export * from './constants';
+export * from './helpers';
+export * from './k8s-permission.service';
+export * from './permission.guard';
+export * from './types';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9wZXJtaXNzaW9uL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUVILGNBQWM7QUFDZCxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFtbaW5jbHVkZTpwZXJtaXNzaW9uL1JFQURNRS5tZF1dXG4gKiBAbW9kdWxlIHBlcm1pc3Npb25cbiAqIEBwcmVmZXJyZWRcbiAqL1xuXG4vKiogaW1wb3J0cyAqL1xuZXhwb3J0ICogZnJvbSAnLi9hZG1pbi5ndWFyZCc7XG5leHBvcnQgKiBmcm9tICcuL2NvbnN0YW50cyc7XG5leHBvcnQgKiBmcm9tICcuL2hlbHBlcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9rOHMtcGVybWlzc2lvbi5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vcGVybWlzc2lvbi5ndWFyZCc7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzJztcbiJdfQ==

package/esm2022/permission/types.mjs

@@ -0,0 +1,38 @@
+/**
+ * @packageDocumentation
+ * @module permission
+ */
+import { K8sResourceAction } from '../core/types';
+export const READABLE_ACTIONS = [
+    K8sResourceAction.GET,
+    K8sResourceAction.LIST,
+    K8sResourceAction.PROXY,
+    K8sResourceAction.REDIRECT,
+    K8sResourceAction.WATCH,
+];
+export const WRITABLE_ACTIONS = [
+    K8sResourceAction.CREATE,
+    K8sResourceAction.DELETE,
+    K8sResourceAction.DELETE_COLLECTION,
+    K8sResourceAction.PATCH,
+    K8sResourceAction.UPDATE,
+];
+export const COMMON_READABLE_ACTIONS = [K8sResourceAction.GET];
+export const COMMON_WRITABLE_ACTIONS = [
+    K8sResourceAction.CREATE,
+    K8sResourceAction.DELETE,
+    K8sResourceAction.UPDATE,
+];
+export const ALL_ACTIONS = [
+    K8sResourceAction.CREATE,
+    K8sResourceAction.DELETE,
+    K8sResourceAction.DELETE_COLLECTION,
+    K8sResourceAction.GET,
+    K8sResourceAction.LIST,
+    K8sResourceAction.PATCH,
+    K8sResourceAction.PROXY,
+    K8sResourceAction.REDIRECT,
+    K8sResourceAction.UPDATE,
+    K8sResourceAction.WATCH,
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/pie-derivative-chart/donut-status/component.mjs

@@ -0,0 +1,195 @@
+import { __decorate, __metadata } from "tslib";
+import { rgbColor } from '@alauda/ui';
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, } from '@angular/core';
+import { combineLatest, Observable, map } from 'rxjs';
+import { ObservableInput } from '../../core/public-api';
+import * as i0 from "@angular/core";
+function DonutStatusChartComponent_ng_template_6_span_8_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "span", 10);
+    i0.ɵɵtext(1);
+    i0.ɵɵpipe(2, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r3 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(2, 1, ctx_r3.unit || "unit_ge"));
+} }
+const _c0 = function (a0) { return { "font-size": a0 }; };
+function DonutStatusChartComponent_ng_template_6_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 5)(1, "div", 6)(2, "span", 7);
+    i0.ɵɵtext(3);
+    i0.ɵɵpipe(4, "aclFieldNotAvailable");
+    i0.ɵɵpipe(5, "number");
+    i0.ɵɵpipe(6, "async");
+    i0.ɵɵpipe(7, "async");
+    i0.ɵɵelementEnd();
+    i0.ɵɵtemplate(8, DonutStatusChartComponent_ng_template_6_span_8_Template, 3, 3, "span", 8);
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(9, "div", 9);
+    i0.ɵɵtext(10);
+    i0.ɵɵpipe(11, "translate");
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("ngStyle", i0.ɵɵpureFunction1(15, _c0, ctx_r1.customTextSize ? ctx_r1.customTextSize : "38px"));
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate(ctx_r1.customText ? ctx_r1.customText : i0.ɵɵpipeBind1(4, 4, ctx_r1.decimal ? i0.ɵɵpipeBind2(5, 6, i0.ɵɵpipeBind1(6, 9, ctx_r1.total$), "1.2-2") : i0.ɵɵpipeBind1(7, 11, ctx_r1.total$)));
+    i0.ɵɵadvance(5);
+    i0.ɵɵproperty("ngIf", !ctx_r1.hideUnit);
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(11, 13, ctx_r1.guideLabel || "total_num"), " ");
+} }
+const _c1 = function (a0) { return { backgroundColor: a0 }; };
+function DonutStatusChartComponent_ul_8_li_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "li");
+    i0.ɵɵelement(1, "i", 13);
+    i0.ɵɵpipe(2, "pure");
+    i0.ɵɵelementStart(3, "div", 14);
+    i0.ɵɵpipe(4, "translate");
+    i0.ɵɵelementStart(5, "label");
+    i0.ɵɵtext(6);
+    i0.ɵɵpipe(7, "translate");
+    i0.ɵɵelementEnd()();
+    i0.ɵɵelementStart(8, "span");
+    i0.ɵɵtext(9);
+    i0.ɵɵpipe(10, "aclFieldNotAvailable");
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    const item_r5 = ctx.$implicit;
+    const ctx_r4 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngStyle", i0.ɵɵpureFunction1(13, _c1, i0.ɵɵpipeBind2(2, 4, item_r5, ctx_r4.color)));
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("title", i0.ɵɵpipeBind1(4, 7, item_r5.name));
+    i0.ɵɵadvance(3);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(7, 9, item_r5.name));
+    i0.ɵɵadvance(3);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(10, 11, item_r5.value));
+} }
+function DonutStatusChartComponent_ul_8_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "ul", 11);
+    i0.ɵɵtemplate(1, DonutStatusChartComponent_ul_8_li_1_Template, 11, 15, "li", 12);
+    i0.ɵɵpipe(2, "async");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngForOf", i0.ɵɵpipeBind1(2, 1, ctx_r2.data$));
+} }
+const EMPTY_COLOR = rgbColor('n-6');
+export const CHART_COLORS = {
+    running: rgbColor('green'),
+    partial_running: rgbColor('yellow'),
+    pending: rgbColor('blue'),
+    failed: rgbColor('red'),
+    fail_or_abnormal: rgbColor('red'),
+    stopped: rgbColor('n-4'),
+    empty: rgbColor('n-6'),
+    error: rgbColor('red'),
+    no_workload: EMPTY_COLOR,
+    nil: 'rgba(242, 242, 242, 0.85)',
+    completed: '#1ba4b3',
+    done: '#1ba4b3',
+};
+export class DonutStatusChartComponent {
+    constructor() {
+        this.layout = 'row';
+        this.size = 145;
+        this.hideLegend = false;
+        this.decimal = false;
+        this.width = 10;
+        this.tooltipHideTitle = true;
+        this.tooltipTranslation = true;
+        this.refresh = new EventEmitter();
+        this.status$ = combineLatest([this.loading$, this.failed$]).pipe(map(([loading, failed]) => ({ loading, failed })));
+        this.pieData$ = this.data$.pipe(map(data => data?.map(d => ({
+            ...d,
+            color: d.color ||
+                CHART_COLORS[(d.type || d.name)],
+        }))));
+        this.total$ = this.data$.pipe(map(data => data?.reduce((sum, { value }) => sum + value, 0)));
+        this.CHART_COLORS = CHART_COLORS;
+    }
+    get layoutColumn() {
+        return this.layout === 'column';
+    }
+    color(item) {
+        return (item.color ||
+            CHART_COLORS[(item.type || item.name)]);
+    }
+    static { this.ɵfac = function DonutStatusChartComponent_Factory(t) { return new (t || DonutStatusChartComponent)(); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: DonutStatusChartComponent, selectors: [["acl-donut-status-chart"]], inputs: { data: "data", loading: "loading", failed: "failed", pieLabelText: "pieLabelText", layout: "layout", size: "size", customText: "customText", customTextSize: "customTextSize", unit: "unit", hideUnit: "hideUnit", hideLegend: "hideLegend", decimal: "decimal", width: "width", guideLabel: "guideLabel", tooltipTrigger: "tooltipTrigger", tooltipHideTitle: "tooltipHideTitle", tooltipTranslation: "tooltipTranslation", tooltipPointFormat: "tooltipPointFormat" }, outputs: { refresh: "refresh" }, decls: 9, vars: 19, consts: [[1, "donut"], [1, "donut_pie"], ["chartType", "pie", 3, "chartStatus", "series", "pieLabelText", "hideHeader", "pieOuterRadius", "pieInnerDisc", "tooltipTrigger", "tooltipHideTitle", "tooltipTranslation", "tooltipPointFormat", "refreshEvent"], ["totalTemplate", ""], ["class", "labels", 4, "ngIf"], [1, "guide"], [1, "guide_value"], [1, "guide_value_text", 3, "ngStyle"], ["class", "guide_unit", 4, "ngIf"], [1, "guide_label"], [1, "guide_unit"], [1, "labels"], [4, "ngFor", "ngForOf"], [3, "ngStyle"], [1, "label", 3, "title"]], template: function DonutStatusChartComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "div", 0)(1, "div", 1)(2, "acl-view-chart", 2);
+            i0.ɵɵlistener("refreshEvent", function DonutStatusChartComponent_Template_acl_view_chart_refreshEvent_2_listener() { return ctx.refresh.next(null); });
+            i0.ɵɵpipe(3, "async");
+            i0.ɵɵpipe(4, "async");
+            i0.ɵɵpipe(5, "async");
+            i0.ɵɵelementEnd()();
+            i0.ɵɵtemplate(6, DonutStatusChartComponent_ng_template_6_Template, 12, 17, "ng-template", null, 3, i0.ɵɵtemplateRefExtractor);
+            i0.ɵɵtemplate(8, DonutStatusChartComponent_ul_8_Template, 3, 3, "ul", 4);
+            i0.ɵɵelementEnd();
+        } if (rf & 2) {
+            const _r0 = i0.ɵɵreference(7);
+            i0.ɵɵclassProp("donut_column", ctx.layoutColumn);
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("chartStatus", i0.ɵɵpipeBind1(3, 13, ctx.status$))("series", i0.ɵɵpipeBind1(4, 15, ctx.pieData$))("pieLabelText", i0.ɵɵpipeBind1(5, 17, ctx.status$).loading ? "" : ctx.pieLabelText || _r0)("hideHeader", true)("pieOuterRadius", ctx.size / 2 - 10)("pieInnerDisc", true)("tooltipTrigger", ctx.tooltipTrigger)("tooltipHideTitle", ctx.tooltipHideTitle)("tooltipTranslation", ctx.tooltipTranslation)("tooltipPointFormat", ctx.tooltipPointFormat);
+            i0.ɵɵadvance(6);
+            i0.ɵɵproperty("ngIf", !ctx.hideLegend);
+        } }, styles: [".donut[_ngcontent-%COMP%]{display:flex;align-items:center;justify-content:space-evenly;flex-direction:row;width:100%;height:100%}.donut_pie[_ngcontent-%COMP%]{flex:1;height:100%;min-width:135px}.donut_column[_ngcontent-%COMP%]{flex-direction:column}.donut_column[_ngcontent-%COMP%]   .labels[_ngcontent-%COMP%]{flex-flow:row wrap;margin-top:45px}.donut_column[_ngcontent-%COMP%]   .labels[_ngcontent-%COMP%]   li[_ngcontent-%COMP%]{flex:0 0 25%}.donut_column[_ngcontent-%COMP%]   .labels[_ngcontent-%COMP%]   li[_ngcontent-%COMP%]:nth-child(odd){margin-right:65px}.labels[_ngcontent-%COMP%]{width:40%;max-width:180px;display:flex;flex:1;flex-direction:column;justify-content:center;padding-left:20px;font-size:12px;color:rgb(var(--aui-color-secondary-text));word-break:keep-all}.labels[_ngcontent-%COMP%]   li[_ngcontent-%COMP%]{margin:2px 0;display:flex;align-items:center}.labels[_ngcontent-%COMP%]   .label[_ngcontent-%COMP%]{flex:1;margin-right:20px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.labels[_ngcontent-%COMP%]   i[_ngcontent-%COMP%]{display:inline-flex;width:6px;height:6px;border-radius:50%;margin-right:4px}.guide[_ngcontent-%COMP%]{display:flex;flex-direction:column;align-items:center}.guide_value[_ngcontent-%COMP%]{color:rgb(var(--aui-color-n-1));display:flex;align-items:flex-end}.guide_value_text[_ngcontent-%COMP%]{text-align:center;line-height:40px}.guide_unit[_ngcontent-%COMP%]{font-size:14px}.guide_label[_ngcontent-%COMP%]{font-size:14px;color:rgb(var(--aui-color-n-2))}.center-text__main[_ngcontent-%COMP%]{font-size:48px;font-weight:500;fill:rgb(var(--aui-color-main-text))}.center-text__sub[_ngcontent-%COMP%]{font-size:14px;fill:rgb(var(--aui-color-secondary-text))}"], changeDetection: 0 }); }
+}
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], DonutStatusChartComponent.prototype, "data$", void 0);
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], DonutStatusChartComponent.prototype, "loading$", void 0);
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], DonutStatusChartComponent.prototype, "failed$", void 0);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DonutStatusChartComponent, [{
+        type: Component,
+        args: [{ selector: 'acl-donut-status-chart', preserveWhitespaces: false, changeDetection: ChangeDetectionStrategy.OnPush, template: "<div\n  class=\"donut\"\n  [class.donut_column]=\"layoutColumn\"\n>\n  <div class=\"donut_pie\">\n    <acl-view-chart\n      chartType=\"pie\"\n      [chartStatus]=\"status$ | async\"\n      [series]=\"pieData$ | async\"\n      [pieLabelText]=\"\n        (status$ | async).loading ? '' : pieLabelText || totalTemplate\n      \"\n      [hideHeader]=\"true\"\n      [pieOuterRadius]=\"size / 2 - 10\"\n      [pieInnerDisc]=\"true\"\n      [tooltipTrigger]=\"tooltipTrigger\"\n      [tooltipHideTitle]=\"tooltipHideTitle\"\n      [tooltipTranslation]=\"tooltipTranslation\"\n      [tooltipPointFormat]=\"tooltipPointFormat\"\n      (refreshEvent)=\"refresh.next(null)\"\n    >\n    </acl-view-chart>\n  </div>\n\n  <ng-template #totalTemplate>\n    <div class=\"guide\">\n      <div class=\"guide_value\">\n        <span\n          [ngStyle]=\"{ 'font-size': customTextSize ? customTextSize : '38px' }\"\n          class=\"guide_value_text\"\n          >{{\n            customText\n              ? customText\n              : ((decimal\n                  ? (total$ | async | number: '1.2-2')\n                  : (total$ | async)\n                ) | aclFieldNotAvailable)\n          }}</span\n        >\n        <span\n          *ngIf=\"!hideUnit\"\n          class=\"guide_unit\"\n          >{{ unit || 'unit_ge' | translate }}</span\n        >\n      </div>\n      <div class=\"guide_label\">\n        {{ guideLabel || 'total_num' | translate }}\n      </div>\n    </div>\n  </ng-template>\n\n  <ul\n    *ngIf=\"!hideLegend\"\n    class=\"labels\"\n  >\n    <li *ngFor=\"let item of data$ | async\">\n      <i [ngStyle]=\"{ backgroundColor: item | pure: color }\"></i>\n      <div\n        class=\"label\"\n        [title]=\"item.name | translate\"\n      >\n        <label>{{ item.name | translate }}</label>\n      </div>\n      <span>{{ item.value | aclFieldNotAvailable }}</span>\n    </li>\n  </ul>\n</div>\n", styles: [".donut{display:flex;align-items:center;justify-content:space-evenly;flex-direction:row;width:100%;height:100%}.donut_pie{flex:1;height:100%;min-width:135px}.donut_column{flex-direction:column}.donut_column .labels{flex-flow:row wrap;margin-top:45px}.donut_column .labels li{flex:0 0 25%}.donut_column .labels li:nth-child(odd){margin-right:65px}.labels{width:40%;max-width:180px;display:flex;flex:1;flex-direction:column;justify-content:center;padding-left:20px;font-size:12px;color:rgb(var(--aui-color-secondary-text));word-break:keep-all}.labels li{margin:2px 0;display:flex;align-items:center}.labels .label{flex:1;margin-right:20px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.labels i{display:inline-flex;width:6px;height:6px;border-radius:50%;margin-right:4px}.guide{display:flex;flex-direction:column;align-items:center}.guide_value{color:rgb(var(--aui-color-n-1));display:flex;align-items:flex-end}.guide_value_text{text-align:center;line-height:40px}.guide_unit{font-size:14px}.guide_label{font-size:14px;color:rgb(var(--aui-color-n-2))}.center-text__main{font-size:48px;font-weight:500;fill:rgb(var(--aui-color-main-text))}.center-text__sub{font-size:14px;fill:rgb(var(--aui-color-secondary-text))}\n"] }]
+    }], null, { data: [{
+            type: Input
+        }], data$: [], loading: [{
+            type: Input
+        }], loading$: [], failed: [{
+            type: Input
+        }], pieLabelText: [{
+            type: Input
+        }], failed$: [], layout: [{
+            type: Input
+        }], size: [{
+            type: Input
+        }], customText: [{
+            type: Input
+        }], customTextSize: [{
+            type: Input
+        }], unit: [{
+            type: Input
+        }], hideUnit: [{
+            type: Input
+        }], hideLegend: [{
+            type: Input
+        }], decimal: [{
+            type: Input
+        }], width: [{
+            type: Input
+        }], guideLabel: [{
+            type: Input
+        }], tooltipTrigger: [{
+            type: Input
+        }], tooltipHideTitle: [{
+            type: Input
+        }], tooltipTranslation: [{
+            type: Input
+        }], tooltipPointFormat: [{
+            type: Input
+        }], refresh: [{
+            type: Output
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component.js","sourceRoot":"","sources":["../../../../../../libs/common/src/pie-derivative-chart/donut-status/component.ts","../../../../../../libs/common/src/pie-derivative-chart/donut-status/template.html"],"names":[],"mappings":"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","sourcesContent":["import { rgbColor } from '@alauda/ui';\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  EventEmitter,\n  Input,\n  Output,\n  TemplateRef,\n} from '@angular/core';\nimport { combineLatest, Observable, map } from 'rxjs';\n\nimport { ContextItem } from '../../chart/common';\nimport { ObservableInput } from '../../core/public-api';\n\nconst EMPTY_COLOR = rgbColor('n-6');\nexport const CHART_COLORS = {\n  running: rgbColor('green'),\n  partial_running: rgbColor('yellow'),\n  pending: rgbColor('blue'),\n  failed: rgbColor('red'),\n  fail_or_abnormal: rgbColor('red'),\n  stopped: rgbColor('n-4'),\n  empty: rgbColor('n-6'),\n  error: rgbColor('red'),\n  no_workload: EMPTY_COLOR,\n  nil: 'rgba(242, 242, 242, 0.85)',\n  completed: '#1ba4b3',\n  done: '#1ba4b3',\n};\n\nexport interface DonutStatusItem {\n  name: string;\n  value: number;\n  color?: string;\n  type?: string;\n  index?: number;\n}\n\n@Component({\n  selector: 'acl-donut-status-chart',\n  templateUrl: 'template.html',\n  styleUrls: ['styles.scss'],\n  preserveWhitespaces: false,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class DonutStatusChartComponent {\n  @Input()\n  data: DonutStatusItem[];\n\n  @ObservableInput()\n  data$!: Observable<DonutStatusItem[]>;\n\n  @Input()\n  loading: boolean;\n\n  @ObservableInput()\n  loading$!: Observable<boolean>;\n\n  @Input() failed: boolean;\n\n  @Input() pieLabelText: string | TemplateRef<unknown>;\n\n  @ObservableInput()\n  failed$!: Observable<boolean>;\n\n  @Input() layout: 'row' | 'column' = 'row';\n\n  @Input()\n  size = 145;\n\n  @Input()\n  customText: string;\n\n  @Input()\n  customTextSize: string;\n\n  @Input()\n  unit: string;\n\n  @Input()\n  hideUnit: boolean;\n\n  @Input()\n  hideLegend = false;\n\n  @Input()\n  decimal = false;\n\n  @Input()\n  width = 10;\n\n  @Input() guideLabel: string;\n\n  @Input() tooltipTrigger: 'axis' | 'item' | 'none';\n\n  @Input() tooltipHideTitle = true;\n\n  @Input() tooltipTranslation = true;\n\n  @Input() tooltipPointFormat: (d: ContextItem) => number | string;\n\n  @Output() refresh = new EventEmitter();\n\n  get layoutColumn() {\n    return this.layout === 'column';\n  }\n\n  status$ = combineLatest([this.loading$, this.failed$]).pipe(\n    map(([loading, failed]) => ({ loading, failed })),\n  );\n\n  pieData$ = this.data$.pipe(\n    map(data =>\n      data?.map(d => ({\n        ...d,\n        color:\n          d.color ||\n          CHART_COLORS[(d.type || d.name) as keyof typeof CHART_COLORS],\n      })),\n    ),\n  );\n\n  total$ = this.data$.pipe(\n    map(data => data?.reduce((sum, { value }) => sum + value, 0)),\n  );\n\n  CHART_COLORS = CHART_COLORS;\n\n  color(item: DonutStatusItem) {\n    return (\n      item.color ||\n      CHART_COLORS[(item.type || item.name) as keyof typeof CHART_COLORS]\n    );\n  }\n}\n","<div\n  class=\"donut\"\n  [class.donut_column]=\"layoutColumn\"\n>\n  <div class=\"donut_pie\">\n    <acl-view-chart\n      chartType=\"pie\"\n      [chartStatus]=\"status$ | async\"\n      [series]=\"pieData$ | async\"\n      [pieLabelText]=\"\n        (status$ | async).loading ? '' : pieLabelText || totalTemplate\n      \"\n      [hideHeader]=\"true\"\n      [pieOuterRadius]=\"size / 2 - 10\"\n      [pieInnerDisc]=\"true\"\n      [tooltipTrigger]=\"tooltipTrigger\"\n      [tooltipHideTitle]=\"tooltipHideTitle\"\n      [tooltipTranslation]=\"tooltipTranslation\"\n      [tooltipPointFormat]=\"tooltipPointFormat\"\n      (refreshEvent)=\"refresh.next(null)\"\n    >\n    </acl-view-chart>\n  </div>\n\n  <ng-template #totalTemplate>\n    <div class=\"guide\">\n      <div class=\"guide_value\">\n        <span\n          [ngStyle]=\"{ 'font-size': customTextSize ? customTextSize : '38px' }\"\n          class=\"guide_value_text\"\n          >{{\n            customText\n              ? customText\n              : ((decimal\n                  ? (total$ | async | number: '1.2-2')\n                  : (total$ | async)\n                ) | aclFieldNotAvailable)\n          }}</span\n        >\n        <span\n          *ngIf=\"!hideUnit\"\n          class=\"guide_unit\"\n          >{{ unit || 'unit_ge' | translate }}</span\n        >\n      </div>\n      <div class=\"guide_label\">\n        {{ guideLabel || 'total_num' | translate }}\n      </div>\n    </div>\n  </ng-template>\n\n  <ul\n    *ngIf=\"!hideLegend\"\n    class=\"labels\"\n  >\n    <li *ngFor=\"let item of data$ | async\">\n      <i [ngStyle]=\"{ backgroundColor: item | pure: color }\"></i>\n      <div\n        class=\"label\"\n        [title]=\"item.name | translate\"\n      >\n        <label>{{ item.name | translate }}</label>\n      </div>\n      <span>{{ item.value | aclFieldNotAvailable }}</span>\n    </li>\n  </ul>\n</div>\n"]}

package/esm2022/pie-derivative-chart/indicator-color.directive.mjs

@@ -0,0 +1,30 @@
+import { Directive, ElementRef, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class IndicatorColorDirective {
+    constructor(el) {
+        this.el = el;
+    }
+    ngOnInit() {
+        if (+this.indicator <= 70) {
+            return;
+        }
+        if (this.el.nativeElement.nodeName === 'text') {
+            this.el.nativeElement.style.fill =
+                +this.indicator >= 90 ? '#e54545' : '#ff9d00';
+            return;
+        }
+        this.el.nativeElement.style.color =
+            +this.indicator >= 90 ? '#e54545' : '#ff9d00';
+    }
+    static { this.ɵfac = function IndicatorColorDirective_Factory(t) { return new (t || IndicatorColorDirective)(i0.ɵɵdirectiveInject(i0.ElementRef)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: IndicatorColorDirective, selectors: [["", "aclIndicatorColor", ""]], inputs: { indicator: "indicator" } }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IndicatorColorDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[aclIndicatorColor]',
+            }]
+    }], function () { return [{ type: i0.ElementRef }]; }, { indicator: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/pie-derivative-chart/numerical-limit.pipe.mjs

@@ -0,0 +1,26 @@
+import { Pipe } from '@angular/core';
+import { isNumber } from 'lodash-es';
+import * as i0 from "@angular/core";
+const MAX_VALUE = 999999;
+const DECIMAL_MAX_VALUE = 999.99;
+export class NumericalLimitPipe {
+    transform(value) {
+        if ((!value && !isNumber(value)) || isNaN(value)) {
+            return null;
+        }
+        return value > MAX_VALUE
+            ? '>999999'
+            : value > DECIMAL_MAX_VALUE
+                ? '' + Math.round(value)
+                : '' + value?.toFixed(2);
+    }
+    static { this.ɵfac = function NumericalLimitPipe_Factory(t) { return new (t || NumericalLimitPipe)(); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "aclNumericalLimit", type: NumericalLimitPipe, pure: true }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(NumericalLimitPipe, [{
+        type: Pipe,
+        args: [{
+                name: 'aclNumericalLimit',
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVtZXJpY2FsLWxpbWl0LnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2NvbW1vbi9zcmMvcGllLWRlcml2YXRpdmUtY2hhcnQvbnVtZXJpY2FsLWxpbWl0LnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUM7QUFDcEQsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLFdBQVcsQ0FBQzs7QUFFckMsTUFBTSxTQUFTLEdBQUcsTUFBTyxDQUFDO0FBQzFCLE1BQU0saUJBQWlCLEdBQUcsTUFBTSxDQUFDO0FBSWpDLE1BQU0sT0FBTyxrQkFBa0I7SUFDN0IsU0FBUyxDQUFDLEtBQWE7UUFDckIsSUFBSSxDQUFDLENBQUMsS0FBSyxJQUFJLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBQyxDQUFDLElBQUksS0FBSyxDQUFDLEtBQUssQ0FBQyxFQUFFO1lBQ2hELE9BQU8sSUFBSSxDQUFDO1NBQ2I7UUFDRCxPQUFPLEtBQUssR0FBRyxTQUFTO1lBQ3RCLENBQUMsQ0FBQyxTQUFTO1lBQ1gsQ0FBQyxDQUFDLEtBQUssR0FBRyxpQkFBaUI7Z0JBQzNCLENBQUMsQ0FBQyxFQUFFLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUM7Z0JBQ3hCLENBQUMsQ0FBQyxFQUFFLEdBQUcsS0FBSyxFQUFFLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUM3QixDQUFDO21GQVZVLGtCQUFrQjsyRkFBbEIsa0JBQWtCOzt1RkFBbEIsa0JBQWtCO2NBSDlCLElBQUk7ZUFBQztnQkFDSixJQUFJLEVBQUUsbUJBQW1CO2FBQzFCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGlwZSwgUGlwZVRyYW5zZm9ybSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgaXNOdW1iZXIgfSBmcm9tICdsb2Rhc2gtZXMnO1xuXG5jb25zdCBNQVhfVkFMVUUgPSA5OTlfOTk5O1xuY29uc3QgREVDSU1BTF9NQVhfVkFMVUUgPSA5OTkuOTk7XG5AUGlwZSh7XG4gIG5hbWU6ICdhY2xOdW1lcmljYWxMaW1pdCcsXG59KVxuZXhwb3J0IGNsYXNzIE51bWVyaWNhbExpbWl0UGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuICB0cmFuc2Zvcm0odmFsdWU6IG51bWJlcik6IHN0cmluZyB7XG4gICAgaWYgKCghdmFsdWUgJiYgIWlzTnVtYmVyKHZhbHVlKSkgfHwgaXNOYU4odmFsdWUpKSB7XG4gICAgICByZXR1cm4gbnVsbDtcbiAgICB9XG4gICAgcmV0dXJuIHZhbHVlID4gTUFYX1ZBTFVFXG4gICAgICA/ICc+OTk5OTk5J1xuICAgICAgOiB2YWx1ZSA+IERFQ0lNQUxfTUFYX1ZBTFVFXG4gICAgICA/ICcnICsgTWF0aC5yb3VuZCh2YWx1ZSlcbiAgICAgIDogJycgKyB2YWx1ZT8udG9GaXhlZCgyKTtcbiAgfVxufVxuIl19