@alauda-fe/common 1.0.0-hotfix-znx-3.16.1-1

package/metric-chart/utils.d.ts

@@ -0,0 +1,86 @@
+import { StringMap } from '../core/public-api';
+import { ChartData, ChartDataItem } from '../view-chart/public-api';
+import { ExpressionItem, Indicator, MetricApiParams, MetricQueryItem, MetricResult } from './types';
+export declare const CHART_LIMIT_MAX_UNIT_VALUE = 800;
+export declare function dependOnIndicatorSeries(res: MetricResult[], indicator: Indicator[]): ChartData[];
+export declare function dependOnDataSeries(res: MetricResult[], indicators: Indicator[]): ChartData[];
+export declare function getMetricName(metricKey: string, metric: StringMap): string;
+export declare function fillNullChartData({ start, end, step }: MetricApiParams, res?: Array<ChartDataItem<{
+    x: number;
+    y: number;
+}>>, stepLine?: boolean): any[];
+export declare function unitDealWith(data: MetricResult[]): boolean;
+export declare function checkInterval(time: MetricApiParams, cacheTime: MetricApiParams): boolean;
+export declare const ChartUnitType: {
+    readonly CPU: "cpu";
+    readonly MEMORY: "memory";
+    readonly TIME: "time";
+    readonly MEASURE: "measure";
+    readonly Rate: "rate";
+};
+export type ChartUnitType = (typeof ChartUnitType)[keyof typeof ChartUnitType];
+export declare const CHART_UNIT_MAP: {
+    cpu: {
+        medium: {
+            value: number;
+            unit: string;
+        };
+        big: {
+            value: number;
+            unit: string;
+        };
+    };
+    memory: {
+        medium: {
+            value: number;
+            unit: string;
+        };
+        big: {
+            value: number;
+            unit: string;
+        };
+    };
+    time: {
+        medium: {
+            value: number;
+            unit: string;
+        };
+        big: {
+            value: number;
+            unit: string;
+        };
+    };
+    measure: {
+        medium: {
+            value: number;
+            unit: string;
+        };
+        big: {
+            value: number;
+            unit: string;
+        };
+    };
+    rate: {
+        medium: {
+            value: number;
+            unit: string;
+        };
+        big: {
+            value: number;
+            unit: string;
+        };
+    };
+};
+export declare function generateMetricQueryParams({ id, value, }: ExpressionItem): MetricQueryItem;
+export declare function generateMetricQuery(expression: ExpressionItem[]): MetricQueryItem[];
+export declare function handleChartUnit(metrics: MetricResult[], type: ChartUnitType): {
+    unit: string;
+    handleCb: (value: number) => number;
+    dealWith: true;
+} | {
+    dealWith: boolean;
+    value: number;
+    unit: string;
+    handleCb?: undefined;
+};
+export declare function hasNoData(res: ChartData[]): boolean;

package/multi-search/action-input/component.d.ts

