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

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

@@ -0,0 +1,40 @@
+import { Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ResourceWriteParams } from '../api/types';
+import { ANNOTATIONS, KubernetesResource, StringMap } from '../core/public-api';
+import { K8sUtilService, LABELS } from '../core/services/k8s-util.service';
+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, }: {
+        type?: R;
+        cluster?: string;
+        resource: T;
+    }, validateMaxLength?: boolean): Observable<T>;
+    updateDescription<T extends KubernetesResource>({ type, cluster, resource, }: {
+        type?: R;
+        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/public-api.d.ts

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

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

@@ -0,0 +1,25 @@
+import { DialogRef } from '@alauda/ui';
+import { BehaviorSubject } from 'rxjs';
+import { K8sApiService } from '../../api/k8s-api.service';
+import { K8sUtilService, KubernetesResource, ResourceType } from '../../core/public-api';
+import * as i0 from "@angular/core";
+export declare class UpdateDescriptionDialogComponent<T extends KubernetesResource> {
+    private readonly dialogRef;
+    private readonly k8sApi;
+    private readonly k8sUtil;
+    data: {
+        type?: ResourceType;
+        cluster?: string;
+        resource: T;
+    };
+    description: string;
+    confirming$$: BehaviorSubject<boolean>;
+    constructor(dialogRef: DialogRef, k8sApi: K8sApiService<ResourceType>, k8sUtil: K8sUtilService, data: {
+        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 { BehaviorSubject } from 'rxjs';
+import { K8sApiService } from '../../api/public-api';
+import { K8sUtilService, KubernetesResource, ResourceType } from '../../core/public-api';
+import * as i0 from "@angular/core";
+export declare class UpdateDisplayNameDialogComponent<T extends KubernetesResource> {
+    private readonly dialogRef;
+    private readonly k8sApi;
+    private readonly k8sUtil;
+    data: {
+        type?: ResourceType;
+        cluster?: string;
+        resource: T;
+        validateMaxLength?: boolean;
+    };
+    displayName: string;
+    confirming$$: BehaviorSubject<boolean>;
+    constructor(dialogRef: DialogRef, k8sApi: K8sApiService<ResourceType>, k8sUtil: K8sUtilService, data: {
+        type?: ResourceType;
+        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,39 @@
+import { DialogRef, MessageService } from '@alauda/ui';
+import { OnDestroy, OnInit } from '@angular/core';
+import { ValidatorFn } from '@angular/forms';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { StringMap } from '../../core/public-api';
+import { TranslateService } from '../../translate/public-api';
+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/license/license-api.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @packageDocumentation
+ * @module license-api
+ */
+import { HttpClient } from '@angular/common/http';
+import { FeatureGate, FeatureGateEnterpriseSupport } from '../core/public-api';
+import * as i0 from "@angular/core";
+export declare const LICENSE_FEATURE_GATE: string;
+export declare function getResourceNum(resource?: Record<string, number>): number;
+export declare function formatProductName(productName: string): string;
+export declare class LicenseApiService {
+    private readonly http;
+    constructor(http: HttpClient);
+    getLicenseResourceLimit(check: 'resource' | 'node' | 'version', resource: number): import("rxjs").Observable<boolean>;
+    getLicenseAllowVersion(version: string): import("rxjs").Observable<FeatureGate>;
+    getEnterpriseSupport(product?: string): import("rxjs").Observable<FeatureGateEnterpriseSupport>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LicenseApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LicenseApiService>;
+}

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/public-api';
+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,116 @@
+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/public-api';
+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;
+    xPlotEmpty: boolean;
+    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; }; "xPlotEmpty": { "alias": "xPlotEmpty"; "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,12 @@
+/**
+ * [[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';

package/metric-chart/types.d.ts

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