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

package/k8s-resource-list/k8s-resource-list.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @packageDocumentation
+ * @module k8s-resource-list
+ */
+import { HttpErrorResponse } from '@angular/common/http';
+import { Observable, ReplaySubject } from 'rxjs';
+import { KubernetesResource, KubernetesResourceList, ResourceListParams, Status } from '../types';
+import { ConfigWithParams, ConfigWithRoute, ItemsScanner, ListParams, LoadSnapshot, LoadState, StreamListLoader } from './types';
+export declare class K8SResourceList<R extends KubernetesResource = KubernetesResource, Q extends object = ResourceListParams, P extends Q & ListParams = Q & ListParams> implements StreamListLoader<KubernetesResourceList<R>, R> {
+    private readonly reloadAction$$;
+    private readonly loadMoreAction$$;
+    private readonly itemsScanner$$;
+    private readonly destroy$$;
+    private readonly insertFn;
+    loadState$: Observable<LoadState<KubernetesResourceList<R>>>;
+    queryParams$: Observable<Q>;
+    rawResponse$: Observable<KubernetesResourceList<R>>;
+    loading$: Observable<boolean>;
+    loadingError$: Observable<HttpErrorResponse | Status>;
+    hasMore$: Observable<boolean>;
+    continueToken$: Observable<string>;
+    items$: Observable<R[]>;
+    bypassItems$: ReplaySubject<R[]>;
+    timer: number;
+    snapshot: LoadSnapshot<KubernetesResourceList<R>, R, Q>;
+    constructor({ fetcher, activatedRoute }: ConfigWithRoute<R, Q, P>);
+    constructor({ fetcher, fetchParams$ }: ConfigWithParams<R, Q, P>);
+    reload(silent?: boolean): void;
+    loadMore(): void;
+    scanItems(scanner: ItemsScanner<R>): void;
+    destroy(): void;
+    create(resource: R): void;
+    update(resource: R): void;
+    delete(resource?: R): void;
+    private _create;
+    private _update;
+    private _delete;
+    private buildLoadStateStream;
+    private extractContinueTokenFromState;
+    private initStreams;
+    private buildWatcher;
+}

package/k8s-resource-list/k8s-resource-paged-list.d.ts

@@ -0,0 +1,61 @@
+import { WatchAPIResponse } from '@alauda-fe/dynamic-plugin-sdk';
+import { HttpErrorResponse } from '@angular/common/http';
+import { Signal } from '@angular/core';
+import { Params } from '@angular/router';
+import { Observable } from 'rxjs';
+import { KubernetesResource, KubernetesResourceList, Status } from '../types';
+export declare class K8SResourcePagedList<R extends KubernetesResource = KubernetesResource, P = unknown> {
+    private readonly config;
+    private readonly reload$$;
+    private readonly addedUid;
+    private readonly deletedUid;
+    params$: Observable<ListFetchParams<P>>;
+    loadState$: Observable<LoadState<R>>;
+    loading$: Observable<boolean>;
+    items$: Observable<R[]>;
+    totalItems$: Observable<number>;
+    loadError$: Observable<Status | HttpErrorResponse>;
+    $loading: Signal<boolean>;
+    $items: Signal<R[]>;
+    $totalItems: Signal<number>;
+    $loadError: Signal<Status | HttpErrorResponse>;
+    constructor(config: PagedListConfig<R, P>);
+    reload(): void;
+    private sourceLoadState;
+    private loadStateWithPolling;
+    private loadStateWithWatcher;
+}
+export interface PagedListConfig<R, P> {
+    params: Signal<ListFetchParams<P>> | Observable<ListFetchParams<P>>;
+    fetcher: (listParams: FetchSeed, extraParams: P) => Observable<KubernetesResourceList<R>>;
+    watcher?: (listParams: FetchSeed, extraParams: P) => Observable<WatchAPIResponse<R>>;
+    polling?: number;
+}
+export interface ListFetchParams<P = never> {
+    pageIndex?: number | string;
+    pageSize?: number | string;
+    sortField?: string;
+    sortOrder?: 'asc' | 'desc';
+    keyword?: string;
+    fieldSelector?: string;
+    labelSelector?: string;
+    extra?: P;
+}
+export interface FetchSeed extends Record<string, string> {
+    limit?: string;
+    continue?: string;
+    fieldSelector?: string;
+}
+interface LoadState<R> {
+    items: R[];
+    totalItems: number;
+    loading: boolean;
+    loadSuccess: boolean;
+    loadError?: HttpErrorResponse | Status;
+}
+export declare function extractPagedListParams<P>(defaultParams?: ListFetchParams, extraParams?: (queryParams: Params) => P): Readonly<{
+    stream: () => Observable<ListFetchParams<P>>;
+    signal: () => Signal<ListFetchParams<P>>;
+}>;
+export declare function queryListParams(): (queryParams: Params) => void;
+export {};