@@ -0,0 +1,119 @@
+import { TooltipDirective, InputComponent } from '@alauda/ui';
+import { EventEmitter, Injector, OnDestroy } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { BaseResourceFormComponent } from 'ng-resource-form-util';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { MultiSearchComponent } from '../form/component';
+import { SearchConditionConfig, SearchConditionModel, MultiSearchOption } from '../types';
+import * as i0 from "@angular/core";
+export declare class MultiSearchActionInputComponent extends BaseResourceFormComponent<SearchConditionModel> implements OnDestroy {
+    injector: Injector;
+    private readonly multiSearch;
+    placeholder: string;
+    conditionCreatable: boolean;
+    isEditing: boolean;
+    hidden: boolean;
+    hidden$: Observable<boolean>;
+    conditionConfig: SearchConditionConfig[];
+    conditionConfig$: Observable<SearchConditionConfig[]>;
+    existingConditions: SearchConditionModel[];
+    existingConditions$: Observable<SearchConditionModel[]>;
+    completed: EventEmitter<{
+        activeCondition: SearchConditionModel;
+        toContinue?: boolean;
+        manualFocus?: boolean;
+    }>;
+    editing: EventEmitter<void>;
+    delete: EventEmitter<void>;
+    search: EventEmitter<void>;
+    inputRef: InputComponent;
+    toolTipRef: TooltipDirective;
+    get hiddenState(): boolean;
+    _conditionsModel: string;
+    get conditionsModel(): string;
+    set conditionsModel(v: string);
+    conditionsModel$$: BehaviorSubject<string>;
+    hasFilteredConditions$: Observable<boolean>;
+    conditionsShouldShow$: Observable<string | boolean>;
+    normalConditionsResource$: Observable<SearchConditionConfig[]>;
+    normalConditions$: Observable<SearchConditionConfig[]>;
+    groupConditionsResource$: Observable<{
+        group: string;
+        member: SearchConditionConfig[];
+    }[]>;
+    groupConditions$: Observable<{
+        group: string;
+        member: SearchConditionConfig[];
+    }[]>;
+    hasFilteredValues: (activeCondition: SearchConditionModel, model: string, isMulti?: boolean) => boolean;
+    getNormalValues: (activeCondition: SearchConditionModel, model: string, isMulti?: boolean) => MultiSearchOption[];
+    getValuesGroup: (activeCondition: SearchConditionModel, model: string, isMulti: boolean) => {
+        group: string;
+        member: MultiSearchOption[];
+    }[];
+    valuesFilter(conditions: MultiSearchOption[], condition: MultiSearchOption, separator: string, isMulti?: boolean): boolean;
+    get isConditionSelecting(): boolean;
+    get isOperatorSelecting(): boolean;
+    get isValueSelecting(): string;
+    get isInitialized(): boolean;
+    get isOperationComplete(): MultiSearchOption;
+    get isSelectAll(): boolean;
+    get isIndeterminate(): boolean;
+    get inputElement(): HTMLInputElement;
+    get optionElements(): NodeListOf<HTMLDivElement>;
+    arrowCursor: number;
+    MAX_SAFE_INTEGER: number;
+    DEFAULT_OPERATOR: string;
+    DROPDOWN_ITEM_CLASS: string;
+    constructor(injector: Injector, multiSearch: MultiSearchComponent);
+    private resolveHideSync;
+    private resolveFormModelChangeSync;
+    private conditionSync;
+    private valuesSync;
+    createForm(): FormControl<SearchConditionModel>;
+    adaptResourceModel(resource: SearchConditionModel): SearchConditionModel;
+    private initModel;
+    selectActiveCondition(conditionConfig: SearchConditionConfig): void;
+    setConditionByModel(): void;
+    selectActiveOperator(operator: string): void;
+    selectValue(condition: MultiSearchOption, isMulti?: boolean): void;
+    private selectMultiValue;
+    selectAllClick: import("lodash").DebouncedFunc<() => void>;
+    private selectAllValues;
+    private deselectAllValues;
+    activeConditionClick(): void;
+    activeOperatorClick(): void;
+    activeValueClick(): void;
+    private setActiveOperator;
+    private setValues;
+    private clearActiveCondition;
+    private changeToEditing;
+    inputFocus(): void;
+    inputKeydown(e: KeyboardEvent): void;
+    private changeToEditingIfNeed;
+    private resolveTabEvent;
+    private resolveArrowEvent;
+    private resolveDeleteEvent;
+    private resolveEnterEvent;
+    private deleteSelf;
+    private resetArrowCursor;
+    manualFocus(silence?: boolean): void;
+    manualBlur(): void;
+    private refreshDropdown;
+    private refreshCursor;
+    toolTipHide(): void;
+    toolTipShow(): void;
+    ifComplete(toContinue?: boolean, manualFocus?: boolean): boolean;
+    _complete(activeCondition: SearchConditionModel, toContinue?: boolean, manualFocus?: boolean): void;
+    private conditionFilterByExists;
+    private resolveGroup;
+    getConditionLabel(condition: SearchConditionModel): string;
+    private getSeparator;
+    getValueContent: (condition: SearchConditionModel) => string;
+    getValueLabel(value: MultiSearchOption): string;
+    private getMultiSearchVal;
+    isConditionSelected(current: string, conditionsModel: string): boolean;
+    isValueSelected: (current: string, conditionsModel: string, condition: SearchConditionModel) => boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiSearchActionInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MultiSearchActionInputComponent, "acl-multi-search-action-input", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "conditionCreatable": { "alias": "conditionCreatable"; "required": false; }; "isEditing": { "alias": "isEditing"; "required": false; }; "hidden": { "alias": "hidden"; "required": false; }; "conditionConfig": { "alias": "conditionConfig"; "required": false; }; "existingConditions": { "alias": "existingConditions"; "required": false; }; }, { "completed": "completed"; "editing": "editing"; "delete": "delete"; "search": "search"; }, never, never, true, never>;
+}

