@alauda-fe/common 1.0.0-next.0

package/esm2022/core/services/k8s-util.service.mjs

@@ -0,0 +1,181 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { DialogService, MessageService } from '@alauda/ui';
+import { Injectable, Injector } from '@angular/core';
+import { get } from 'lodash-es';
+import { from, throwError, of, catchError, switchMap, tap, } from 'rxjs';
+import { K8sApiService } from '../../api/public-api';
+import { TranslateService } from '../../translate/translate.service';
+import { SPACE } from '../constants/constants';
+import { TOKEN_BASE_DOMAIN } from '../constants/tokens';
+import { ifExist, wrapText } from '../utils';
+import { catchPromise, skipError } from '../utils/operators';
+import * as i0 from "@angular/core";
+export const METADATA = 'metadata';
+export const NAMESPACE = 'namespace';
+export const NAME = 'name';
+export const CREATION_TIMESTAMP = 'creationTimestamp';
+export const ANNOTATIONS = 'annotations';
+export const LABELS = 'labels';
+export const DISPLAY_NAME = 'display-name';
+export const DESCRIPTION = 'description';
+export const CREATOR = 'creator';
+export const UPDATED__AT = 'updated-at';
+export const PROJECT = 'project';
+export const CLUSTER = 'cluster';
+export const TRANSLATION = 'translation';
+export class K8sUtilService {
+    constructor(injector) {
+        this.injector = injector;
+        this.dialog = injector.get(DialogService);
+        this.message = injector.get(MessageService);
+        this.k8sApi = injector.get(K8sApiService);
+        this.translate = injector.get(TranslateService);
+        this.baseDomain = injector.get(TOKEN_BASE_DOMAIN);
+    }
+    /**
+     * @param type - 对应资源的翻译 key
+     */
+    deleteResource(params, typeOrOptions) {
+        const { type, content } = typeof typeOrOptions === 'string'
+            ? { type: typeOrOptions, content: null }
+            : typeOrOptions;
+        return catchPromise(this.dialog.confirm({
+            title: this.translate.get('confirm_delete_resource', {
+                type: this.translate.get(type),
+                name: 'name' in params ? params.name : this.getName(params.resource),
+            }),
+            content,
+            confirmText: this.translate.get('delete'),
+            cancelText: this.translate.get('cancel'),
+            beforeConfirm: () => ('cluster' in params
+                ? this.k8sApi.deleteResource(params)
+                : this.k8sApi.deleteGlobalResource(params)).pipe(tap(() => this.message.success(this.translate.get('delete_success'))), skipError()),
+        }));
+    }
+    updateResource({ type, cluster, resource, silent, }) {
+        const put = (res) => this.k8sApi.putResource({
+            type,
+            cluster,
+            resource: res,
+            notifyOnError: !silent,
+        });
+        const get = () => this.k8sApi.getResource({
+            type,
+            cluster,
+            namespace: resource.metadata.namespace,
+            name: resource.metadata.name,
+        });
+        return this.retryUpdate(put, get, resource, silent);
+    }
+    updateGlobalResource({ type, namespaced, resource, namespace, silent, }) {
+        const put = (res) => this.k8sApi.putGlobalResource({
+            type,
+            namespaced,
+            resource: res,
+            namespace,
+            notifyOnError: !silent,
+        });
+        const get = () => this.k8sApi.getGlobalResource({
+            type,
+            namespaced,
+            name: resource.metadata.name,
+            namespace,
+        });
+        return this.retryUpdate(put, get, resource, silent);
+    }
+    normalizeType(typeOrParams, prefix) {
+        if (typeof typeOrParams === 'string') {
+            return `${ifExist(prefix, prefix + '.')}${this.baseDomain}/${typeOrParams}`;
+        }
+        return `${ifExist(typeOrParams.prefix, typeOrParams.prefix + '.')}${typeOrParams.baseDomain}/${typeOrParams.type}`;
+    }
+    getAnnotation(resource, paramsOrType, prefix) {
+        return get(resource, [
+            METADATA,
+            ANNOTATIONS,
+            this.normalizeType(paramsOrType, prefix),
+        ]);
+    }
+    getNamespace(resource) {
+        return get(resource, [METADATA, NAMESPACE]);
+    }
+    getName(resource) {
+        return get(resource, [METADATA, NAME]);
+    }
+    getCreationTimestamp(resource) {
+        return get(resource, [METADATA, CREATION_TIMESTAMP]);
+    }
+    getDisplayName(resource, prefix) {
+        return this.getAnnotation(resource, DISPLAY_NAME, prefix);
+    }
+    getUnionDisplayName(resource, namePrefix, displayNamePrefix) {
+        if (!resource) {
+            return;
+        }
+        const name = (namePrefix !== false &&
+            this.getAnnotation(resource, NAME, namePrefix)) ||
+            this.getName(resource);
+        const displayName = this.getDisplayName(resource, displayNamePrefix);
+        return name + ifExist(displayName, SPACE + wrapText(displayName));
+    }
+    getDescription(resource, prefix) {
+        return this.getAnnotation(resource, DESCRIPTION, prefix);
+    }
+    getCreator(resource, prefix) {
+        return this.getAnnotation(resource, CREATOR, prefix);
+    }
+    getUpdatedAt(resource, prefix) {
+        return this.getAnnotation(resource, UPDATED__AT, prefix);
+    }
+    getLabel(resource, paramsOrType, prefix) {
+        return get(resource, [
+            METADATA,
+            LABELS,
+            this.normalizeType(paramsOrType, prefix),
+        ]);
+    }
+    getProject(resource) {
+        return this.getLabel(resource, PROJECT);
+    }
+    retryUpdate(put, get, resource, silent) {
+        const waitUserConfirmRetry = (err) => (silent
+            ? of(null)
+            : from(this.dialog.confirm({
+                title: this.translate.get('resource_version_conflict'),
+                content: this.translate.get('confirm_retry_with_latest_version'),
+                confirmText: this.translate.get('confirm'),
+                cancelText: this.translate.get('cancel'),
+            }))).pipe(switchMap(() => get().pipe(switchMap(newResource => put({
+            ...resource,
+            metadata: {
+                ...resource.metadata,
+                resourceVersion: newResource.metadata.resourceVersion,
+            },
+        })), catchError(() => this.retryUpdate(put, get, resource, silent)))), catchError(() => throwError(() => err)));
+        return put(resource).pipe(catchError((err) => err.code === 409 ? waitUserConfirmRetry(err) : throwError(() => err)));
+    }
+    // eslint-disable-next-line sonar/function-name
+    $get(resource, type) {
+        return this.getAnnotation(resource, {
+            type,
+            baseDomain: 'cpaas.io',
+            prefix: TRANSLATION,
+        });
+    }
+    // eslint-disable-next-line sonar/function-name
+    $translate(resource, type, data) {
+        return this.translate.get(this.$get(resource, type), data);
+    }
+    static { this.ɵfac = function K8sUtilService_Factory(t) { return new (t || K8sUtilService)(i0.ɵɵinject(i0.Injector)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: K8sUtilService, factory: K8sUtilService.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(K8sUtilService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], function () { return [{ type: i0.Injector }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"k8s-util.service.js","sourceRoot":"","sources":["../../../../../../libs/common/src/core/services/k8s-util.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @packageDocumentation\n * @module utils\n */\n\nimport { DialogService, MessageService } from '@alauda/ui';\nimport { Injectable, Injector, Type } from '@angular/core';\nimport { get } from 'lodash-es';\nimport {\n  Observable,\n  from,\n  throwError,\n  of,\n  catchError,\n  switchMap,\n  tap,\n} from 'rxjs';\n\nimport { K8sApiService, ResourceDeleteParams } from '../../api/public-api';\nimport { KubernetesResource, Status } from '../../core/types';\nimport { TranslateService } from '../../translate/translate.service';\nimport { SPACE } from '../constants/constants';\nimport { TOKEN_BASE_DOMAIN } from '../constants/tokens';\nimport { ifExist, wrapText } from '../utils';\nimport { catchPromise, skipError } from '../utils/operators';\n\nexport const METADATA = 'metadata';\nexport const NAMESPACE = 'namespace';\nexport const NAME = 'name';\nexport const CREATION_TIMESTAMP = 'creationTimestamp';\nexport const ANNOTATIONS = 'annotations';\nexport const LABELS = 'labels';\nexport const DISPLAY_NAME = 'display-name';\nexport const DESCRIPTION = 'description';\nexport const CREATOR = 'creator';\nexport const UPDATED__AT = 'updated-at';\nexport const PROJECT = 'project';\nexport const CLUSTER = 'cluster';\nexport const TRANSLATION = 'translation';\n\nexport interface BaseNormalizeTypeParams {\n  type: string;\n  baseDomain: string;\n  prefix?: string;\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class K8sUtilService<R extends string = string> {\n  protected dialog: DialogService;\n  protected message: MessageService;\n  protected k8sApi: K8sApiService<R>;\n  protected translate: TranslateService;\n  protected baseDomain: string;\n\n  constructor(protected injector: Injector) {\n    this.dialog = injector.get(DialogService as Type<DialogService>);\n    this.message = injector.get(MessageService as Type<MessageService>);\n    this.k8sApi = injector.get(K8sApiService as Type<K8sApiService>);\n    this.translate = injector.get(TranslateService as Type<TranslateService>);\n    this.baseDomain = injector.get(TOKEN_BASE_DOMAIN);\n  }\n\n  /**\n   * @param type - 对应资源的翻译 key\n   */\n  deleteResource<T extends KubernetesResource>(\n    params: ResourceDeleteParams<R, T>,\n    typeOrOptions: string | { type: string; content: string },\n  ) {\n    const { type, content } =\n      typeof typeOrOptions === 'string'\n        ? { type: typeOrOptions, content: null }\n        : typeOrOptions;\n    return catchPromise(\n      this.dialog.confirm({\n        title: this.translate.get('confirm_delete_resource', {\n          type: this.translate.get(type),\n          name: 'name' in params ? params.name : this.getName(params.resource),\n        }),\n        content,\n        confirmText: this.translate.get('delete'),\n        cancelText: this.translate.get('cancel'),\n        beforeConfirm: () =>\n          ('cluster' in params\n            ? this.k8sApi.deleteResource(params)\n            : this.k8sApi.deleteGlobalResource(params)\n          ).pipe(\n            tap(() =>\n              this.message.success(this.translate.get('delete_success')),\n            ),\n            skipError(),\n          ),\n      }),\n    );\n  }\n\n  updateResource<T extends KubernetesResource>({\n    type,\n    cluster,\n    resource,\n    silent,\n  }: {\n    type: R;\n    cluster: string;\n    resource: T;\n    silent?: boolean;\n  }): Observable<T> {\n    const put = (res: T) =>\n      this.k8sApi.putResource({\n        type,\n        cluster,\n        resource: res,\n        notifyOnError: !silent,\n      });\n    const get = () =>\n      this.k8sApi.getResource<T>({\n        type,\n        cluster,\n        namespace: resource.metadata.namespace,\n        name: resource.metadata.name,\n      });\n\n    return this.retryUpdate(put, get, resource, silent);\n  }\n\n  updateGlobalResource<T extends KubernetesResource>({\n    type,\n    namespaced,\n    resource,\n    namespace,\n    silent,\n  }: {\n    type: R;\n    namespaced?: boolean;\n    resource: T;\n    namespace?: string;\n    silent?: boolean;\n  }): Observable<T> {\n    const put = (res: T) =>\n      this.k8sApi.putGlobalResource({\n        type,\n        namespaced,\n        resource: res,\n        namespace,\n        notifyOnError: !silent,\n      });\n    const get = () =>\n      this.k8sApi.getGlobalResource<T>({\n        type,\n        namespaced,\n        name: resource.metadata.name,\n        namespace,\n      });\n\n    return this.retryUpdate(put, get, resource, silent);\n  }\n\n  // reference: http://confluence.alaudatech.com/pages/viewpage.action?pageId=27166946\n  normalizeType(type: string, prefix?: string): string;\n  normalizeType(params: BaseNormalizeTypeParams): string;\n  normalizeType(\n    typeOrParams: string | BaseNormalizeTypeParams,\n    prefix?: string,\n  ): string {\n    if (typeof typeOrParams === 'string') {\n      return `${ifExist(prefix, prefix + '.')}${\n        this.baseDomain\n      }/${typeOrParams}`;\n    }\n\n    return `${ifExist(typeOrParams.prefix, typeOrParams.prefix + '.')}${\n      typeOrParams.baseDomain\n    }/${typeOrParams.type}`;\n  }\n\n  getAnnotation<T extends KubernetesResource>(\n    resource: T,\n    type: string,\n    prefix?: string,\n  ): string;\n\n  getAnnotation<T extends KubernetesResource>(\n    resource: T,\n    params: BaseNormalizeTypeParams,\n  ): string;\n\n  getAnnotation<T extends KubernetesResource>(\n    resource: T,\n    paramsOrType: string | BaseNormalizeTypeParams,\n    prefix?: string,\n  ): string {\n    return get(resource, [\n      METADATA,\n      ANNOTATIONS,\n      this.normalizeType(paramsOrType as string, prefix),\n    ]);\n  }\n\n  getNamespace<T extends KubernetesResource>(resource: T) {\n    return get(resource, [METADATA, NAMESPACE]);\n  }\n\n  getName<T extends KubernetesResource>(resource: T) {\n    return get(resource, [METADATA, NAME]);\n  }\n\n  getCreationTimestamp<T extends KubernetesResource>(resource: T) {\n    return get(resource, [METADATA, CREATION_TIMESTAMP]);\n  }\n\n  getDisplayName<T extends KubernetesResource>(resource: T, prefix?: string) {\n    return this.getAnnotation(resource, DISPLAY_NAME, prefix);\n  }\n\n  getUnionDisplayName<T extends KubernetesResource>(\n    resource: T,\n    namePrefix?: string | false,\n    displayNamePrefix?: string,\n  ) {\n    if (!resource) {\n      return;\n    }\n    const name =\n      (namePrefix !== false &&\n        this.getAnnotation(resource, NAME, namePrefix)) ||\n      this.getName(resource);\n    const displayName = this.getDisplayName(resource, displayNamePrefix);\n    return name + ifExist(displayName, SPACE + wrapText(displayName));\n  }\n\n  getDescription<T extends KubernetesResource>(resource: T, prefix?: string) {\n    return this.getAnnotation(resource, DESCRIPTION, prefix);\n  }\n\n  getCreator<T extends KubernetesResource>(resource: T, prefix?: string) {\n    return this.getAnnotation(resource, CREATOR, prefix);\n  }\n\n  getUpdatedAt<T extends KubernetesResource>(resource: T, prefix?: string) {\n    return this.getAnnotation(resource, UPDATED__AT, prefix);\n  }\n\n  getLabel<T extends KubernetesResource>(\n    resource: T,\n    type: string,\n    prefix?: string,\n  ): string;\n\n  getLabel<T extends KubernetesResource>(\n    resource: T,\n    params: BaseNormalizeTypeParams,\n  ): string;\n\n  getLabel<T extends KubernetesResource>(\n    resource: T,\n    paramsOrType: string | BaseNormalizeTypeParams,\n    prefix?: string,\n  ): string {\n    return get(resource, [\n      METADATA,\n      LABELS,\n      this.normalizeType(paramsOrType as string, prefix),\n    ]);\n  }\n\n  getProject<T extends KubernetesResource>(resource: T) {\n    return this.getLabel(resource, PROJECT);\n  }\n\n  private retryUpdate<T extends KubernetesResource>(\n    put: (resource: T) => Observable<T>,\n    get: () => Observable<T>,\n    resource: T,\n    silent?: boolean,\n  ): Observable<T> {\n    const waitUserConfirmRetry = (err: Status) =>\n      (silent\n        ? of(null)\n        : from(\n            this.dialog.confirm({\n              title: this.translate.get('resource_version_conflict'),\n              content: this.translate.get('confirm_retry_with_latest_version'),\n              confirmText: this.translate.get('confirm'),\n              cancelText: this.translate.get('cancel'),\n            }),\n          )\n      ).pipe(\n        switchMap(() =>\n          get().pipe(\n            switchMap(newResource =>\n              put({\n                ...resource,\n                metadata: {\n                  ...resource.metadata,\n                  resourceVersion: newResource.metadata.resourceVersion,\n                },\n              }),\n            ),\n            catchError(() => this.retryUpdate(put, get, resource, silent)),\n          ),\n        ),\n        catchError(() => throwError(() => err)),\n      );\n\n    return put(resource).pipe(\n      catchError((err: Status) =>\n        err.code === 409 ? waitUserConfirmRetry(err) : throwError(() => err),\n      ),\n    );\n  }\n\n  // eslint-disable-next-line sonar/function-name\n  $get<T extends KubernetesResource>(resource: T, type: string) {\n    return this.getAnnotation(resource, {\n      type,\n      baseDomain: 'cpaas.io',\n      prefix: TRANSLATION,\n    });\n  }\n\n  // eslint-disable-next-line sonar/function-name\n  $translate<T extends KubernetesResource>(\n    resource: T,\n    type: string,\n    data?: unknown,\n  ) {\n    return this.translate.get(this.$get(resource, type), data);\n  }\n}\n"]}

package/esm2022/core/services/on-resize.service.mjs

@@ -0,0 +1,52 @@
+import { Directive, Injectable, Injector, NgZone, } from '@angular/core';
+import { animationFrameScheduler, fromEvent, auditTime } from 'rxjs';
+import * as i0 from "@angular/core";
+const RESIZE_SCHEDULER = animationFrameScheduler;
+// 提供全局的监听事件
+export class ListenResizeDirective {
+    constructor(injector) {
+        this._resizeService = injector.get(OnResizeChangeService);
+    }
+    ngAfterViewInit() {
+        this._resizeService.subscribe(this);
+    }
+    ngOnDestroy() {
+        this._resizeService.unsubscribe(this);
+    }
+    static { this.ɵfac = function ListenResizeDirective_Factory(t) { return new (t || ListenResizeDirective)(i0.ɵɵdirectiveInject(i0.Injector)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: ListenResizeDirective }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ListenResizeDirective, [{
+        type: Directive
+    }], function () { return [{ type: i0.Injector }]; }, null); })();
+export class OnResizeChangeService {
+    constructor(ngZone) {
+        this.ngZone = ngZone;
+        this._resizeListeners = new Set();
+        this.ngZone.runOutsideAngular(() => Promise.resolve().then(() => {
+            fromEvent(window, 'resize')
+                .pipe(
+            // 收集多个resize
+            auditTime(0, RESIZE_SCHEDULER))
+                .subscribe(_ => {
+                this._resizeListeners.forEach(i => i.onResize());
+            });
+        }));
+    }
+    subscribe(item) {
+        this._resizeListeners.add(item);
+        item.onResize();
+    }
+    unsubscribe(item) {
+        this._resizeListeners.delete(item);
+    }
+    static { this.ɵfac = function OnResizeChangeService_Factory(t) { return new (t || OnResizeChangeService)(i0.ɵɵinject(i0.NgZone)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: OnResizeChangeService, factory: OnResizeChangeService.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(OnResizeChangeService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], function () { return [{ type: i0.NgZone }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/services/silently-navigate.service.mjs

@@ -0,0 +1,28 @@
+import { Location } from '@angular/common';
+import { Injectable } from '@angular/core';
+import { Router } from '@angular/router';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@angular/common";
+export class SilentlyNavigateService {
+    constructor(router, location) {
+        this.router = router;
+        this.location = location;
+    }
+    navigate(from, to) {
+        this.router
+            .navigateByUrl(to, {
+            skipLocationChange: true,
+        })
+            .then(() => {
+            this.location.replaceState(from);
+        });
+    }
+    static { this.ɵfac = function SilentlyNavigateService_Factory(t) { return new (t || SilentlyNavigateService)(i0.ɵɵinject(i1.Router), i0.ɵɵinject(i2.Location)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: SilentlyNavigateService, factory: SilentlyNavigateService.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SilentlyNavigateService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], function () { return [{ type: i1.Router }, { type: i2.Location }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lsZW50bHktbmF2aWdhdGUuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9jb3JlL3NlcnZpY2VzL3NpbGVudGx5LW5hdmlnYXRlLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQzNDLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLGlCQUFpQixDQUFDOzs7O0FBR3pDLE1BQU0sT0FBTyx1QkFBdUI7SUFDbEMsWUFDbUIsTUFBYyxFQUNkLFFBQWtCO1FBRGxCLFdBQU0sR0FBTixNQUFNLENBQVE7UUFDZCxhQUFRLEdBQVIsUUFBUSxDQUFVO0lBQ2xDLENBQUM7SUFFSixRQUFRLENBQUMsSUFBWSxFQUFFLEVBQVU7UUFDL0IsSUFBSSxDQUFDLE1BQU07YUFDUixhQUFhLENBQUMsRUFBRSxFQUFFO1lBQ2pCLGtCQUFrQixFQUFFLElBQUk7U0FDekIsQ0FBQzthQUNELElBQUksQ0FBQyxHQUFHLEVBQUU7WUFDVCxJQUFJLENBQUMsUUFBUSxDQUFDLFlBQVksQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUNuQyxDQUFDLENBQUMsQ0FBQztJQUNQLENBQUM7d0ZBZFUsdUJBQXVCO3VFQUF2Qix1QkFBdUIsV0FBdkIsdUJBQXVCLG1CQURWLE1BQU07O3VGQUNuQix1QkFBdUI7Y0FEbkMsVUFBVTtlQUFDLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IExvY2F0aW9uIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFJvdXRlciB9IGZyb20gJ0Bhbmd1bGFyL3JvdXRlcic7XG5cbkBJbmplY3RhYmxlKHsgcHJvdmlkZWRJbjogJ3Jvb3QnIH0pXG5leHBvcnQgY2xhc3MgU2lsZW50bHlOYXZpZ2F0ZVNlcnZpY2Uge1xuICBjb25zdHJ1Y3RvcihcbiAgICBwcml2YXRlIHJlYWRvbmx5IHJvdXRlcjogUm91dGVyLFxuICAgIHByaXZhdGUgcmVhZG9ubHkgbG9jYXRpb246IExvY2F0aW9uLFxuICApIHt9XG5cbiAgbmF2aWdhdGUoZnJvbTogc3RyaW5nLCB0bzogc3RyaW5nKSB7XG4gICAgdGhpcy5yb3V0ZXJcbiAgICAgIC5uYXZpZ2F0ZUJ5VXJsKHRvLCB7XG4gICAgICAgIHNraXBMb2NhdGlvbkNoYW5nZTogdHJ1ZSxcbiAgICAgIH0pXG4gICAgICAudGhlbigoKSA9PiB7XG4gICAgICAgIHRoaXMubG9jYXRpb24ucmVwbGFjZVN0YXRlKGZyb20pO1xuICAgICAgfSk7XG4gIH1cbn1cbiJdfQ==

package/esm2022/core/services/time.service.mjs

@@ -0,0 +1,46 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { Injectable, Injector } from '@angular/core';
+import dayjs from 'dayjs';
+import relativeTime from 'dayjs/plugin/relativeTime';
+import timezone from 'dayjs/plugin/timezone';
+import utc from 'dayjs/plugin/utc';
+import { Locale, TranslateService } from '../../translate/public-api';
+import { DATE_TIME_FORMAT } from '../constants';
+import * as i0 from "@angular/core";
+dayjs.extend(relativeTime);
+dayjs.extend(timezone);
+dayjs.extend(utc);
+export class TimeService {
+    get currTz() {
+        return dayjs.tz.guess();
+    }
+    constructor(injector) {
+        this.injector = injector;
+    }
+    now(utc) {
+        const now = dayjs();
+        return utc ? now.utc() : now;
+    }
+    format(date, dateFormat = DATE_TIME_FORMAT) {
+        return dayjs(date).format(dateFormat);
+    }
+    distance(date, baseDate) {
+        return dayjs(date)
+            .locale(this.injector.get(TranslateService).locale === Locale.ZH
+            ? 'zh-cn'
+            : 'en')
+            .from(baseDate);
+    }
+    static { this.ɵfac = function TimeService_Factory(t) { return new (t || TimeService)(i0.ɵɵinject(i0.Injector)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: TimeService, factory: TimeService.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TimeService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], function () { return [{ type: i0.Injector }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/services/ui-state.service.mjs

@@ -0,0 +1,68 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, ReplaySubject, debounceTime } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Provides a holder for UI templates to be used globally.
+ */
+export class TemplateHolder {
+    constructor() {
+        this.templatePortalSubject = new BehaviorSubject(undefined);
+    }
+    get templatePortal$() {
+        return this.templatePortalSubject.pipe(debounceTime(0));
+    }
+    setTemplatePortal(templatePortal) {
+        this.templatePortalSubject.next(templatePortal);
+    }
+}
+export var TemplateHolderType;
+(function (TemplateHolderType) {
+    TemplateHolderType["PageHeaderContent"] = "PageHeaderContent";
+})(TemplateHolderType || (TemplateHolderType = {}));
+/**
+ * Acts as a general ui state store
+ */
+export class UiStateService {
+    constructor() {
+        this.templateHolders = new Map();
+        this._prevViewSwitchState = null;
+        this._currViewSwitchState = null;
+        this.activeItemInfo$ = new ReplaySubject(1);
+    }
+    registerTemplateHolder(id) {
+        if (this.templateHolders.has(id)) {
+            throw new Error(`Template holder for ${id} has already registered!`);
+        }
+        this.templateHolders.set(id, new TemplateHolder());
+    }
+    // Will init template holder if not initialled yet
+    getTemplateHolder(id) {
+        if (!this.templateHolders.has(id)) {
+            this.registerTemplateHolder(id);
+        }
+        return this.templateHolders.get(id);
+    }
+    /**
+     * NOTE: only set active item info in ConsoleComponent
+     */
+    setActiveItemInfo(activeNavItemInfo) {
+        this.activeItemInfo$.next(activeNavItemInfo);
+    }
+    /**
+     * NOTE: only use for view switch status recording
+     */
+    setViewSwitchState(state) {
+        this._prevViewSwitchState = this._currViewSwitchState;
+        this._currViewSwitchState = state;
+    }
+    shouldViewSwitchAnimate() {
+        return ![null, this._currViewSwitchState].includes(this._prevViewSwitchState);
+    }
+    static { this.ɵfac = function UiStateService_Factory(t) { return new (t || UiStateService)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: UiStateService, factory: UiStateService.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(UiStateService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/services/workspace-helper.service.mjs

@@ -0,0 +1,21 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class WorkspaceHelperService {
+    constructor() {
+        this.baseParams$$ = new BehaviorSubject({});
+        this.baseParams = this.baseParams$$.asObservable();
+    }
+    get baseParamsSnapshot() {
+        return this.baseParams$$.value;
+    }
+    setBaseParams(params) {
+        this.baseParams$$.next(params);
+    }
+    static { this.ɵfac = function WorkspaceHelperService_Factory(t) { return new (t || WorkspaceHelperService)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: WorkspaceHelperService, factory: WorkspaceHelperService.ɵfac }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(WorkspaceHelperService, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ya3NwYWNlLWhlbHBlci5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21tb24vc3JjL2NvcmUvc2VydmljZXMvd29ya3NwYWNlLWhlbHBlci5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFM0MsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLE1BQU0sQ0FBQzs7QUFLdkMsTUFBTSxPQUFPLHNCQUFzQjtJQURuQztRQUVtQixpQkFBWSxHQUFHLElBQUksZUFBZSxDQUFrQixFQUFFLENBQUMsQ0FBQztRQUVoRSxlQUFVLEdBQUcsSUFBSSxDQUFDLFlBQVksQ0FBQyxZQUFZLEVBQUUsQ0FBQztLQVF4RDtJQVBDLElBQUksa0JBQWtCO1FBQ3BCLE9BQU8sSUFBSSxDQUFDLFlBQVksQ0FBQyxLQUFLLENBQUM7SUFDakMsQ0FBQztJQUVELGFBQWEsQ0FBQyxNQUF1QjtRQUNuQyxJQUFJLENBQUMsWUFBWSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUNqQyxDQUFDO3VGQVZVLHNCQUFzQjt1RUFBdEIsc0JBQXNCLFdBQXRCLHNCQUFzQjs7dUZBQXRCLHNCQUFzQjtjQURsQyxVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQWN0aXZhdGVkUm91dGUgfSBmcm9tICdAYW5ndWxhci9yb3V0ZXInO1xuaW1wb3J0IHsgQmVoYXZpb3JTdWJqZWN0IH0gZnJvbSAncnhqcyc7XG5cbmltcG9ydCB7IFdvcmtzcGFjZVBhcmFtcyB9IGZyb20gJy4uL3R5cGVzJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIFdvcmtzcGFjZUhlbHBlclNlcnZpY2Uge1xuICBwcml2YXRlIHJlYWRvbmx5IGJhc2VQYXJhbXMkJCA9IG5ldyBCZWhhdmlvclN1YmplY3Q8V29ya3NwYWNlUGFyYW1zPih7fSk7XG4gIGJhc2VBY3RpdmF0ZWRSb3V0ZTogQWN0aXZhdGVkUm91dGU7XG4gIHJlYWRvbmx5IGJhc2VQYXJhbXMgPSB0aGlzLmJhc2VQYXJhbXMkJC5hc09ic2VydmFibGUoKTtcbiAgZ2V0IGJhc2VQYXJhbXNTbmFwc2hvdCgpIHtcbiAgICByZXR1cm4gdGhpcy5iYXNlUGFyYW1zJCQudmFsdWU7XG4gIH1cblxuICBzZXRCYXNlUGFyYW1zKHBhcmFtczogV29ya3NwYWNlUGFyYW1zKSB7XG4gICAgdGhpcy5iYXNlUGFyYW1zJCQubmV4dChwYXJhbXMpO1xuICB9XG59XG4iXX0=

package/esm2022/core/services/yaml-util.service.mjs

@@ -0,0 +1,97 @@
+import { Inject, Injectable } from '@angular/core';
+import { get, sortBy } from 'lodash-es';
+import { ANNOTATIONS, LABELS, METADATA, TOKEN_BASE_DOMAIN, } from '..';
+import { emptyObjectRemoveRuleFactory, prefixFilterRuleFactory, stringify, yamlFilterField, } from '../utils';
+import * as i0 from "@angular/core";
+export class YamlUtilService {
+    constructor(baseDomain) {
+        this.baseDomain = baseDomain;
+    }
+    // https://confluence.alauda.cn/pages/viewpage.action?pageId=112060211
+    // 所有资源规则全平台通用
+    getConciseResource(r) {
+        const commonFilters = [
+            'metadata.namespace',
+            'metadata.managedFields',
+            'metadata.creationTimestamp',
+            'metadata.generation',
+            'metadata.resourceVersion',
+            'metadata.uid',
+            'metadata.ownerReferences',
+            'metadata.finalizers',
+            'metadata.selfLink',
+            `metadata.labels.['app.${this.baseDomain}/uuid']`,
+            prefixFilterRuleFactory(this.baseDomain, [METADATA, ANNOTATIONS]),
+            prefixFilterRuleFactory('kubernetes.io', [METADATA, ANNOTATIONS], 'includes'),
+            'status',
+        ];
+        const specificFilters = [];
+        switch (r.kind) {
+            case 'Application': {
+                specificFilters.push('metadata.labels.sync-from-helmrequest');
+                break;
+            }
+            case 'Deployment':
+            case 'StatefulSet':
+            case 'DaemonSet': {
+                specificFilters.push('spec.template.annotations.updateTimestamp');
+                break;
+            }
+            case 'Job': {
+                specificFilters.push('spec.selector.matchLabels', 'spec.template.metadata.labels.controller-uid', `${METADATA}.${LABELS}.controller-uid`, prefixFilterRuleFactory('batch.kubernetes.io/controller-uid', ['spec', 'template', METADATA, LABELS], 'includes'));
+                break;
+            }
+            case 'PersistentVolumeClaim': {
+                specificFilters.push(prefixFilterRuleFactory('pv.kubernetes.io', [METADATA, ANNOTATIONS], 'startsWith'), prefixFilterRuleFactory('volume.beta.kubernetes.io', [METADATA, ANNOTATIONS], 'startsWith'), 'spec.volumeName');
+                break;
+            }
+            case 'Service': {
+                specificFilters.push(resource => {
+                    const ports = get(resource, ['spec', 'ports']);
+                    return ports.map((_, i) => ['spec', 'ports', `[${i}]`, 'nodePort'].join('.'));
+                }, 'spec.clusterIPs', 'spec.clusterIP', 'spec.ipFamilies', 'spec.ipFamilyPolicy');
+                break;
+            }
+            default: {
+                break;
+            }
+        }
+        specificFilters.push(emptyObjectRemoveRuleFactory([METADATA, ANNOTATIONS]), emptyObjectRemoveRuleFactory([METADATA, LABELS]));
+        return yamlFilterField(r, [...commonFilters, ...specificFilters]);
+    }
+    /**
+     *
+     *
+     * @template T
+     * @param {T} resource
+     * @param {boolean} [concise=false] 精简 Yaml
+     * @param {boolean} [reduce=false] 隐藏 managedFields
+     * @returns
+     * @memberof YamlUtilService
+     */
+    generateFilteredYamlResource(resource, concise = false, reduce = false) {
+        return sortBy(Array.isArray(resource) ? resource : [resource], 'kind')
+            .map((resource) => concise
+            ? this.getConciseResource(resource)
+            : reduce
+                ? yamlFilterField(resource, ['metadata.managedFields'])
+                : resource)
+            .map(res => stringify(res, {
+            strict: false,
+            sortMapEntries: true,
+        }))
+            .join('\n---\r\n\n');
+    }
+    static { this.ɵfac = function YamlUtilService_Factory(t) { return new (t || YamlUtilService)(i0.ɵɵinject(TOKEN_BASE_DOMAIN)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: YamlUtilService, factory: YamlUtilService.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(YamlUtilService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], function () { return [{ type: undefined, decorators: [{
+                type: Inject,
+                args: [TOKEN_BASE_DOMAIN]
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"yaml-util.service.js","sourceRoot":"","sources":["../../../../../../libs/common/src/core/services/yaml-util.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { get, sortBy } from 'lodash-es';\n\nimport {\n  ANNOTATIONS,\n  Arrayable,\n  KubernetesResource,\n  LABELS,\n  METADATA,\n  TOKEN_BASE_DOMAIN,\n} from '..';\nimport {\n  emptyObjectRemoveRuleFactory,\n  prefixFilterRuleFactory,\n  stringify,\n  yamlFilterField,\n  YamlFilterItem,\n} from '../utils';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class YamlUtilService {\n  constructor(@Inject(TOKEN_BASE_DOMAIN) private readonly baseDomain: string) {}\n\n  // https://confluence.alauda.cn/pages/viewpage.action?pageId=112060211\n  // 所有资源规则全平台通用\n  getConciseResource(r: KubernetesResource) {\n    const commonFilters: YamlFilterItem[] = [\n      'metadata.namespace',\n      'metadata.managedFields',\n      'metadata.creationTimestamp',\n      'metadata.generation',\n      'metadata.resourceVersion',\n      'metadata.uid',\n      'metadata.ownerReferences',\n      'metadata.finalizers',\n      'metadata.selfLink',\n      `metadata.labels.['app.${this.baseDomain}/uuid']`,\n      prefixFilterRuleFactory(this.baseDomain, [METADATA, ANNOTATIONS]),\n      prefixFilterRuleFactory(\n        'kubernetes.io',\n        [METADATA, ANNOTATIONS],\n        'includes',\n      ),\n      'status',\n    ];\n    const specificFilters: YamlFilterItem[] = [];\n    switch (r.kind) {\n      case 'Application': {\n        specificFilters.push('metadata.labels.sync-from-helmrequest');\n        break;\n      }\n      case 'Deployment':\n      case 'StatefulSet':\n      case 'DaemonSet': {\n        specificFilters.push('spec.template.annotations.updateTimestamp');\n        break;\n      }\n      case 'Job': {\n        specificFilters.push(\n          'spec.selector.matchLabels',\n          'spec.template.metadata.labels.controller-uid',\n          `${METADATA}.${LABELS}.controller-uid`,\n          prefixFilterRuleFactory(\n            'batch.kubernetes.io/controller-uid',\n            ['spec', 'template', METADATA, LABELS],\n            'includes',\n          ),\n        );\n        break;\n      }\n      case 'PersistentVolumeClaim': {\n        specificFilters.push(\n          prefixFilterRuleFactory(\n            'pv.kubernetes.io',\n            [METADATA, ANNOTATIONS],\n            'startsWith',\n          ),\n          prefixFilterRuleFactory(\n            'volume.beta.kubernetes.io',\n            [METADATA, ANNOTATIONS],\n            'startsWith',\n          ),\n          'spec.volumeName',\n        );\n        break;\n      }\n      case 'Service': {\n        specificFilters.push(\n          resource => {\n            const ports = get(resource, ['spec', 'ports']) as any[];\n            return ports.map((_, i) =>\n              ['spec', 'ports', `[${i}]`, 'nodePort'].join('.'),\n            );\n          },\n          'spec.clusterIPs',\n          'spec.clusterIP',\n          'spec.ipFamilies',\n          'spec.ipFamilyPolicy',\n        );\n        break;\n      }\n      default: {\n        break;\n      }\n    }\n    specificFilters.push(\n      emptyObjectRemoveRuleFactory([METADATA, ANNOTATIONS]),\n      emptyObjectRemoveRuleFactory([METADATA, LABELS]),\n    );\n    return yamlFilterField(r, [...commonFilters, ...specificFilters]);\n  }\n\n  /**\n   *\n   *\n   * @template T\n   * @param {T} resource\n   * @param {boolean} [concise=false] 精简 Yaml\n   * @param {boolean} [reduce=false] 隐藏 managedFields\n   * @returns\n   * @memberof YamlUtilService\n   */\n  generateFilteredYamlResource<T extends KubernetesResource>(\n    resource: Arrayable<T>,\n    concise = false,\n    reduce = false,\n  ) {\n    return sortBy(Array.isArray(resource) ? resource : [resource], 'kind')\n      .map((resource: T) =>\n        concise\n          ? this.getConciseResource(resource)\n          : reduce\n          ? yamlFilterField(resource, ['metadata.managedFields'])\n          : resource,\n      )\n      .map(res =>\n        stringify(res, {\n          strict: false,\n          sortMapEntries: true,\n        }),\n      )\n      .join('\\n---\\r\\n\\n');\n  }\n}\n"]}

package/esm2022/core/types/commons.mjs

@@ -0,0 +1,6 @@
+/**
+ * @packageDocumentation
+ * @module types
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9jb3JlL3R5cGVzL2NvbW1vbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAcGFja2FnZURvY3VtZW50YXRpb25cbiAqIEBtb2R1bGUgdHlwZXNcbiAqL1xuXG5leHBvcnQgdHlwZSBTdHJpbmdNYXAgPSBSZWNvcmQ8c3RyaW5nLCBzdHJpbmc+O1xuXG5leHBvcnQgaW50ZXJmYWNlIEVudmlyb25tZW50cyB7XG4gIEdMT0JBTF9OQU1FU1BBQ0U/OiBzdHJpbmc7XG4gIExBQkVMX0JBU0VfRE9NQUlOPzogc3RyaW5nO1xuICBMT0dPX1VSTD86IHN0cmluZztcbiAgSU5ORVJfUFJPSkVDVF9OU19QUkVGSVg/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgUmVzb3VyY2VMaXN0UGFyYW1zIGV4dGVuZHMgU3RyaW5nTWFwIHtcbiAgbGltaXQ/OiBzdHJpbmc7XG4gIGNvbnRpbnVlPzogc3RyaW5nO1xuICBsYWJlbFNlbGVjdG9yPzogc3RyaW5nO1xuICBmaWVsZFNlbGVjdG9yPzogc3RyaW5nO1xuICBmaWVsZD86IHN0cmluZztcbiAga2V5d29yZD86IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBXb3Jrc3BhY2VQYXJhbXMge1xuICBwcm9qZWN0Pzogc3RyaW5nO1xuICBjbHVzdGVyPzogc3RyaW5nO1xuICBuYW1lc3BhY2U/OiBzdHJpbmc7XG4gIHNlcnZpY2VtZXNoPzogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFdvcmtzcGFjZUxpc3RQYXJhbXNcbiAgZXh0ZW5kcyBXb3Jrc3BhY2VQYXJhbXMsXG4gICAgUmVzb3VyY2VMaXN0UGFyYW1zIHt9XG5cbmV4cG9ydCBpbnRlcmZhY2UgV29ya3NwYWNlRGV0YWlsUGFyYW1zIGV4dGVuZHMgV29ya3NwYWNlTGlzdFBhcmFtcyB7XG4gIG5hbWU/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCB0eXBlIEtleVZhbHVlPFYgPSBzdHJpbmcsIFQgZXh0ZW5kcyBvYmplY3QgPSBvYmplY3Q+ID0gVCAmIHtcbiAga2V5OiBzdHJpbmc7XG4gIHZhbHVlOiBWO1xufTtcblxuZXhwb3J0IHR5cGUgUGFnaW5hdGlvbjxULCBPID0geyBba2V5OiBzdHJpbmddOiB1bmtub3duIH0+ID0ge1xuICB0b3RhbDogbnVtYmVyO1xuICBpdGVtczogVFtdO1xufSAmIE87XG4iXX0=

package/esm2022/core/types/helpers.mjs

@@ -0,0 +1,12 @@
+/**
+ * @packageDocumentation
+ * @module types
+ */
+export function isErrorMessage(error) {
+    return 'message' in error && typeof error.message === 'string';
+}
+export const DataSource = {
+    Platform: 'Platform',
+    Business: 'Business',
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/types/index.mjs

@@ -0,0 +1,11 @@
+/**
+ * @packageDocumentation
+ * @module types
+ * @preferred
+ */
+export * from './commons';
+export * from './helpers';
+export * from './k8s';
+export * from './schema';
+export * from './resource-definitions';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbW1vbi9zcmMvY29yZS90eXBlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBRUgsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxPQUFPLENBQUM7QUFDdEIsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyx3QkFBd0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQHBhY2thZ2VEb2N1bWVudGF0aW9uXG4gKiBAbW9kdWxlIHR5cGVzXG4gKiBAcHJlZmVycmVkXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9jb21tb25zJztcbmV4cG9ydCAqIGZyb20gJy4vaGVscGVycyc7XG5leHBvcnQgKiBmcm9tICcuL2s4cyc7XG5leHBvcnQgKiBmcm9tICcuL3NjaGVtYSc7XG5leHBvcnQgKiBmcm9tICcuL3Jlc291cmNlLWRlZmluaXRpb25zJztcbiJdfQ==