@alauda-fe/common 1.0.0-next.0

package/page-guard/component/page-guard.type.d.ts

@@ -0,0 +1,86 @@
+/**
+ * @packageDocumentation
+ * @module page-guard
+ */
+import { ValueOf } from 'ts-essentials';
+export declare enum GuardStatus {
+    Pending = "pending",
+    Available = "available",
+    Unavailable = "unavailable"
+}
+export declare const Reason: {
+    readonly NotSupported: "notSupported";
+    readonly NoPermission: "noPermission";
+    readonly NotDeployed: "notDeployed";
+    readonly Abnormal: "abnormal";
+    readonly NoData: "noData";
+    readonly NoMessage: "noMessage";
+    readonly Disconnected: "disconnected";
+    readonly LicenseAbnormal: "licenseAbnormal";
+    readonly NetworkAbnormal: "networkAbnormal";
+    readonly NotFound: "notFound";
+    readonly NoAlarm: "noAlarm";
+};
+export type Reason = ValueOf<typeof Reason>;
+export declare const REASON_MAP: {
+    notSupported: {
+        src: string;
+        title: string;
+        description: string;
+    };
+    noPermission: {
+        src: string;
+        title: string;
+        description: string;
+    };
+    notDeployed: {
+        src: string;
+        title: string;
+        description: string;
+    };
+    abnormal: {
+        src: string;
+        title: string;
+        description: string;
+    };
+    noData: {
+        src: string;
+        title: string;
+        description: string;
+    };
+    noMessage: {
+        src: string;
+        title: string;
+        description: string;
+    };
+    disconnected: {
+        src: string;
+        title: string;
+        description: string;
+    };
+    licenseAbnormal: {
+        src: string;
+        title: string;
+        description: string;
+    };
+    networkAbnormal: {
+        src: string;
+        title: string;
+        description: string;
+    };
+    notFound: {
+        src: string;
+        title: string;
+        description: string;
+    };
+    noAlarm: {
+        src: string;
+        title: string;
+        description: string;
+    };
+};
+export declare const DEFAULT_REASON: {
+    src: string;
+    title: string;
+    description: string;
+};

package/page-guard/module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./component/component";
+import * as i2 from "./component/helper-directives";
+export declare class PageGuardModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageGuardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PageGuardModule, never, [typeof i1.PageGuardComponent, typeof i2.PageGuardContentDirective, typeof i2.PageGuardDescriptionDirective, typeof i2.PageGuardOperationDirective, typeof i2.PageGuardImageDirective], [typeof i1.PageGuardComponent, typeof i2.PageGuardContentDirective, typeof i2.PageGuardDescriptionDirective, typeof i2.PageGuardOperationDirective, typeof i2.PageGuardImageDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PageGuardModule>;
+}

package/page-guard/public-api.d.ts

@@ -0,0 +1,10 @@
+/**
+ * [[include:page-guard/README.md]]
+ * @module page-guard
+ * @preferred
+ */
+/** imports */
+export * from './component/component';
+export * from './component/helper-directives';
+export * from './component/page-guard.type';
+export * from './module';

package/page-scaffold/index.d.ts

@@ -0,0 +1,4 @@
+export * from './navigation';
+export * from './page';
+export * from './page-header';
+export * from './module';

package/page-scaffold/module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "../core/module";
+import * as i2 from "./navigation/module";
+import * as i3 from "./page/page.module";
+import * as i4 from "./page-header/module";
+export declare class PageScaffoldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageScaffoldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PageScaffoldModule, never, [typeof i1.CoreModule, typeof i2.NavigationModule, typeof i3.PageModule, typeof i4.PageHeaderModule], [typeof i1.CoreModule, typeof i2.NavigationModule, typeof i3.PageModule, typeof i4.PageHeaderModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PageScaffoldModule>;
+}

package/page-scaffold/navigation/breadcrumb/breadcrumb-slot.directive.d.ts