package/multi-search/form/component.d.ts

@@ -0,0 +1,63 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, OnDestroy } from '@angular/core';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { MultiSearchActionInputComponent } from '../action-input/component';
+import { MultiSearchTagsComponent } from '../multi-search-tags/component';
+import { SearchConditionConfig, SearchCondition, SearchConditionModel } from '../types';
+import * as i0 from "@angular/core";
+export declare const DEFAULT_OPERATOR: string;
+export declare class MultiSearchComponent implements OnDestroy {
+    protected readonly cdr: ChangeDetectorRef;
+    placeholder: string;
+    conditionCreatable: boolean;
+    conditions: SearchCondition[];
+    conditions$: Observable<SearchCondition[]>;
+    conditionConfig: SearchConditionConfig[];
+    conditionConfig$: Observable<SearchConditionConfig[]>;
+    search: EventEmitter<SearchCondition[]>;
+    conditionsChange: EventEmitter<SearchCondition[]>;
+    normalInputComponent: MultiSearchActionInputComponent;
+    tagsComponent: MultiSearchTagsComponent;
+    multiSearchRef: ElementRef;
+    addedCondition: SearchConditionModel;
+    focus$$: BehaviorSubject<boolean>;
+    destroy$$: Subject<void>;
+    actionScanner$$: Subject<(items: SearchConditionModel[]) => SearchConditionModel[]>;
+    existingConditions: SearchConditionModel[];
+    existingConditions$: Observable<SearchConditionModel[]>;
+    noEditingCondition: boolean;
+    noEditingCondition$: Observable<boolean>;
+    noDeletingCondition: boolean;
+    noDeletingCondition$: Observable<boolean>;
+    addedInputShouldHidden$: Observable<boolean>;
+    get inputComponent(): MultiSearchActionInputComponent;
+    CLEAR_ICON_CLASS: string;
+    SEARCH_ICON_CLASS: string;
+    constructor(cdr: ChangeDetectorRef);
+    private isSearchBtn;
+    private notActionElement;
+    private notTooltipContent;
+    private checkElement;
+    private manualComplete;
+    manualFocus(silence?: boolean): void;
+    setFocus(focus: boolean): void;
+    manualBlur(): void;
+    doSearch(): void;
+    clearConditions(): void;
+    removeCondition(condition: SearchConditionModel): void;
+    updateCondition(condition: SearchConditionModel, index: number): void;
+    addCondition(activeCondition: SearchConditionModel): void;
+    setConditionEditing(condition: SearchConditionModel): void;
+    setConditionDeleting(index?: number): void;
+    complete({ activeCondition, toContinue, manualFocus, index, }: {
+        activeCondition: SearchConditionModel;
+        toContinue?: boolean;
+        manualFocus?: boolean;
+        index?: number;
+    }): void;
+    private isGrammarCustomCondition;
+    private getConditionModel;
+    conditionInAction(condition: SearchConditionModel): boolean;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiSearchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MultiSearchComponent, "acl-multi-search", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "conditionCreatable": { "alias": "conditionCreatable"; "required": false; }; "conditions": { "alias": "conditions"; "required": false; }; "conditionConfig": { "alias": "conditionConfig"; "required": false; }; }, { "search": "search"; "conditionsChange": "conditionsChange"; }, never, never, true, never>;
+}

package/multi-search/multi-search-tags/component.d.ts

