@alauda-fe/common 1.0.0-next.0

package/license/license-error/component.d.ts

@@ -0,0 +1,33 @@
+import { Router } from '@angular/router';
+import { TranslateService } from '../../translate/public-api';
+import { LicenseService } from '../license.service';
+import { LicenseStatus } from '../license.type';
+import * as i0 from "@angular/core";
+export declare class LicenseErrorComponent {
+    private readonly router;
+    private readonly licenseService;
+    readonly translate: TranslateService;
+    readonly productName: string;
+    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";
+    };
+    errorStatus$: import("rxjs").Observable<LicenseStatus>;
+    LicenseStatus: typeof LicenseStatus;
+    constructor(router: Router, licenseService: LicenseService, translate: TranslateService, productName: string);
+    getErrorTitle(status: LicenseStatus): string;
+    getErrorContent(status: LicenseStatus, _locale?: string): string;
+    shouldShowImport(status: LicenseStatus): boolean;
+    getButtonText(status: LicenseStatus, _locale?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LicenseErrorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LicenseErrorComponent, "acl-license-error", never, {}, {}, never, ["*"], false, never>;
+}

package/license/license-error/module.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./component";
+import * as i2 from "../../page-scaffold/page/page.module";
+import * as i3 from "@angular/common";
+import * as i4 from "@alauda/ui";
+import * as i5 from "../../translate/translate.module";
+import * as i6 from "../../core/module";
+import * as i7 from "../../page-guard/module";
+export declare class LicenseErrorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LicenseErrorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LicenseErrorModule, [typeof i1.LicenseErrorComponent], [typeof i2.PageModule, typeof i3.CommonModule, typeof i4.ButtonModule, typeof i5.TranslateModule, typeof i6.CoreModule, typeof i7.PageGuardModule], [typeof i1.LicenseErrorComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LicenseErrorModule>;
+}

package/license/license.guard.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @packageDocumentation
+ * @module license
+ */
+import { InjectionToken } from '@angular/core';
+import { ActivatedRouteSnapshot, CanActivate, CanActivateChild, RouterStateSnapshot } from '@angular/router';
+import { SilentlyNavigateService } from '../core/services';
+import { LicenseService } from './license.service';
+import * as i0 from "@angular/core";
+export declare const DEFAULT_LICENSE_ERROR_URL = "license-error";
+export declare function defaultLicenseErrorUrlFactory(): string;
+export declare const LICENSE_ERROR_URL_TOKEN: InjectionToken<string>;
+export declare class LicenseGuardService implements CanActivate, CanActivateChild {
+    private readonly errorUrl;
+    private readonly emptyUrl;
+    private readonly silentlyNavigate;
+    private readonly licenseService;
+    constructor(errorUrl: string, emptyUrl: string, silentlyNavigate: SilentlyNavigateService, licenseService: LicenseService);
+    canActivate(_route: ActivatedRouteSnapshot, state: RouterStateSnapshot): import("rxjs").Observable<boolean>;
+    canActivateChild(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): import("rxjs").Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LicenseGuardService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LicenseGuardService>;
+}

package/license/license.service.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @packageDocumentation
+ * @module license
+ */
+import { HttpClient } from '@angular/common/http';
+import { InjectionToken } from '@angular/core';
+import { Observable } from 'rxjs';
+import { K8sUtilService } from '../core/public-api';
+import { LicenseProductName, LicenseStatus } from './license.type';
+import * as i0 from "@angular/core";
+export declare const LICENSE_PRODUCT_NAME_TOKEN: InjectionToken<LicenseProductName>;
+export declare class LicenseService {
+    private readonly productName;
+    private readonly http;
+    private readonly k8sUtil;
+    status$: Observable<LicenseStatus>;
+    constructor(productName: LicenseProductName, http: HttpClient, k8sUtil: K8sUtilService);
+    getStatus(): Observable<LicenseStatus>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LicenseService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LicenseService>;
+}

package/license/license.type.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @packageDocumentation
+ * @module license
+ */
+export declare enum LicenseStatus {
+    EXPIRED = "expired",
+    UNAUTHORIZED = "unauthorized",
+    AUTHORIZED = "authorized",
+    NO_PERMISSION = "no_permission",
+    INVALID = "invalid"
+}
+export declare enum LicenseProductName {
+    CONTAINER_PLATFORM = "Container Platform",
+    DEVOPS = "DevOps",
+    SERVICE_MESH = "Service Mesh",
+    MACHINE_LEARNING = "Machine Learning",
+    API_MANAGEMENT_PLATFORM = "API Management Platform",
+    DATA_SERVICES = "Data Services"
+}