package/k8s-resource-list/types.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @packageDocumentation
+ * @module k8s-resource-list
+ */
+import { WatchAPIResponse } from '@alauda-fe/dynamic-plugin-sdk';
+import { HttpErrorResponse } from '@angular/common/http';
+import { ActivatedRoute } from '@angular/router';
+import { Observable } from 'rxjs';
+import { KubernetesResource, KubernetesResourceList, Status, StringMap } from '../types';
+import { K8SResourceList } from './k8s-resource-list';
+export type Watcher<R extends KubernetesResource, Q> = (seedVersion: string, params?: Q) => Observable<WatchAPIResponse<R>>;
+export type InsertFn<R> = (items: R[], res: R, hasMore: boolean) => R[];
+export interface WatcherParams<R extends KubernetesResource, Q> {
+    list: K8SResourceList<R>;
+    watcher: Watcher<R, Q>;
+    insertFn?: InsertFn<R>;
+}
+interface BaseConfig<R extends KubernetesResource, Q> {
+    watcher?: Watcher<R, Q>;
+    insertFn?: InsertFn<R>;
+    limit?: number;
+    polling?: number;
+}
+export type ItemsScanner<R> = (items: R[]) => R[];
+export interface ConfigWithRoute<R, Q, P> extends BaseConfig<R, Q> {
+    fetcher: (params: P) => Observable<KubernetesResourceList<R>>;
+    activatedRoute?: ActivatedRoute;
+}
+export interface ConfigWithParams<R, Q, P> extends BaseConfig<R, Q> {
+    fetcher: (params: P) => Observable<KubernetesResourceList<R>>;
+    fetchParams$?: Observable<Q>;
+}
+export declare enum LoadAction {
+    Reload = "Reload",
+    SilentReload = "SilentReload",
+    LoadMore = "LoadMore"
+}
+export interface LoadState<R> {
+    action?: LoadAction;
+    rawResponse?: R;
+    loading?: boolean;
+    loadingError?: HttpErrorResponse | Status;
+}
+export interface ListParams extends StringMap {
+    limit: string;
+    continue: string;
+}
+export interface StreamListLoader<R, T> {
+    loadState$: Observable<LoadState<R>>;
+    loading$: Observable<boolean>;
+    loadingError$: Observable<HttpErrorResponse | Status>;
+    hasMore$: Observable<boolean>;
+    rawResponse$: Observable<R>;
+    items$: Observable<T[]>;
+    snapshot: StreamListLoaderSnapshot<R, T>;
+    loadMore(): void;
+    reload(): void;
+}
+export interface StreamListLoaderSnapshot<R, T> {
+    rawResponse?: R;
+    loading?: boolean;
+    loadingError?: HttpErrorResponse | Status;
+    hasMore?: boolean;
+    continueToken?: string;
+    items?: T[];
+}
+export interface LoadSnapshot<R, T, Q> extends StreamListLoaderSnapshot<R, T> {
+    queryParams?: Q;
+}
+export {};

package/k8s-resource-list/utils.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @packageDocumentation
+ * @module k8s-resource-list
+ */
+import { ActivatedRoute } from '@angular/router';
+import { Observable } from 'rxjs';
+import { LabelSelectorRequirement, ResourceListParams, StringMap } from '../types';
+/**
+ * convert selector.matchLabels to string
+ * refers to: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api
+ */
+export declare function matchLabelsToString(params?: StringMap): string;
+/**
+ * convert string to selector.matchLabels
+ */
+export declare function stringToMatchLabels(str?: string): Record<string, string>;
+export declare function matchExpressionsToString(params: LabelSelectorRequirement[]): string;
+export declare function extractListParamsFromRoute(route: ActivatedRoute): Observable<ResourceListParams>;
+export declare function normalizeParams<P extends object>(params: P): P;

package/k8s-shared/constants.d.ts

@@ -0,0 +1,7 @@
+import { K8sResourceDefinition } from '@alauda-fe/dynamic-plugin-sdk';
+export interface ManageResourceType {
+    kind: string;
+    definition: K8sResourceDefinition;
+    kindAlias?: string;
+}
+export declare const CONTROLLED_RESOURCE_TRANSLATIONS: ManageResourceType[];