@@ -0,0 +1,26 @@
+import { EventEmitter } from '@angular/core';
+import { MultiSearchActionInputComponent } from '../action-input/component';
+import { SearchConditionConfig, SearchConditionModel } from '../types';
+import * as i0 from "@angular/core";
+export declare class MultiSearchTagsComponent {
+    placeholder: string;
+    conditionCreatable: boolean;
+    conditionConfig: SearchConditionConfig[];
+    existingConditions: SearchConditionModel[];
+    removeCondition: EventEmitter<SearchConditionModel>;
+    setConditionEditing: EventEmitter<SearchConditionModel>;
+    setConditionDeleting: EventEmitter<number>;
+    search: EventEmitter<void>;
+    completed: EventEmitter<{
+        activeCondition: SearchConditionModel;
+        toContinue: boolean;
+        manualFocus: boolean;
+        index?: number;
+    }>;
+    inputComponent: MultiSearchActionInputComponent;
+    conditionInAction(condition: SearchConditionModel): boolean;
+    getConditionLabel(condition: SearchConditionModel): string;
+    getValueContent(condition: SearchConditionModel): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiSearchTagsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MultiSearchTagsComponent, "acl-multi-search-tags", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "conditionCreatable": { "alias": "conditionCreatable"; "required": false; }; "conditionConfig": { "alias": "conditionConfig"; "required": false; }; "existingConditions": { "alias": "existingConditions"; "required": false; }; }, { "removeCondition": "removeCondition"; "setConditionEditing": "setConditionEditing"; "setConditionDeleting": "setConditionDeleting"; "search": "search"; "completed": "completed"; }, never, ["*"], true, never>;
+}

package/multi-search/public-api.d.ts

@@ -0,0 +1,4 @@
+export * from './utils';
+export * from './types';
+export * from './form/component';
+export * from './action-input/component';

package/multi-search/types.d.ts

@@ -0,0 +1,32 @@
+export interface SearchCondition {
+    condition: string;
+    operator?: string;
+    values?: string[];
+}
+export type SearchConditionModel = SearchConditionConfig & {
+    isEditing?: boolean;
+    isDeleting?: boolean;
+    actionModel?: SearchConditionModel;
+    operator?: string;
+    selectedValues?: MultiSearchOption[];
+};
+export type SearchConditionConfig = SearchTagConfig & {
+    isMulti?: boolean;
+    separator?: string;
+    operators?: string[];
+    allowSelectAll?: boolean;
+    condition: MultiSearchOption;
+    values?: MultiSearchOption[];
+};
+export interface SearchTagConfig {
+    tagClass?: string;
+    tagStyle?: {
+        [clazz: string]: any;
+    };
+    tagType?: 'primary' | 'success' | 'warning' | 'error' | 'info';
+}
+export interface MultiSearchOption {
+    label?: string;
+    value: string;
+    group?: string;
+}

package/multi-search/utils.d.ts

@@ -0,0 +1,24 @@
+import { SearchCondition } from './types';
+/**
+ * 将basic的conditions转换为advanced形式
+ * 如：
+ * [
+ *  {
+ *    condition: 'category1',
+ *    operator: '=',
+ *    values: ['con1', 'con2']
+ *  },
+ *  {
+ *    condition: 'category2',
+ *    operator: '!=',
+ *    values: ['con11']
+ *  },
+ *  {
+ *    condition: '!custom'
+ *  }
+ * ]
+ * 将会转化为：
+ * '[category1 = (con1,con2)],[category2 != (con11)],[!custom]'
+ */
+export declare function MultiSearchAdvanced(conditions: SearchCondition[]): string;
+export declare function MultiSearchBasic(advancedConditions: string): SearchCondition[];

package/mutable/element.d.ts

@@ -0,0 +1,10 @@
+import { ElementRef } from '@angular/core';
+/**
+ * To judge whether the parent element
+ */
+export declare const isSelfOrParent: (element: HTMLElement, target: HTMLElement) => boolean;
+/**
+ * Coerces an ElementRef or an Element into an element.
+ * Useful for APIs that can accept either a ref or the native element itself.
+ */
+export declare function coerceElement<T>(elementOrRef: ElementRef<T> | T): T;

package/mutable/mosaic/mosaic.component.d.ts