package/license/public-api.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @packageDocumentation
+ * @module license
+ * @preferred
+ */
+export * from './license-api';
+export * from './license.guard';
+export * from './license.service';
+export * from './license.type';
+export * from './license-error/component';
+export * from './license-error/module';

package/metric-chart/common-chart.service.d.ts

@@ -0,0 +1,30 @@
+import { HttpClient } from '@angular/common/http';
+import { MatchUnitParams } from './helpers';
+import { Indicator, MetricApiParams, MetricResult } from './types';
+import * as i0 from "@angular/core";
+export declare class CommonChartService {
+    readonly http: HttpClient;
+    constructor(http: HttpClient);
+    requestChartData({ cluster, ...rest }: MetricApiParams, indicator: Indicator[]): import("rxjs").Observable<MetricResult[]>;
+    getPrometheusStatus(cluster?: string): import("rxjs").Observable<{
+        notDeployed: boolean;
+        abnormal: boolean;
+    }>;
+    handelChartData: (res: MetricResult[], indicator: Indicator[], dependOnData: boolean) => import("@alauda-fe/common").ChartData[];
+    adaptChartUnit(data: Array<{
+        data?: Array<{
+            x: number;
+            y: number;
+        }>;
+        values?: Array<{
+            x: number;
+            y: number;
+        }>;
+    }>, adaptUnitParams: boolean | MatchUnitParams): {
+        base: number;
+        exponent: number;
+        unit: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommonChartService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CommonChartService>;
+}

package/metric-chart/helpers.d.ts

@@ -0,0 +1,54 @@
+import { Dayjs, ManipulateType } from 'dayjs';
+import { PickerTimeRanges } from './types';
+export declare const BASE_UNITS: readonly ["K", "M", "G", "T", "P", "E"];
+export declare const MEMORY_UNITS: string[];
+export declare enum UnitType {
+    MEMORY = "memory",
+    CAPACITY = "capacity"
+}
+export interface MatchUnitParams {
+    base?: number;
+    threshold?: number;
+    unitType?: UnitType;
+    unitRange?: string[];
+    defaultPrefix?: boolean;
+    prefix?: string;
+    baseUnit?: string;
+    groups?: Array<{
+        base: number;
+        range: string[];
+    }>;
+}
+export declare const MATCH_UNIT_DEFAULT_BASE = 1024;
+export declare const UnitMap: {
+    [key: string]: readonly string[];
+};
+export declare const matchUnit: (value: number, params?: MatchUnitParams) => {
+    unit: string;
+    base: number;
+    exponent: number;
+};
+export declare const adaptUnit: (seriesOrMetrics: Array<{
+    data?: Array<{
+        x: number;
+        y: number;
+    }>;
+    values?: Array<{
+        x: number;
+        y: number;
+    }>;
+}>, params?: MatchUnitParams) => {
+    unit: string;
+    base: number;
+    exponent: number;
+};
+export declare function getTimeValueOf(value: string): number;
+export declare const CHART_DATA_FORMAT: string;
+export declare const getTimeRanges: (value: number, unit: ManipulateType) => {
+    start: () => string;
+    end: () => string;
+    startTime: () => number;
+    endTime: () => number;
+};
+export declare function dateTimeRounding(value: number | Dayjs): string;
+export declare const PICKER_TIME_RANGES: PickerTimeRanges[];

package/metric-chart/metric-chart.component.d.ts

@@ -0,0 +1,115 @@
+import { TooltipContext } from '@alauda/chart';
+import { ChangeDetectorRef, EventEmitter, OnInit, TemplateRef } from '@angular/core';
+import { CurveFactory, CurveFactoryLineOnly } from 'd3';
+import { Observable, Subject, BehaviorSubject } from 'rxjs';
+import { Chart, TooltipValue } from 'zz-chart';
+import { AreaPosition, ContextItem } from '../chart/public-api';
+import { StringMap } from '../core';
+import { ChartData, ChartDataItem, ChartStatus, XPlotLines } from '../view-chart/public-api';
+import { CommonChartService } from './common-chart.service';
+import { MatchUnitParams } from './helpers';
+import { Indicator, MetricApiParams, MetricResult } from './types';
+import * as i0 from "@angular/core";
+export declare class MetricChartComponent implements OnInit {
+    private readonly service;
+    private readonly cdr;
+    contextCallbackFunction: (context: Chart) => void;
+    backgroundColor: string;
+    hideHeader: boolean;
+    title: string | TemplateRef<unknown>;
+    hideTitle: boolean;
+    chartType: 'line' | 'area' | 'bar' | 'point' | 'stat';
+    titleDescription: string | TemplateRef<unknown>;
+    titleDescriptionContext: StringMap;
+    unit: string;
+    tooltipAppendToBody: boolean;
+    get overflow(): "" | "unset";
+    unit$: Observable<string>;
+    indicator: Indicator[];
+    gridOffsetTop: number;
+    yAxisMinStep?: number;
+    rotated: boolean;
+    barType: 'standard' | 'stacked';
+    indicator$: Observable<Indicator[]>;
+    metricApiParams: MetricApiParams;
+    metricApiParams$: Observable<MetricApiParams>;
+    tooltipPointNameTemplate: TemplateRef<unknown>;
+    tooltipPointTemplate: TemplateRef<unknown>;
+    legendTemplate: TemplateRef<unknown> | string;
+    legendSelectAllOperation: boolean;
+    legendSelectAllName: string;
+    tooltipHide: boolean;
+    tooltipPointFormat: (d: ContextItem) => number | string;
+    tooltipPointTemplateContext: {
+        [key: string]: any;
+    };
+    tooltipColumnLayout: boolean;
+    hideLegend: boolean;
+    tooltipAutoSort: boolean;
+    tooltipSortMethod: (a: TooltipValue, b: TooltipValue) => number;
+    hideTooltipUnit: boolean;
+    leftOperation: TemplateRef<unknown>;
+    leftOperationContext: StringMap;
+    rightOperation: TemplateRef<unknown>;
+    mode: 'card' | 'default';
+    adaptUnit: boolean | MatchUnitParams;
+    adaptUnit$: Observable<boolean | MatchUnitParams>;
+    percent: boolean;
+    percent$: Observable<boolean>;
+    dependOnData: boolean;
+    customNoDataTitle: TemplateRef<unknown> | string;
+    dataFormat: (d: MetricResult[], indicator: Indicator[]) => ChartData[];
+    customSeries: MetricResult[];
+    customSeries$: Observable<MetricResult[]>;
+    isCustomSeries: boolean;
+    series$: Observable<ChartData[]>;
+    chartStatus: ChartStatus;
+    chartStatus$: Observable<ChartStatus>;
+    tooltipTranslation: boolean;
+    xPlotLines: XPlotLines;
+    yPlotLines: TooltipContext;
+    yPlotLinesTooltip: TemplateRef<unknown>;
+    yPlotLinesTooltipContext: StringMap;
+    yPlotLinesHide: boolean;
+    enableZoom: boolean;
+    stepLine: boolean;
+    tooltipTitleTemplate: TemplateRef<unknown>;
+    yAccessor: (d: ChartDataItem) => number;
+    curveType: CurveFactory | CurveFactoryLineOnly;
+    mouseUpEvent: EventEmitter<AreaPosition>;
+    markClickEvent: EventEmitter<TooltipContext>;
+    refreshEvent: EventEmitter<any>;
+    dataCompleted: EventEmitter<void>;
+    reload$: BehaviorSubject<any>;
+    _chartStatus$$: Subject<ChartStatus>;
+    _status: ChartStatus;
+    status$: Observable<{
+        loading?: boolean;
+        noData?: boolean;
+        failed?: boolean;
+        noLegend?: boolean;
+    }>;
+    noData: boolean;
+    dateAxisLabelFormats: string;
+    dateXAxisLabelFormats: string;
+    get xAccessor(): (d: ChartDataItem<{
+        x: number;
+        y: number;
+    }>) => number;
+    yAccessor$: Observable<(d: ChartDataItem<{
+        x: number;
+        y: number;
+    }>) => number>;
+    _cacheTime: MetricApiParams;
+    private chartParams;
+    constructor(service: CommonChartService, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    defaultSeries$: Observable<MetricResult[]>;
+    handleTimeParams(): void;
+    handleMetricDataPipe(): import("rxjs").UnaryFunction<Observable<unknown>, Observable<ChartData[]>>;
+    refresh(): void;
+    private handelChartStatus;
+    private handleDateAxisLabelFormats;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetricChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MetricChartComponent, "acl-metric-chart", never, { "contextCallbackFunction": { "alias": "contextCallbackFunction"; "required": false; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; }; "hideHeader": { "alias": "hideHeader"; "required": false; }; "title": { "alias": "title"; "required": false; }; "hideTitle": { "alias": "hideTitle"; "required": false; }; "chartType": { "alias": "chartType"; "required": false; }; "titleDescription": { "alias": "titleDescription"; "required": false; }; "titleDescriptionContext": { "alias": "titleDescriptionContext"; "required": false; }; "unit": { "alias": "unit"; "required": false; }; "tooltipAppendToBody": { "alias": "tooltipAppendToBody"; "required": false; }; "indicator": { "alias": "indicator"; "required": false; }; "gridOffsetTop": { "alias": "gridOffsetTop"; "required": false; }; "yAxisMinStep": { "alias": "yAxisMinStep"; "required": false; }; "rotated": { "alias": "rotated"; "required": false; }; "barType": { "alias": "barType"; "required": false; }; "metricApiParams": { "alias": "metricApiParams"; "required": false; }; "tooltipPointNameTemplate": { "alias": "tooltipPointNameTemplate"; "required": false; }; "tooltipPointTemplate": { "alias": "tooltipPointTemplate"; "required": false; }; "legendTemplate": { "alias": "legendTemplate"; "required": false; }; "legendSelectAllOperation": { "alias": "legendSelectAllOperation"; "required": false; }; "legendSelectAllName": { "alias": "legendSelectAllName"; "required": false; }; "tooltipHide": { "alias": "tooltipHide"; "required": false; }; "tooltipPointFormat": { "alias": "tooltipPointFormat"; "required": false; }; "tooltipPointTemplateContext": { "alias": "tooltipPointTemplateContext"; "required": false; }; "tooltipColumnLayout": { "alias": "tooltipColumnLayout"; "required": false; }; "hideLegend": { "alias": "hideLegend"; "required": false; }; "tooltipAutoSort": { "alias": "tooltipAutoSort"; "required": false; }; "tooltipSortMethod": { "alias": "tooltipSortMethod"; "required": false; }; "hideTooltipUnit": { "alias": "hideTooltipUnit"; "required": false; }; "leftOperation": { "alias": "leftOperation"; "required": false; }; "leftOperationContext": { "alias": "leftOperationContext"; "required": false; }; "rightOperation": { "alias": "rightOperation"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "adaptUnit": { "alias": "adaptUnit"; "required": false; }; "percent": { "alias": "percent"; "required": false; }; "dependOnData": { "alias": "dependOnData"; "required": false; }; "customNoDataTitle": { "alias": "customNoDataTitle"; "required": false; }; "dataFormat": { "alias": "dataFormat"; "required": false; }; "customSeries": { "alias": "customSeries"; "required": false; }; "isCustomSeries": { "alias": "isCustomSeries"; "required": false; }; "chartStatus": { "alias": "chartStatus"; "required": false; }; "tooltipTranslation": { "alias": "tooltipTranslation"; "required": false; }; "xPlotLines": { "alias": "xPlotLines"; "required": false; }; "yPlotLines": { "alias": "yPlotLines"; "required": false; }; "yPlotLinesTooltip": { "alias": "yPlotLinesTooltip"; "required": false; }; "yPlotLinesTooltipContext": { "alias": "yPlotLinesTooltipContext"; "required": false; }; "yPlotLinesHide": { "alias": "yPlotLinesHide"; "required": false; }; "enableZoom": { "alias": "enableZoom"; "required": false; }; "stepLine": { "alias": "stepLine"; "required": false; }; "tooltipTitleTemplate": { "alias": "tooltipTitleTemplate"; "required": false; }; "yAccessor": { "alias": "yAccessor"; "required": false; }; "curveType": { "alias": "curveType"; "required": false; }; }, { "mouseUpEvent": "mouseUpEvent"; "markClickEvent": "markClickEvent"; "refreshEvent": "refreshEvent"; "dataCompleted": "dataCompleted"; }, never, never, false, never>;
+}

package/metric-chart/metric-chart.module.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./metric-chart.component";
+import * as i2 from "@angular/common";
+import * as i3 from "../view-zchart/view-zchart.module";
+import * as i4 from "../translate/translate.module";
+import * as i5 from "@alauda/ui";
+import * as i6 from "@angular/forms";
+import * as i7 from "../widget/widget.module";
+import * as i8 from "./metric-time-pick";
+export declare class MetricChartModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetricChartModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MetricChartModule, [typeof i1.MetricChartComponent], [typeof i2.CommonModule, typeof i3.ViewZChartModule, typeof i4.TranslateModule, typeof i5.SelectModule, typeof i6.FormsModule, typeof i5.IconModule, typeof i7.WidgetModule, typeof i8.MetricTimePickComponent], [typeof i1.MetricChartComponent, typeof i8.MetricTimePickComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MetricChartModule>;
+}

package/metric-chart/metric-time-pick.d.ts

@@ -0,0 +1,12 @@
+import { EventEmitter } from '@angular/core';
+import { PickerTimeRanges } from './types';
+import * as i0 from "@angular/core";
+export declare class MetricTimePickComponent {
+    icon: boolean;
+    time: PickerTimeRanges;
+    timeRange: PickerTimeRanges[];
+    timeSelected: EventEmitter<PickerTimeRanges>;
+    changeTime(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetricTimePickComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MetricTimePickComponent, "acl-metric-time-pick", never, { "icon": { "alias": "icon"; "required": false; }; "time": { "alias": "time"; "required": false; }; "timeRange": { "alias": "timeRange"; "required": false; }; }, { "timeSelected": "timeSelected"; }, never, never, true, never>;
+}

package/metric-chart/public-api.d.ts

@@ -0,0 +1,13 @@
+/**
+ * [[include:metric-chart/README.md]]
+ * @module view-chart
+ * @preferred
+ */
+export * from './common-chart.service';
+export * from './helpers';
+export * from './metric-chart.component';
+export * from './metric-chart.module';
+export * from './metric-time-pick';
+export * from './types';
+export * from './utils';
+export * from './range-util';

package/metric-chart/range-util.d.ts

@@ -0,0 +1 @@
+export declare function roundInterval(start: number, end: number): number;

package/metric-chart/types.d.ts

@@ -0,0 +1,69 @@
+import { StringMap } from '../core';
+export interface MetricApiParams {
+    start?: number;
+    end?: number;
+    step?: number;
+    cluster?: string;
+    point?: number;
+}
+export interface Indicator {
+    id: string;
+    color?: string;
+    indicator: string;
+    name?: string;
+    legend?: string;
+    metricSourceKey?: keyof StringMap;
+    variables?: StringMap;
+    aggregator?: string;
+    level?: string;
+    range?: number;
+    labels?: MetricLabel[];
+    group_by?: string;
+}
+export interface MetricLabel {
+    type?: string;
+    name: string;
+    value: string;
+}
+export interface MetricResult {
+    id: string;
+    resultType: string;
+    result?: Metric[];
+}
+export interface Metric {
+    metric?: StringMap;
+    values?: Array<[number, string]>;
+    value?: [number, string];
+}
+export interface PickerTimeRanges {
+    name: string;
+    start?: () => string;
+    end?: () => string;
+    startTime?: () => number;
+    endTime?: () => number;
+    step?: number;
+    zoomStep?: number;
+}
+export interface ExpressionItem {
+    id?: string;
+    value?: string;
+    indicator?: string;
+    variables?: StringMap;
+    name?: string;
+    color?: string;
+}
+export interface MetricQueryItem {
+    aggregator?: string;
+    indicator?: string;
+    variables?: StringMap;
+    level?: string;
+    range?: number;
+    labels?: MetricLabels[];
+    group_by?: string;
+    id?: string;
+}
+export interface MetricLabels {
+    type?: string;
+    name: string;
+    value: string;
+}

package/metric-chart/utils.d.ts

@@ -0,0 +1,86 @@
+import { StringMap } from '../core';
+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>;
+}