package/k8s-shared/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @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';

package/k8s-shared/k8s-resource-translate-key.pipe.d.ts

@@ -0,0 +1,9 @@
+import { InjectionToken, PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const K8S_RESOURCE_TRANSLATE_KEY: InjectionToken<(type: string, apiGroup: string) => string>;
+export declare class K8sResourceTranslateKeyPipe implements PipeTransform {
+    private getKey;
+    transform(type: string, apiGroup?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<K8sResourceTranslateKeyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<K8sResourceTranslateKeyPipe, "aclK8sResourceTranslateKey", true>;
+}

package/k8s-shared/k8s-shared-util.service.d.ts

@@ -0,0 +1,48 @@
+import { K8sResourceDefinition, ResourceWriteParams, K8sUtilService } from '@alauda-fe/dynamic-plugin-sdk';
+import { Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ANNOTATIONS, LABELS } from '../constants';
+import { KubernetesResource, StringMap } from '../types';
+import * as i0 from "@angular/core";
+export declare class K8sSharedUtilService<R extends string = string> extends K8sUtilService<R> {
+    constructor(injector: Injector);
+    /**
+     * 更新 Annotation 或 Label
+     */
+    updatePart<T extends KubernetesResource>(params: ResourceWriteParams<R, T> & {
+        readonlyKeys?: Array<string | RegExp>;
+        part: typeof ANNOTATIONS | typeof LABELS;
+        getResourceSpec?: (stringMap: StringMap) => Record<string, unknown>;
+        dialogClass?: string;
+    }): Observable<T>;
+    updateDisplayName<T extends KubernetesResource>({ type, cluster, resource, definition, }: {
+        definition?: K8sResourceDefinition;
+        /**
+         * @deprecated use `definition` instead
+         */
+        type?: R;
+        cluster?: string;
+        resource: T;
+    }, validateMaxLength?: boolean): Observable<T>;
+    updateDescription<T extends KubernetesResource>({ type, cluster, resource, definition, }: {
+        /**
+         * @deprecated use `definition` instead
+         */
+        type?: R;
+        definition?: K8sResourceDefinition;
+        cluster?: string;
+        resource: T;
+    }): Observable<T>;
+    /**
+     * 单项目绑定切换至多项目绑定时，兼容之前的 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: KubernetesResource | string[]): string[];
+    getProjectLabels(projects: string[], value?: string): StringMap;
+    static ɵfac: i0.ɵɵFactoryDeclaration<K8sSharedUtilService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<K8sSharedUtilService<any>>;
+}

package/k8s-shared/resource-mark/component.d.ts

@@ -0,0 +1,16 @@
+import { ThemeService } from '@alauda/ui';
+import { KubernetesResource } from '../../types/k8s/core';
+import * as i0 from "@angular/core";
+export declare class K8sResourceMarkComponent {
+    private theme;
+    size: 'small' | 'mini';
+    currentTheme: import("@angular/core").Signal<import("@alauda/ui").Theme>;
+    constructor(theme: ThemeService);
+    kind: import("@angular/core").InputSignal<string>;
+    apiVersion: import("@angular/core").InputSignal<string>;
+    resource: import("@angular/core").InputSignal<KubernetesResource>;
+    mark: import("@angular/core").Signal<string>;
+    color: import("@angular/core").Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<K8sResourceMarkComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<K8sResourceMarkComponent, "acl-k8s-mark", never, { "size": { "alias": "size"; "required": false; }; "kind": { "alias": "kind"; "required": false; "isSignal": true; }; "apiVersion": { "alias": "apiVersion"; "required": false; "isSignal": true; }; "resource": { "alias": "resource"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/k8s-shared/resource-mark/util.d.ts

@@ -0,0 +1,2 @@
+export declare function getResourceMark(kind: string, apiGroup?: string): string;
+export declare function getResourceColor(kind: string, theme: string): string;

package/k8s-shared/update-description-dialog/component.d.ts

@@ -0,0 +1,33 @@
+import { DialogRef } from '@alauda/ui';
+import { K8sApiService, K8sResourceDefinition, K8sUtilService, ResourceType } from '@alauda-fe/dynamic-plugin-sdk';
+import { BehaviorSubject } from 'rxjs';
+import { KubernetesResource } from '../../types';
+import * as i0 from "@angular/core";
+export declare class UpdateDescriptionDialogComponent<T extends KubernetesResource> {
+    private readonly dialogRef;
+    private readonly k8sApi;
+    private readonly k8sUtil;
+    data: {
+        definition?: K8sResourceDefinition;
+        /**
+         * @deprecated use `definition` instead
+         */
+        type?: ResourceType;
+        cluster?: string;
+        resource: T;
+    };
+    description: string;
+    confirming$$: BehaviorSubject<boolean>;
+    constructor(dialogRef: DialogRef, k8sApi: K8sApiService, k8sUtil: K8sUtilService, data: {
+        definition?: K8sResourceDefinition;
+        /**
+         * @deprecated use `definition` instead
+         */
+        type?: ResourceType;
+        cluster?: string;
+        resource: T;
+    });
+    confirm(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UpdateDescriptionDialogComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UpdateDescriptionDialogComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
+}

package/k8s-shared/update-display-name-dialog/component.d.ts

@@ -0,0 +1,27 @@
+import { DialogRef } from '@alauda/ui';
+import { K8sApiService, K8sResourceDefinition, K8sUtilService } from '@alauda-fe/dynamic-plugin-sdk';
+import { BehaviorSubject } from 'rxjs';
+import { KubernetesResource } from '../../types';
+import * as i0 from "@angular/core";
+export declare class UpdateDisplayNameDialogComponent<T extends KubernetesResource> {
+    private readonly dialogRef;
+    private readonly k8sApi;
+    private readonly k8sUtil;
+    data: {
+        definition?: K8sResourceDefinition;
+        cluster?: string;
+        resource: T;
+        validateMaxLength?: boolean;
+    };
+    displayName: string;
+    confirming$$: BehaviorSubject<boolean>;
+    constructor(dialogRef: DialogRef, k8sApi: K8sApiService, k8sUtil: K8sUtilService, data: {
+        definition?: K8sResourceDefinition;
+        cluster?: string;
+        resource: T;
+        validateMaxLength?: boolean;
+    });
+    confirm(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UpdateDisplayNameDialogComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UpdateDisplayNameDialogComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
+}

package/k8s-shared/update-key-value-dialog/component.d.ts

@@ -0,0 +1,38 @@
+import { DialogRef, MessageService } from '@alauda/ui';
+import { StringMap, TranslateService } from '@alauda-fe/dynamic-plugin-sdk';
+import { OnDestroy, OnInit } from '@angular/core';
+import { ValidatorFn } from '@angular/forms';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export interface UpdateKeyValueDialogData<R = unknown, Context = unknown, T = StringMap> {
+    title?: string;
+    keyValues?: T;
+    confirmButton?: string;
+    readonlyKeys?: Array<string | RegExp>;
+    onUpdate?: (keyValues: T) => Promise<R> | Observable<R>;
+    context?: Context;
+    updateSuccessMsg?: string;
+    updateFailMsg?: string;
+    validator?: {
+        key: ValidatorFn | ValidatorFn[];
+        value?: ValidatorFn | ValidatorFn[];
+    };
+    errorMapper?: Record<string, unknown>;
+    showMessage?: boolean;
+}
+export declare class UpdateKeyValueDialogComponent<R = unknown, Context = unknown, T = StringMap> implements OnInit, OnDestroy {
+    private readonly dialogRef;
+    private readonly message;
+    private readonly translate;
+    data: UpdateKeyValueDialogData<R, Context, T>;
+    readonly onUpdate$$: Subject<void>;
+    readonly submitting$$: BehaviorSubject<boolean>;
+    private readonly originalKeyValues;
+    keyValues: T;
+    private readonly destroy$$;
+    constructor(dialogRef: DialogRef<UpdateKeyValueDialogComponent<R, Context, T>, UpdateKeyValueDialogData<R, Context, T>>, message: MessageService, translate: TranslateService, data?: UpdateKeyValueDialogData<R, Context, T>);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UpdateKeyValueDialogComponent<any, any, any>, [null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UpdateKeyValueDialogComponent<any, any, any>, "ng-component", never, {}, {}, never, never, true, never>;
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@alauda-fe/dynamic-plugin-shared",
+  "version": "0.0.1-alpha.0",
+  "peerDependencies": {
+    "@alauda-fe/i18n": "1.0.4",
+    "@alauda/chart": "^0.1.11",
+    "@alauda/code-editor": "^5.1.0",
+    "@alauda/ui": "^7.2.0",
+    "@alauda-fe/dynamic-plugin-sdk": "0.0.1",
+    "@angular/common": "^18.1.1",
+    "@angular/core": "^18.1.1",
+    "@angular/animations": "^18.1.1",
+    "@angular/cdk": "^16.2.2",
+    "@angular/compiler": "^18.1.1",
+    "@angular/forms": "^18.1.1",
+    "@angular/platform-browser": "^18.1.1",
+    "@angular/platform-browser-dynamic": "^18.1.1",
+    "@angular/router": "^18.1.1",
+    "ab64": "^0.1.1",
+    "compare-versions": "^6.1.0",
+    "cron-parser": "^4.9.0",
+    "d3": "^7.8.5",
+    "dayjs": "^1.11.9",
+    "lodash-es": "^4.17.21",
+    "marked": "^7.0.5",
+    "monaco-editor": "^0.39.0",
+    "ng-monaco-editor": "^5.1.0",
+    "ng-resource-form-util": "^6.1.0",
+    "ramda": "^0.29.0",
+    "rxjs": "^7.8.1",
+    "ts-md5": "^1.3.1",
+    "yaml": "^2.3.2",
+    "zone.js": "^0.13.1"
+  },
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "module": "fesm2022/alauda-fe-dynamic-plugin-shared.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "esm2022": "./esm2022/alauda-fe-dynamic-plugin-shared.mjs",
+      "esm": "./esm2022/alauda-fe-dynamic-plugin-shared.mjs",
+      "default": "./fesm2022/alauda-fe-dynamic-plugin-shared.mjs"
+    }
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  }
+}

package/page-deactivate/deactivate.directive.d.ts

@@ -0,0 +1,18 @@
+import { AfterViewInit, ElementRef, OnDestroy } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+import { InterceptDeactivateService } from './deactivate.service';
+import * as i0 from "@angular/core";
+export declare class InterceptDeactivateDirective implements AfterViewInit, OnDestroy {
+    private readonly elRef;
+    private readonly interceptDeactivate;
+    enabled: boolean | '';
+    enabled$$: Observable<boolean | ''>;
+    enabled$: Observable<boolean>;
+    destroy$$: Subject<void>;
+    constructor(elRef: ElementRef<HTMLElement>, interceptDeactivate: InterceptDeactivateService);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onBeforeUnload(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InterceptDeactivateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InterceptDeactivateDirective, "[aclInterceptDeactivate]", never, { "enabled": { "alias": "aclInterceptDeactivate"; "required": false; }; }, {}, never, never, true, never>;
+}

package/page-deactivate/deactivate.guard.d.ts

@@ -0,0 +1,13 @@
+import { Injector } from '@angular/core';
+import { ActivatedRouteSnapshot, CanDeactivate, RouterStateSnapshot } from '@angular/router';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare const ESCAPE_DEACTIVATE_GUARD = "__ESCAPE_DEACTIVATE_GUARD__";
+export declare const CURR_ESCAPE_DEACTIVATE_GUARD = "__CURR_ESCAPE_DEACTIVATE_GUARD__";
+export declare class InterceptDeactivateGuard implements CanDeactivate<unknown> {
+    private readonly injector;
+    constructor(injector: Injector);
+    canDeactivate(component: object, currentRoute: ActivatedRouteSnapshot, currentState: RouterStateSnapshot, nextState: RouterStateSnapshot): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InterceptDeactivateGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InterceptDeactivateGuard>;
+}

package/page-deactivate/deactivate.service.d.ts

@@ -0,0 +1,28 @@
+import { DialogService } from '@alauda/ui';
+import { TranslateService } from '@alauda-fe/dynamic-plugin-sdk';
+import { Location } from '@angular/common';
+import { OnDestroy } from '@angular/core';
+import { Router } from '@angular/router';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class InterceptDeactivateService implements OnDestroy {
+    private readonly location;
+    private readonly router;
+    private readonly dialog;
+    private readonly translate;
+    destroy$$: Subject<void>;
+    constructor(location: Location, router: Router, dialog: DialogService, translate: TranslateService);
+    ngOnDestroy(): void;
+    intercept({ title, content, context, errorFallback, }?: {
+        title?: string;
+        content?: string;
+        context?: unknown;
+        errorFallback?: boolean;
+    }): import("rxjs").Observable<boolean>;
+    back(escape?: boolean): Promise<void>;
+    forward(escape?: boolean): Promise<void>;
+    searchParamsToQueryParams(searchParams: URLSearchParams): Record<string, string | string[]>;
+    escape(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InterceptDeactivateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InterceptDeactivateService>;
+}

package/page-deactivate/index.d.ts

@@ -0,0 +1,3 @@
+export * from './deactivate.guard';
+export * from './deactivate.service';
+export * from './deactivate.directive';

package/pipes/calc.pipe.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class CalcPipe implements PipeTransform {
+    transform<T extends (...args: unknown[]) => unknown>(calc: T, ...args: Parameters<T>): ReturnType<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalcPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CalcPipe, "calc", true>;
+}

package/pipes/cron-human-readable.pipe.d.ts

@@ -0,0 +1,9 @@
+import { PipeTransform } from '@angular/core';
+import 'cronstrue/locales/zh_CN';
+import 'cronstrue/locales/en';
+import * as i0 from "@angular/core";
+export declare class CronHumanReadablePipe implements PipeTransform {
+    transform(cronString: string, locale: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CronHumanReadablePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CronHumanReadablePipe, "aclCronHumanReadable", false>;
+}

package/pipes/crontab-next.pipe.d.ts

@@ -0,0 +1,18 @@
+import { TimeService } from '@alauda-fe/dynamic-plugin-sdk';
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class CrontabNextPipe implements PipeTransform {
+    private readonly time;
+    constructor(time: TimeService);
+    transform(rule: string, step?: number, { utc, showUtc, format, tz, formatTz, showLocalTz, parseInCurrentTz, }?: {
+        utc?: boolean;
+        showUtc?: boolean;
+        format?: string;
+        tz?: string;
+        formatTz?: string;
+        showLocalTz?: boolean;
+        parseInCurrentTz?: boolean;
+    }): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CrontabNextPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CrontabNextPipe, "aclCrontabNext", true>;
+}

package/pipes/duration.pipe.d.ts

@@ -0,0 +1,10 @@
+import { TranslateService } from '@alauda-fe/dynamic-plugin-sdk';
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class DurationPipe implements PipeTransform {
+    private readonly translate;
+    constructor(translate: TranslateService);
+    transform(ms: any): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DurationPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DurationPipe, "aclDuration", true>;
+}

package/pipes/field-not-available.pipe.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const FIELD_NOT_AVAILABLE_PLACEHOLDER = "-";
+export declare const isFieldNotAvailable: (field: unknown) => boolean;
+export declare class FieldNotAvailablePipe implements PipeTransform {
+    transform(field: unknown): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FieldNotAvailablePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FieldNotAvailablePipe, "aclFieldNotAvailable", true>;
+}

package/pipes/img-header.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ImgHeaderPipe implements PipeTransform {
+    transform(value: string, prefix?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImgHeaderPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ImgHeaderPipe, "aclImageHeader", true>;
+}

package/pipes/img-theme.pipe.d.ts

@@ -0,0 +1,13 @@
+import { ThemeService } from '@alauda/ui';
+import { ChangeDetectorRef, OnDestroy, PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ImgThemePipe implements PipeTransform, OnDestroy {
+    private readonly theme;
+    private readonly cdr;
+    private readonly destroy$$;
+    constructor(theme: ThemeService, cdr: ChangeDetectorRef);
+    transform(value: string): string;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImgThemePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ImgThemePipe, "aclImageTheme", true>;
+}

package/pipes/index.d.ts

@@ -0,0 +1,18 @@
+export * from './crontab-next.pipe';
+export * from './field-not-available.pipe';
+export * from './img-header.pipe';
+export * from './img-theme.pipe';
+export * from './keyvalue.pipe';
+export * from './safe.pipe';
+export * from './sanitize.pipe';
+export * from './time.pipe';
+export * from './page-env.pipe';
+export * from './marked.pipe';
+export * from './parse-json-translate.pipe';
+export * from './timezone-display.pipe';
+export * from './cron-human-readable.pipe';
+export { ParseJsonPipe } from './parse-json.pipe';
+export { MinimumFormatPipe } from './minimum-format.pipe';
+export * from './duration.pipe';
+export * from './pure.pipe';
+export * from './calc.pipe';

package/pipes/keyvalue.pipe.d.ts

@@ -0,0 +1,9 @@
+import { KeyValuePipe as _KeyValuePipe } from '@angular/common';
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const asIsComparator: (_a: unknown, _b: unknown) => number;
+export declare class KeyValuePipe extends _KeyValuePipe implements PipeTransform {
+    transform<K extends keyof any, V>(input: Record<K, V>): import("@angular/common").KeyValue<string, V>[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeyValuePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<KeyValuePipe, "aclKeyvalue", true>;
+}