@@ -0,0 +1,32 @@
+import { Observable } from 'rxjs';
+import { DragRange, MutableOptions } from '../../public-api';
+import * as i0 from "@angular/core";
+export declare class MosaicComponent {
+    left: DragRange;
+    left$: Observable<DragRange>;
+    right: DragRange;
+    right$: Observable<DragRange>;
+    splitLocation: number;
+    mutableOptions$: Observable<MutableOptions>;
+    leftInset: {
+        top: string;
+        right: string;
+        bottom: string;
+        left: string;
+    };
+    rightInset: {
+        top: string;
+        right: string;
+        bottom: string;
+        left: string;
+    };
+    splitInset: {
+        top: string;
+        right: string;
+        bottom: string;
+        left: string;
+    };
+    drag(element: HTMLElement, root: HTMLDivElement): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MosaicComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MosaicComponent, "acl-mosaic", never, { "left": { "alias": "left"; "required": false; }; "right": { "alias": "right"; "required": false; }; "splitLocation": { "alias": "splitLocation"; "required": false; }; }, {}, never, ["[aclMosaicLeft]", "[aclMosaicRight]"], false, never>;
+}

package/mutable/mosaic/mosaic.directive.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+export declare class MosaicLeftDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MosaicLeftDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MosaicLeftDirective, "acl-mosaic[aclMosaicLeft]", never, {}, {}, never, never, false, never>;
+}
+export declare class MosaicRightDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MosaicRightDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MosaicRightDirective, "acl-mosaic[aclMosaicRight]", never, {}, {}, never, never, false, never>;
+}

package/mutable/mutable.directive.d.ts

@@ -0,0 +1,83 @@
+import { ElementRef, EventEmitter, QueryList } from '@angular/core';
+import { ResizeCursor } from './util';
+import * as i0 from "@angular/core";
+export type DragRange = number | string;
+export interface MutableOptions {
+    directions?: [boolean, boolean, boolean, boolean];
+    resizeThreshold?: number;
+    cursors?: {
+        move: string;
+    };
+    dragRange?: [DragRange, DragRange, DragRange, DragRange];
+}
+export declare const MUTABLE_BASIC_OPTIONS: MutableOptions;
+export interface Point {
+    x: number;
+    y: number;
+}
+export declare class DragHandleDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragHandleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DragHandleDirective, "[aclDragHandle]", never, {}, {}, never, never, false, never>;
+}
+export declare class MutableDirective {
+    private readonly el;
+    private computedOptions;
+    /** Allow for stretch shrink, the default is open */
+    aclResizable: boolean;
+    /** Allow for drag and drop, the default is open */
+    aclDraggable: boolean;
+    /** Define drag boundary, as body */
+    aclDragBoundary: string | ElementRef<HTMLElement> | HTMLElement;
+    set aclMutableOptions(options: MutableOptions);
+    /** In the process of the resize triggering events */
+    readonly aclOnResize: EventEmitter<HTMLElement>;
+    /** Drag in the process of the triggering event */
+    readonly aclOnDrag: EventEmitter<HTMLElement>;
+    /** Emits when the user start drag. */
+    readonly aclDragStarted: EventEmitter<HTMLElement>;
+    readonly aclDragEnded: EventEmitter<HTMLElement>;
+    /** Emits when the user start resize */
+    readonly aclResizeStarted: EventEmitter<HTMLElement>;
+    readonly aclResizeEnded: EventEmitter<HTMLElement>;
+    handles: QueryList<ElementRef>;
+    isDragging: boolean;
+    isResizingX: boolean;
+    isResizingY: boolean;
+    mousePoint: {
+        x: number;
+        y: number;
+    };
+    parentBorder: {
+        left: number;
+        top: number;
+    };
+    elementBorder: {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    };
+    element: HTMLElement;
+    private readonly _initCursor;
+    resizeCursor: ResizeCursor;
+    resizeInitXRight: number;
+    resizeInitYBottom: number;
+    onMouseDown(event: MouseEvent): void;
+    onMouseMove(event: MouseEvent): void;
+    onMouseUp(): void;
+    constructor(el: ElementRef<HTMLElement>);
+    /** Gets the boundary element, based on the `boundaryElement` value. */
+    private getBoundaryElement;
+    private ensureInParent;
+    dragElement(event: MouseEvent): void;
+    initDragging(event: MouseEvent): void;
+    setDragging(cursor: string, event: MouseEvent): void;
+    resizeElementX(event: MouseEvent): void;
+    resizeElementY(event: MouseEvent): void;
+    initResizing(event: MouseEvent): void;
+    setResizing(cursor: string, event: MouseEvent): void;
+    getMutableCursor(event: MouseEvent): string;
+    private isResizeOutOfBoundary;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MutableDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MutableDirective, "[aclMutable]", never, { "aclResizable": { "alias": "aclResizable"; "required": false; }; "aclDraggable": { "alias": "aclDraggable"; "required": false; }; "aclDragBoundary": { "alias": "aclDragBoundary"; "required": false; }; "aclMutableOptions": { "alias": "aclMutableOptions"; "required": false; }; }, { "aclOnResize": "aclOnResize"; "aclOnDrag": "aclOnDrag"; "aclDragStarted": "aclDragStarted"; "aclDragEnded": "aclDragEnded"; "aclResizeStarted": "aclResizeStarted"; "aclResizeEnded": "aclResizeEnded"; }, ["handles"], never, false, never>;
+}