@@ -0,0 +1,12 @@
+import { OnDestroy, OnInit, TemplateRef } from '@angular/core';
+import { BreadcrumbService } from './breadcrumb.service';
+import * as i0 from "@angular/core";
+export declare class BreadcrumbSlotDirective implements OnInit, OnDestroy {
+    private readonly template;
+    private readonly service;
+    constructor(template: TemplateRef<unknown>, service: BreadcrumbService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbSlotDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BreadcrumbSlotDirective, "[aclBreadcrumbSlot]", never, {}, {}, never, never, false, never>;
+}

package/page-scaffold/navigation/breadcrumb/breadcrumb.component.d.ts

@@ -0,0 +1,40 @@
+import { StringMap } from '@alauda/ui';
+import { ChangeDetectorRef, ElementRef, OnChanges, OnInit, SimpleChanges, TemplateRef } from '@angular/core';
+import { Router } from '@angular/router';
+import { NavGroupConfig, NavItemConfig } from '../nav-menu';
+import { BreadcrumbService, BreadcrumbTemplateState } from './breadcrumb.service';
+import * as i0 from "@angular/core";
+export declare class BreadcrumbComponent implements OnInit, OnChanges {
+    private readonly router;
+    private readonly cdr;
+    private readonly service;
+    configs: NavItemConfig[];
+    groups: NavGroupConfig[];
+    activatedKey: string;
+    _subItems: (rest: string[], lastRouteLink: Array<string | StringMap>) => Array<{
+        name: string;
+        translate?: boolean;
+        routerLink?: NavItemConfig['routerLink'];
+    }> | void;
+    iconRef: ElementRef<HTMLElement>;
+    activatedPath: NavItemConfig[];
+    customTemplateState: BreadcrumbTemplateState;
+    customTemplate: TemplateRef<unknown>;
+    private internalConfigs;
+    private url;
+    constructor(router: Router, cdr: ChangeDetectorRef, service: BreadcrumbService);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    isSameUrl(link: NavItemConfig['routerLink']): boolean;
+    subItems(): Array<{
+        name: string;
+        translate?: boolean;
+        routerLink?: NavItemConfig['routerLink'];
+    }>;
+    rootPath(): string;
+    private updateActivatedPath;
+    private restNode;
+    private linkToUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbComponent, "acl-breadcrumb", never, { "configs": { "alias": "configs"; "required": false; }; "groups": { "alias": "groups"; "required": false; }; "activatedKey": { "alias": "activatedKey"; "required": false; }; "_subItems": { "alias": "subItems"; "required": false; }; }, {}, never, never, false, never>;
+}

package/page-scaffold/navigation/breadcrumb/breadcrumb.service.d.ts

@@ -0,0 +1,13 @@
+import { TemplateRef } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class BreadcrumbService {
+    templateState$: ReplaySubject<BreadcrumbTemplateState>;
+    template: TemplateRef<unknown>;
+    prepareSlot(): void;
+    registerSlot(template: TemplateRef<unknown>): void;
+    unregisterSlot(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BreadcrumbService>;
+}
+export type BreadcrumbTemplateState = 'initialing' | 'ready' | 'destroyed';

package/page-scaffold/navigation/breadcrumb/index.d.ts

@@ -0,0 +1,4 @@
+export * from './breadcrumb-slot.directive';
+export * from './breadcrumb.component';
+export * from './breadcrumb.service';
+export * from './module';

package/page-scaffold/navigation/breadcrumb/module.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./breadcrumb-slot.directive";
+import * as i2 from "./breadcrumb.component";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/router";
+import * as i5 from "@alauda/ui";
+import * as i6 from "../../../translate/translate.module";
+import * as i7 from "../lottie-icons/module";
+export declare class BreadcrumbModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BreadcrumbModule, [typeof i1.BreadcrumbSlotDirective, typeof i2.BreadcrumbComponent], [typeof i3.CommonModule, typeof i4.RouterModule, typeof i5.BreadcrumbModule, typeof i6.TranslateModule, typeof i7.NavLottieIconModule], [typeof i5.BreadcrumbModule, typeof i1.BreadcrumbSlotDirective, typeof i2.BreadcrumbComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BreadcrumbModule>;
+}

package/page-scaffold/navigation/index.d.ts

@@ -0,0 +1,6 @@
+export * from './breadcrumb';
+export * from './lottie-icons';
+export * from './nav-menu';
+export * from './navconfig-loader';
+export * from './module';
+export * from './utils';

package/page-scaffold/navigation/lottie-icons/animation-data.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Record<string, any>;
+export default _default;

package/page-scaffold/navigation/lottie-icons/index.d.ts

@@ -0,0 +1,2 @@
+export * from './module';
+export * from './lottie-icon.directive';

package/page-scaffold/navigation/lottie-icons/lottie-icon.directive.d.ts

@@ -0,0 +1,24 @@
+import { ThemeService } from '@alauda/ui';
+import { ElementRef, EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { AnimationConfigWithData, AnimationItem } from 'lottie-web';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class NavLottieIconDirective implements OnInit, OnDestroy {
+    hostEl: ElementRef;
+    theme: ThemeService;
+    aniIns: AnimationItem;
+    animData: unknown;
+    animData$: Observable<unknown>;
+    animDataKey: string;
+    animDataKey$: Observable<string>;
+    aniConfig: AnimationConfigWithData;
+    frame?: number;
+    aniInit: EventEmitter<AnimationItem>;
+    private readonly destroy$$;
+    constructor(hostEl: ElementRef, theme: ThemeService);
+    ngOnInit(): void;
+    jumpFrame(frame?: number): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavLottieIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NavLottieIconDirective, "[aclNavLottieIcon],acl-nav-lottie-icon", never, { "animData": { "alias": "animData"; "required": false; }; "animDataKey": { "alias": "animDataKey"; "required": false; }; "aniConfig": { "alias": "aniConfig"; "required": false; }; "frame": { "alias": "frame"; "required": false; }; }, { "aniInit": "aniInit"; }, never, never, false, never>;
+}

package/page-scaffold/navigation/lottie-icons/module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./lottie-icon.directive";
+export declare class NavLottieIconModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavLottieIconModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NavLottieIconModule, [typeof i1.NavLottieIconDirective], never, [typeof i1.NavLottieIconDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NavLottieIconModule>;
+}

package/page-scaffold/navigation/lottie-icons/replace-lottie-colors.d.ts

@@ -0,0 +1 @@
+export declare function replaceLottieColorsByTheme(theme: string, lottieObj: any): any;

package/page-scaffold/navigation/module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./nav-menu/nav-menu.module";
+export declare class NavigationModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NavigationModule, never, [typeof i1.NavMenuModule], [typeof i1.NavMenuModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NavigationModule>;
+}

package/page-scaffold/navigation/nav-menu/index.d.ts

@@ -0,0 +1,3 @@
+export * from './nav-menu.component';
+export * from './nav-menu.module';
+export * from './nav-menu.types';

package/page-scaffold/navigation/nav-menu/nav-item-li/nav-item-li.component.d.ts

@@ -0,0 +1,52 @@
+import { Overlay } from '@angular/cdk/overlay';
+import { ChangeDetectorRef, OnDestroy, OnInit, Renderer2, TemplateRef, ViewContainerRef } from '@angular/core';
+import { AnimationItem } from 'lottie-web';
+import { Subject } from 'rxjs';
+import { NavMenuComponent } from '../nav-menu.component';
+import { NavItemConfig } from './../nav-menu.types';
+import * as i0 from "@angular/core";
+export declare class NavItemLiComponent implements OnInit, OnDestroy {
+    readonly navMenu: NavMenuComponent;
+    private readonly cdr;
+    private readonly overlay;
+    private readonly viewContainerRef;
+    private readonly renderer;
+    private _item;
+    private readonly item$$;
+    private paths;
+    private overlayIns;
+    overlayHovered: boolean;
+    overlayTriggerHovered: boolean;
+    private listeners;
+    get item(): NavItemConfig;
+    set item(val: NavItemConfig);
+    main: TemplateRef<any>;
+    depth: number;
+    destroy$$: Subject<void>;
+    depth$: import("rxjs").Observable<number>;
+    isActive$: import("rxjs").Observable<boolean>;
+    isExpanded$: import("rxjs").Observable<boolean>;
+    isFocusedRoot$: import("rxjs").Observable<boolean>;
+    snapshot: Record<string, any>;
+    iconAnim: AnimationItem;
+    animDataMap: Record<string, any>;
+    get hasSubItem(): boolean;
+    constructor(navMenu: NavMenuComponent, cdr: ChangeDetectorRef, overlay: Overlay, viewContainerRef: ViewContainerRef, renderer: Renderer2);
+    ngOnInit(): void;
+    playIcon(): void;
+    isExternal(url: string): boolean;
+    handleContentClicked(forceExpand: boolean): void;
+    openTooltip(event: MouseEvent): void;
+    bindOverlayHover(): void;
+    clearListeners(): void;
+    disposeOverlay(): void;
+    handleIconAnim(hover: boolean, $event: MouseEvent, fromTooltip: boolean): void;
+    disposeWithDelayCheck(): Promise<void>;
+    private findParentKey;
+    ngOnDestroy(): void;
+    aniInit(ins: AnimationItem, fromTooltip: boolean): void;
+    private resetIconAnim;
+    auiTooltipShowHandle(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavItemLiComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavItemLiComponent, "acl-nav-item-li", never, { "item": { "alias": "item"; "required": false; }; }, {}, never, never, false, never>;
+}

package/page-scaffold/navigation/nav-menu/nav-item-ul/nav-item-ul.component.d.ts

@@ -0,0 +1,10 @@
+import { NavGroupConfig, NavItemConfig } from './../nav-menu.types';
+import * as i0 from "@angular/core";
+export declare class NavItemUlComponent {
+    items: NavItemConfig[];
+    groups: NavGroupConfig[];
+    trackByKey(_: number, item: NavItemConfig): string;
+    trackByTitle(_: number, item: NavGroupConfig): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavItemUlComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavItemUlComponent, "acl-nav-item-ul", never, { "items": { "alias": "items"; "required": false; }; "groups": { "alias": "groups"; "required": false; }; }, {}, never, never, false, never>;
+}

package/page-scaffold/navigation/nav-menu/nav-menu.component.d.ts

@@ -0,0 +1,47 @@
+import { TooltipTrigger } from '@alauda/ui';
+import { OnInit, OnDestroy, AfterViewInit, ElementRef } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { IframeConfigService } from '../../..//iframe-config/config.service';
+import { PageComponent } from '../../page';
+import { NavGroupConfig, NavItemConfig } from './nav-menu.types';
+import * as i0 from "@angular/core";
+export declare class NavMenuComponent implements OnInit, OnDestroy, AfterViewInit {
+    private readonly pageCpt;
+    private readonly iframeConfigService;
+    private readonly expandedKey$$;
+    private readonly focusedRootKey$$;
+    activatedKey: string;
+    activatedKey$: Observable<string>;
+    isCollapse: boolean;
+    isCollapse$: Observable<boolean>;
+    triggerType: TooltipTrigger;
+    configs: NavItemConfig[];
+    configs$: Observable<NavItemConfig[]>;
+    groups: NavGroupConfig[];
+    groups$: Observable<NavGroupConfig[]>;
+    disableAniIcon: boolean;
+    container: ElementRef;
+    content: ElementRef;
+    filteredConfigs$: Observable<NavItemConfig[]>;
+    showShadow$: BehaviorSubject<boolean>;
+    isIntersecting: boolean;
+    items$: Observable<NavItemConfig[]>;
+    paths$: Observable<string[][]>;
+    activeKeys$: Observable<string[]>;
+    expandedKeys$: Observable<string[]>;
+    focusedRootKey$: Observable<string>;
+    constructor(pageCpt: PageComponent, iframeConfigService: IframeConfigService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    scroll(type: string): void;
+    private findPathByLastKey;
+    private getPaths;
+    expandedKeyChanged(key: string): void;
+    focusedRootKeyChange(key: string): void;
+    private readonly addSidenavAni;
+    toggleCollapse(): void;
+    updateCollapseClass(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavMenuComponent, "acl-nav-menu", never, { "activatedKey": { "alias": "activatedKey"; "required": false; }; "isCollapse": { "alias": "isCollapse"; "required": false; }; "triggerType": { "alias": "triggerType"; "required": false; }; "configs": { "alias": "configs"; "required": false; }; "groups": { "alias": "groups"; "required": false; }; "disableAniIcon": { "alias": "disableAniIcon"; "required": false; }; }, {}, never, never, false, never>;
+}

package/page-scaffold/navigation/nav-menu/nav-menu.module.d.ts

@@ -0,0 +1,16 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./nav-menu.component";
+import * as i2 from "./nav-item-ul/nav-item-ul.component";
+import * as i3 from "./nav-item-li/nav-item-li.component";
+import * as i4 from "@angular/common";
+import * as i5 from "@angular/cdk/scrolling";
+import * as i6 from "@alauda/ui";
+import * as i7 from "../../../core/module";
+import * as i8 from "@angular/router";
+import * as i9 from "../../../skeleton/module";
+import * as i10 from "../lottie-icons/module";
+export declare class NavMenuModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavMenuModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NavMenuModule, [typeof i1.NavMenuComponent, typeof i2.NavItemUlComponent, typeof i3.NavItemLiComponent], [typeof i4.CommonModule, typeof i5.ScrollingModule, typeof i6.IconModule, typeof i6.TooltipModule, typeof i7.CoreModule, typeof i8.RouterModule, typeof i9.SkeletonModule, typeof i10.NavLottieIconModule], [typeof i1.NavMenuComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NavMenuModule>;
+}

package/page-scaffold/navigation/nav-menu/nav-menu.types.d.ts

@@ -0,0 +1,21 @@
+import { StringMap } from './../../../core';
+export interface NavItemConfig {
+    name?: string;
+    label?: string;
+    key?: string;
+    href?: string;
+    icon?: string;
+    iconData?: string;
+    hidden?: boolean;
+    animJson?: string;
+    stage?: 'Alpha' | 'Beta';
+    divider?: boolean;
+    children?: NavItemConfig[];
+    routerLink?: Array<string | StringMap>;
+    routerLinkQueryParams?: StringMap;
+    [key: string]: any;
+}
+export interface NavGroupConfig {
+    title?: string;
+    items?: NavItemConfig[];
+}

package/page-scaffold/navigation/navconfig-loader/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * [[include:navconfig-loader/README.md]]
+ * @module navconfig-loader
+ * @preferred
+ */
+/** imports */
+export * from './navconfig-loader.service';

package/page-scaffold/navigation/navconfig-loader/navconfig-loader.service.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @packageDocumentation
+ * @module navconfig-loader
+ */
+import { NotificationService } from '@alauda/ui';
+import { HttpClient } from '@angular/common/http';
+import { InjectionToken } from '@angular/core';
+import { Observable } from 'rxjs';
+import { K8sApiService } from '../../../api/k8s-api.service';
+import { TranslateService } from '../../../translate/public-api';
+import { NavGroupConfig, NavItemConfig } from '../nav-menu';
+import * as i0 from "@angular/core";
+interface NavigationConfigConfigMapData {
+    buildIn: {
+        [name: string]: {
+            label: string;
+            hidden: boolean;
+        };
+    };
+    customs: Array<{
+        label: string;
+        icon?: string;
+        iconData?: string;
+        hidden: boolean;
+        href: string;
+    }>;
+}
+export declare const NAV_CONFIG_LOCAL_STORAGE_KEY: InjectionToken<string>;
+export type Nav = NavItemConfig | NavGroupConfig;
+export declare class NavConfigLoaderService {
+    private readonly http;
+    private readonly translate;
+    private readonly notification;
+    private readonly localStorageKey;
+    private readonly k8sApi;
+    private readonly cachedConfig;
+    constructor(http: HttpClient, translate: TranslateService, notification: NotificationService, localStorageKey: string, k8sApi: K8sApiService);
+    loadNavConfig(address: string): Observable<string>;
+    loadNavTree(address: string, cmConfigName: string, withGroup?: boolean): Observable<Nav[]>;
+    configTree(treeItemConfig: NavItemConfig[], config: NavigationConfigConfigMapData): import("../../../core").Tree[];
+    configTreeWithGroup(treeGroupConfig: NavGroupConfig[], config: NavigationConfigConfigMapData): {
+        title: string;
+        items: NavItemConfig[];
+    }[];
+    parseYaml(): import("rxjs").OperatorFunction<string, Nav[]>;
+    mapToAuiNav(withGroup?: boolean): import("rxjs").OperatorFunction<Nav[], Nav[]>;
+    /**
+     * @param name
+     * 加载左导航配置 todo: 添加文档链接
+     */
+    loadCmConfig(name: string): Observable<NavigationConfigConfigMapData>;
+    private buildLoadStream;
+    private readonly mapToAuiNavItem;
+    private toastParseError;
+    private localKey;
+    private setLocal;
+    private getLocal;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavConfigLoaderService, [null, null, null, { optional: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NavConfigLoaderService>;
+}
+export {};

package/page-scaffold/navigation/utils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @packageDocumentation
+ * @module navconfig-loader
+ */
+import { NavItemConfig } from './nav-menu/nav-menu.types';
+export declare const reduceNavTrees: <T extends import("../../core/utils/tree").Tree, R>(fn: import("../../core/utils/tree").TreeReducer<T, R>) => (seed: R) => (trees: T[]) => R;
+export declare const mapNavTrees: <T extends import("../../core/utils/tree").Tree, R extends import("../../core/utils/tree").Tree>(fn: import("../../core/utils/tree").TreeMapper<T, R>) => (trees: T[]) => R[];
+export declare const filterNavTrees: <T extends import("../../core/utils/tree").Tree>(fn: import("../../core/utils/tree").TreeFilter<T>) => (trees: T[]) => T[];
+export declare const findNavPath: <T extends import("../../core/utils/tree").Tree>(fn: import("../../core/utils/tree").TreeFilter<T>) => (trees: T[]) => T[];
+export declare const firstNavPath: <T extends import("../../core/utils/tree").Tree>(trees: T[]) => T[];
+export declare const filterEmptyNode: (trees: NavItemConfig[]) => NavItemConfig[];

package/page-scaffold/page/context.service.d.ts

@@ -0,0 +1,9 @@
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class PageContextService {
+    showToolbar$: BehaviorSubject<boolean>;
+    showToolbar(): void;
+    hideToolbar(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageContextService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PageContextService>;
+}

package/page-scaffold/page/helper-directives.d.ts

@@ -0,0 +1,30 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class PageHeaderDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PageHeaderDirective, "[aclPageHeader]", never, {}, {}, never, never, false, never>;
+}
+export declare class PageContentDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PageContentDirective, "[aclPageContent]", never, {}, {}, never, never, false, never>;
+}
+export declare class PageSiderDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageSiderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PageSiderDirective, "[aclPageSider]", never, {}, {}, never, never, false, never>;
+}
+export declare class PageToolbarDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageToolbarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PageToolbarDirective, "[aclPageToolbar]", never, {}, {}, never, never, false, never>;
+}
+export declare class PageHeaderAppendDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageHeaderAppendDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PageHeaderAppendDirective, "[aclPageHeaderAppend]", never, {}, {}, never, never, true, never>;
+}

package/page-scaffold/page/index.d.ts

@@ -0,0 +1,4 @@
+export * from './helper-directives';
+export * from './context.service';
+export * from './page.component';
+export * from './page.module';

package/page-scaffold/page/notices/maintenance.component.d.ts

@@ -0,0 +1,26 @@
+import { DialogService } from '@alauda/ui';
+import { OnDestroy, TemplateRef } from '@angular/core';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { K8sApiService } from '../../../api/k8s-api.service';
+import { AuthorizationStateService } from '../../../authorization/state.service';
+import { TranslateService } from '../../../translate/public-api';
+import { NoticeComponent } from './notice.component';
+import * as i0 from "@angular/core";
+export declare class MaintenanceComponent implements OnDestroy {
+    readonly notice: NoticeComponent;
+    private readonly k8sApi;
+    private readonly translate;
+    private readonly auth;
+    private readonly dialog;
+    maintenance: TemplateRef<any>;
+    announcement: TemplateRef<any>;
+    noticeId: string;
+    announcement$: BehaviorSubject<string>;
+    hasConfirm: boolean;
+    isPlatformRule$: import("rxjs").Observable<boolean>;
+    destroy$: Subject<void>;
+    constructor(notice: NoticeComponent, k8sApi: K8sApiService, translate: TranslateService, auth: AuthorizationStateService, dialog: DialogService);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MaintenanceComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MaintenanceComponent, "acl-page-header-notice-maintenance", never, {}, {}, never, never, true, never>;
+}

package/page-scaffold/page/notices/notice.component.d.ts

@@ -0,0 +1,22 @@
+import { InlineAlertType } from '@alauda/ui';
+import { ComponentType } from '@angular/cdk/portal';
+import { ChangeDetectorRef, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class NoticeComponent {
+    private readonly cdr;
+    pageHeaderAppend: ComponentType<any>;
+    messages: Message[];
+    constructor(cdr: ChangeDetectorRef);
+    open: (message: Message) => () => void;
+    close: (id?: string) => void;
+    iconMap(type: InlineAlertType): "check_circle_s" | "exclamation_circle_s" | "exclamation_triangle_s" | "info_circle_s";
+    static ɵfac: i0.ɵɵFactoryDeclaration<NoticeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NoticeComponent, "acl-page-notice", never, {}, {}, ["pageHeaderAppend"], never, true, never>;
+}
+export interface Message {
+    content: string;
+    id?: string;
+    suffix?: TemplateRef<any>;
+    type?: InlineAlertType;
+    closable?: boolean;
+}

package/page-scaffold/page/page.component.d.ts

@@ -0,0 +1,23 @@
+import { TemplateRef, ElementRef, AfterViewInit } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { IframeConfigService } from '../../iframe-config/config.service';
+import * as i0 from "@angular/core";
+export declare class PageComponent implements AfterViewInit {
+    private readonly iframeConfigService;
+    pageHeader: TemplateRef<any>;
+    pageContent: TemplateRef<any>;
+    pageSider: TemplateRef<any>;
+    pageToolbar: TemplateRef<any>;
+    header?: ElementRef<HTMLElement>;
+    private readonly classes;
+    classes$$: BehaviorSubject<Set<string>>;
+    showToolbar$: BehaviorSubject<boolean>;
+    isHideMenu: boolean;
+    isHideHeader: boolean;
+    constructor(iframeConfigService: IframeConfigService);
+    ngAfterViewInit(): void;
+    addClass(cls: string): void;
+    removeClass(cls: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PageComponent, "acl-page", never, {}, {}, ["pageHeader", "pageContent", "pageSider", "pageToolbar"], never, false, never>;
+}