package/mutable/mutable.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./mutable.directive";
+import * as i2 from "./mosaic/mosaic.directive";
+import * as i3 from "./mosaic/mosaic.component";
+import * as i4 from "@angular/common";
+export declare class MutableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MutableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MutableModule, [typeof i1.MutableDirective, typeof i2.MosaicRightDirective, typeof i2.MosaicLeftDirective, typeof i1.DragHandleDirective, typeof i3.MosaicComponent], [typeof i4.CommonModule], [typeof i1.MutableDirective, typeof i2.MosaicRightDirective, typeof i2.MosaicLeftDirective, typeof i3.MosaicComponent, typeof i1.DragHandleDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MutableModule>;
+}

package/mutable/public-api.d.ts

@@ -0,0 +1,5 @@
+export * from './mosaic/mosaic.component';
+export * from './mosaic/mosaic.directive';
+export * from './mutable.directive';
+export * from './mutable.module';
+export * from './util';

package/mutable/util.d.ts

@@ -0,0 +1,18 @@
+/**
+ * cursor style link https://developer.mozilla.org/zh-CN/docs/Web/CSS/cursor
+ */
+export type CursorX = 'e' | 'w';
+export type CursorY = 'n' | 's';
+export type Cursor = CursorX | CursorY | `${CursorY}${CursorX}`;
+export type ResizeCursor = `${Cursor}-resize`;
+/** 如果cursor存在类似 n-resize、ne-resize，都代表是top 方向 */
+export declare const isT: (cursor: ResizeCursor) => boolean;
+/** 是否是right */
+export declare const isR: (cursor: ResizeCursor) => boolean;
+/** 是否是bottom */
+export declare const isB: (cursor: ResizeCursor) => boolean;
+/** 是否是left */
+export declare const isL: (cursor: ResizeCursor) => boolean;
+export declare const toPx: (num: number) => string;
+export declare const toPercent: (num: number, base?: number) => string;
+export declare const toNumber: (str: string) => number;

package/notification/errors-mapper.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @packageDocumentation
+ * @module notification
+ */
+import { StringMap } from '../core/public-api';
+export declare const ZH_ERRORS: StringMap;
+export declare const DEFAULT_ZH_ERROR = "\u7F51\u7EDC\u9519\u8BEF";

package/notification/feedback-notification/component.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @packageDocumentation
+ * @module notification
+ */
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class FeedbackNotificationComponent {
+    primary: string;
+    secondary: string;
+    content?: string;
+    pre: boolean;
+    onPrimary: EventEmitter<void>;
+    onSecondary: EventEmitter<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FeedbackNotificationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FeedbackNotificationComponent, "ng-component", never, { "primary": { "alias": "primary"; "required": false; }; "secondary": { "alias": "secondary"; "required": false; }; "content": { "alias": "content"; "required": false; }; "pre": { "alias": "pre"; "required": false; }; }, { "onPrimary": "onPrimary"; "onSecondary": "onSecondary"; }, never, never, false, never>;
+}
+export type FeedbackNotificationProps = Partial<Pick<FeedbackNotificationComponent, 'primary' | 'secondary' | 'content' | 'pre'>>;

package/notification/helpers.d.ts

@@ -0,0 +1,2 @@
+import { Status } from '../core/public-api';
+export declare function isK8sErrorStatus(e: any): e is Status;

package/notification/notification-util.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./feedback-notification/component";
+import * as i2 from "../code/code.module";
+import * as i3 from "../translate/translate.module";
+import * as i4 from "@alauda/ui";
+export declare class NotificationUtilModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationUtilModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NotificationUtilModule, [typeof i1.FeedbackNotificationComponent], [typeof i2.CodeModule, typeof i3.TranslateModule, typeof i4.ButtonModule], [typeof i2.CodeModule, typeof i3.TranslateModule, typeof i4.ButtonModule, typeof i1.FeedbackNotificationComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NotificationUtilModule>;
+}

package/notification/notification-util.service.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @packageDocumentation
+ * @module notification
+ */
+import { DialogService, NotificationConfig, NotificationService } from '@alauda/ui';
+import { HttpErrorResponse, HttpRequest } from '@angular/common/http';
+import { Injector } from '@angular/core';
+import { Callback, Status } from '../core/public-api';
+import { TimeService } from '../core/services/public-api';
+import { FeedbackNotificationProps } from './feedback-notification/component';
+import * as i0 from "@angular/core";
+export interface NotificationHttpRequest<T = unknown> extends HttpRequest<T> {
+    requestAt?: number;
+}
+export type FeedbackNotificationPropsWithEvents = Omit<FeedbackNotificationProps, 'content' | 'primary' | 'secondary'> & Partial<{
+    content: unknown;
+    summary: unknown;
+    primary: string | true;
+    secondary: string | true;
+    onPrimary: Callback;
+    onSecondary: Callback;
+}>;
+export type FeedbackNotificationConfig = Omit<NotificationConfig, 'contentRef'>;
+export declare class NotificationUtilService {
+    private readonly injector;
+    private readonly dialog;
+    private readonly time;
+    private readonly notification;
+    constructor(injector: Injector, dialog: DialogService, time: TimeService, notification: NotificationService);
+    viewDetail(json: unknown, title?: string, notificationId?: string): void;
+    createFeedback(config: FeedbackNotificationConfig, { content, onPrimary, onSecondary, pre, primary, secondary, summary, }?: FeedbackNotificationPropsWithEvents): void;
+    private normalizeJson;
+    notify(status: Status): void;
+    notify(req: NotificationHttpRequest, res: HttpErrorResponse): Promise<void>;
+    private getResErrorMessage;
+    private getAllHeaders;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationUtilService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationUtilService>;
+}

package/notification/public-api.d.ts

@@ -0,0 +1,12 @@
+/**
+ * [[include:notification/README.md]]
+ * @module notification
+ * @preferred
+ */
+/** imports */
+export * from './errors-mapper';
+export * from './feedback-notification/component';
+export * from './helpers';
+export * from './notification-util.module';
+export * from './notification-util.service';
+export * from './resource-error.interceptor';

package/notification/resource-error.interceptor.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @packageDocumentation
+ * @module notification
+ */
+import { HttpErrorResponse, HttpHandler, HttpInterceptor } from '@angular/common/http';
+import { Status } from '../core/public-api';
+import { NotificationHttpRequest, NotificationUtilService } from './notification-util.service';
+import * as i0 from "@angular/core";
+export declare const WRITABLE_METHODS: readonly ["delete", "patch", "post", "put"];
+export type WritableMethod = (typeof WRITABLE_METHODS)[number];
+export interface StatusErrorResponse extends Status {
+    __origin__: HttpErrorResponse;
+}
+export declare class ResourceErrorInterceptor implements HttpInterceptor {
+    private readonly notificationUtil;
+    constructor(notificationUtil: NotificationUtilService);
+    intercept(req: NotificationHttpRequest, next: HttpHandler): import("rxjs").Observable<import("@angular/common/http").HttpEvent<any>>;
+    private notifyOnError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceErrorInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResourceErrorInterceptor>;
+}