@univerjs-pro/engine-chart 0.6.4-nightly.202503101606

package/lib/types/model/data-context-transformers/line-like-context-transformer.d.ts

@@ -0,0 +1,3 @@
+import { ChartModel } from '../chart-model';
+import { ChartTypeBits } from '../../enum';
+export declare const lineLikeContextTransformer: (fromType: ChartTypeBits, toType: ChartTypeBits, model: ChartModel) => void;

package/lib/types/model/data-context-transformers/percent-data-context-transformer.d.ts

@@ -0,0 +1,3 @@
+import { ChartModel } from '../chart-model';
+import { ChartTypeBits } from '../../enum';
+export declare const percentDataContextTransformer: (fromType: ChartTypeBits, toType: ChartTypeBits, model: ChartModel) => void;

package/lib/types/model/data-context-transformers/pie-data-context-transformer.d.ts

@@ -0,0 +1,3 @@
+import { ChartModel } from '../chart-model';
+import { ChartTypeBits } from '../../enum';
+export declare const pieDataContextTransformer: (fromType: ChartTypeBits, toType: ChartTypeBits, model: ChartModel) => void;

package/lib/types/model/echart-render-model.d.ts

@@ -0,0 +1,33 @@
+import { ChartStyle, EChartInstance, EChartSpec, IChartConfig, IChartHostRect, IChartInstance, IChartRenderModel, IChartRenderModelStylizeInit } from '../types';
+import { Disposable } from '@univerjs/core';
+import * as echarts from 'echarts';
+export declare class EChartRenderModel extends Disposable implements IChartRenderModel {
+    private _specConverters;
+    private _specOperators;
+    readonly _addWatermark: boolean;
+    constructor(_addWatermark: boolean);
+    private _addSpecConverters;
+    private _addSpecOperators;
+    createChartInstance(): IChartInstance<EChartSpec>;
+    toSpec(config: IChartConfig, style: ChartStyle): echarts.EChartsOption;
+    stylizeSpec(spec: EChartSpec, stylizeInit: IChartRenderModelStylizeInit<EChartSpec>, rect: IChartHostRect): echarts.EChartsOption | {
+        backgroundColor: string;
+    };
+}
+export declare class EChartRenderEngine extends Disposable implements EChartInstance {
+    [Symbol.dispose](): void;
+    static name: string;
+    private _instance;
+    container: HTMLElement | string;
+    private _devicePixelRatio;
+    constructor();
+    getDevicePixelRatio(): 1 | 2 | undefined;
+    mount(id: string | HTMLElement): void;
+    resize(): void;
+    private _ensureChartInstance;
+    get containerElement(): HTMLElement | null;
+    render(spec: EChartSpec): void;
+    exportImg(): Promise<string>;
+    onDispose(): void;
+    dispose(): void;
+}

package/lib/types/model/mode-converter/converters/combination-chart-converter.d.ts

@@ -0,0 +1,2 @@
+import { EChartSpec, IChartRenderSpecConverter } from '../../../types';
+export declare const combinationChartConverter: IChartRenderSpecConverter<EChartSpec>;

package/lib/types/model/mode-converter/converters/constants.d.ts

@@ -0,0 +1,7 @@
+export declare enum SpecField {
+    ValueField = "__valueField__",
+    SeriesField = "__seriesField__",
+    SeriesFieldLabel = "__seriesFieldLabel__",
+    CategoryField = "__categoryField__",
+    CategoryFieldLabel = "__categoryFieldLabel__"
+}

package/lib/types/model/mode-converter/converters/pie-chart-converter.d.ts

@@ -0,0 +1,2 @@
+import { EChartSpec, IChartRenderSpecConverter } from '../../../types';
+export declare const pieChartConverter: IChartRenderSpecConverter<EChartSpec>;

package/lib/types/model/mode-converter/converters/radar-chart-converter.d.ts

@@ -0,0 +1,2 @@
+import { EChartSpec, IChartRenderSpecConverter } from '../../../types';
+export declare const radarChartConverter: IChartRenderSpecConverter<EChartSpec>;

package/lib/types/model/mode-converter/converters/tools.d.ts

@@ -0,0 +1,5 @@
+import { IChartConfig } from '../../../types';
+export declare function createLabelMap(config: IChartConfig): {
+    categoryNameMap: Record<string, string>;
+    seriesNameMap: Record<string, string>;
+};

package/lib/types/model/mode-converter/mode-converter.d.ts

@@ -0,0 +1,86 @@
+import { Injector } from '@univerjs/core';
+import { ChartTypeBits } from '../../enum';
+import { ChartStyle, IChartContext, IChartHostRect, IUniverDataSet } from '../../types';
+import { ChartModel } from '../chart-model';
+/**
+ * The parameters for initializing a chart model.
+ */
+export interface IChartModelInitParams {
+    /**
+     * The type of the chart.
+     */
+    chartType: ChartTypeBits;
+    /**
+     * The data source of the chart. The data should be like has dimensions and source.
+     * @example
+     * ```json
+     * {
+     *    "dimensions": ['a', 'b', 'c'],
+     *   "source": [
+     *     [1, 2, 3],
+     *     [4, 5, 6],
+     *     [7, 8, 9],
+     *     ]
+     * }
+     * ```
+     */
+    source: IUniverDataSet;
+    /**
+     * The chart title.
+     */
+    title: string;
+    /**
+     * The id of the chart model. This property will be provided by chart model json.
+     */
+    id?: string;
+    /**
+     * The context of the chart model. This property will be provided by chart model json.
+     */
+    context?: Partial<IChartContext>;
+    /**
+     * The style of the chart model. This property will be provided by chart model json.
+     */
+    style?: ChartStyle;
+    /**
+     * The theme name of the chart model. This property will be provided by chart model json.
+     */
+    themeName?: string;
+}
+/**
+ * Convert the initial data to a chart model.
+ * @param initJson The initial data of the chart model.
+ * @param injector  The injector of the chart model.
+ * @returns {Promise<ChartModel>} The chart model.
+ * @example
+ * ```typescript
+ * const workbook = univerAPI.getActiveWorkbook()
+ * const sheet = workbook.getActiveSheet()
+ * const inject = sheet.getInject(); *
+ * const data = {
+ *     dimensions: ['a', 'b', 'c'],
+ *     source: [['test', 1, 3], ['test1', 2, 2], ['tes2', 3, 1], ['test3', 4, 4], ]
+ * } *
+ * const initData = {
+ *     chartType: 4,
+ *     source: data,
+ *     title: 'test title',
+ * }
+ * const model = await window.convertModelFromInitData(initData, inject)
+ * const rect = {
+ *     width: 500,
+ *     height: 400
+ * };
+ * console.log(window.convertModelToSpec(model, rect))
+ * setTimeout(()=>{
+ *     console.log('1111',window.convertModelToSpec(model, rect))
+ * },1000)
+ * ```
+ */
+export declare function convertModelFromInitData(initJson: IChartModelInitParams, injector: Injector): Promise<ChartModel>;
+/**
+ * Convert the chart model to a chart spec.The spec is a echart option object.
+ * @param model The chart model.
+ * @param rect The current size of the chart.
+ * @returns {EChartSpec} The chart spec.
+ */
+export declare function convertModelToSpec(model: ChartModel, rect: IChartHostRect): import('echarts').EChartsOption;

package/lib/types/model/mode-converter/render-spec-operators/axis-title.operator.d.ts

@@ -0,0 +1,2 @@
+import { EChartRenderSpecOperator } from '../../../types';
+export declare const axisTitleStyleOperator: EChartRenderSpecOperator;

package/lib/types/model/mode-converter/render-spec-operators/chart-axes.operator.d.ts

@@ -0,0 +1,2 @@
+import { EChartRenderSpecOperator } from '../../../types';
+export declare const chartAxesOperator: EChartRenderSpecOperator;

package/lib/types/model/mode-converter/render-spec-operators/chart-box-style.operator.d.ts

@@ -0,0 +1,2 @@
+import { EChartRenderSpecOperator } from '../../../types';
+export declare const chartBoxStyleOperator: EChartRenderSpecOperator;

package/lib/types/model/mode-converter/render-spec-operators/empty-style-operator.d.ts

@@ -0,0 +1,2 @@
+import { EChartRenderSpecOperator } from '../../../types';
+export declare const emptyStyleOperator: EChartRenderSpecOperator;

package/lib/types/model/mode-converter/render-spec-operators/font-size.operator.d.ts

@@ -0,0 +1,2 @@
+import { EChartRenderSpecOperator } from '../../../types';
+export declare const fontSizeOperator: EChartRenderSpecOperator;

package/lib/types/model/mode-converter/render-spec-operators/grid-operator.d.ts

@@ -0,0 +1,2 @@
+import { EChartRenderSpecOperator } from '../../../types';
+export declare const gridStyleOperator: EChartRenderSpecOperator;

package/lib/types/model/mode-converter/render-spec-operators/hover-mark-style.operator.d.ts

@@ -0,0 +1,2 @@
+import { EChartRenderSpecOperator } from '../../../types';
+export declare const hoverMarkStyleOperator: EChartRenderSpecOperator;

package/lib/types/model/mode-converter/render-spec-operators/index.d.ts

@@ -0,0 +1,13 @@
+export { axisTitleStyleOperator } from './axis-title.operator';
+export { chartAxesOperator } from './chart-axes.operator';
+export { chartBoxStyleOperator } from './chart-box-style.operator';
+export { fontSizeOperator } from './font-size.operator';
+export { hoverMarkStyleOperator } from './hover-mark-style.operator';
+export { invalidValueStyleOperator } from './invalid-value-style.operator';
+export { legendStyleOperator } from './legend-style.operator';
+export { lineLikeStyleOperator } from './line-like-style.operator';
+export { pieStyleOperator } from './pie-style.operator';
+export { seriesStyleOperator } from './series-style-operator/series-style-operator';
+export { stackOperator } from './stack.operator';
+export { chartThemeOperator } from './theme.operator';
+export { chartTitleStyleOperator } from './title-style.operator';

package/lib/types/model/mode-converter/render-spec-operators/invalid-value-style.operator.d.ts

@@ -0,0 +1,2 @@
+import { EChartRenderSpecOperator } from '../../../types';
+export declare const invalidValueStyleOperator: EChartRenderSpecOperator;

package/lib/types/model/mode-converter/render-spec-operators/legend-style.operator.d.ts

@@ -0,0 +1,2 @@
+import { EChartRenderSpecOperator } from '../../../types';
+export declare const legendStyleOperator: EChartRenderSpecOperator;

package/lib/types/model/mode-converter/render-spec-operators/line-like-style.operator.d.ts

@@ -0,0 +1,2 @@
+import { EChartRenderSpecOperator } from '../../../types';
+export declare const lineLikeStyleOperator: EChartRenderSpecOperator;

package/lib/types/model/mode-converter/render-spec-operators/operator-types.d.ts

@@ -0,0 +1,7 @@
+export interface ISpecGrid {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    containLabel: boolean;
+}

package/lib/types/model/mode-converter/render-spec-operators/pie-style.operator.d.ts

@@ -0,0 +1,2 @@
+import { EChartRenderSpecOperator } from '../../../types';
+export declare const pieStyleOperator: EChartRenderSpecOperator;

package/lib/types/model/mode-converter/render-spec-operators/radar-style.operator.d.ts

@@ -0,0 +1,2 @@
+import { EChartRenderSpecOperator } from '../../../types';
+export declare const radarStyleOperator: EChartRenderSpecOperator;

package/lib/types/model/mode-converter/render-spec-operators/scatter-style.operator.d.ts

@@ -0,0 +1,2 @@
+import { EChartRenderSpecOperator } from '../../../types';
+export declare const scatterStyleOperator: EChartRenderSpecOperator;

package/lib/types/model/mode-converter/render-spec-operators/series-style-operator/series-chart-style.handler.d.ts

@@ -0,0 +1,2 @@
+import { SeriesItemHandler } from './series-style-operator';
+export declare const seriesChartStyleHandler: SeriesItemHandler;

package/lib/types/model/mode-converter/render-spec-operators/series-style-operator/series-data-label.handler.d.ts

@@ -0,0 +1,2 @@
+import { SeriesItemHandler } from './series-style-operator';
+export declare const seriesDataLabelHandler: SeriesItemHandler;

package/lib/types/model/mode-converter/render-spec-operators/series-style-operator/series-style-operator.d.ts

@@ -0,0 +1,11 @@
+import { ChartStyle, DeepPartial, EChartRenderSpecOperator, EChartSeriesItem, ISeriesStyle } from '../../../../types';
+import { ChartTypeBits } from '../../../../enum';
+export interface ISeriesStyleHandlerContext {
+    seriesItem: EChartSeriesItem;
+    seriesIndex: number;
+    seriesStyle: DeepPartial<ISeriesStyle> | undefined;
+    chartStyle: ChartStyle;
+    chartType: ChartTypeBits;
+}
+export type SeriesItemHandler = (context: ISeriesStyleHandlerContext, isVerticalSeriesValue: boolean) => void;
+export declare const seriesStyleOperator: EChartRenderSpecOperator;

package/lib/types/model/mode-converter/render-spec-operators/stack.operator.d.ts

@@ -0,0 +1,2 @@
+import { EChartRenderSpecOperator } from '../../../types';
+export declare const stackOperator: EChartRenderSpecOperator;

package/lib/types/model/mode-converter/render-spec-operators/theme.operator.d.ts

@@ -0,0 +1,2 @@
+import { EChartRenderSpecOperator } from '../../../types';
+export declare const chartThemeOperator: EChartRenderSpecOperator;

package/lib/types/model/mode-converter/render-spec-operators/title-style.operator.d.ts

@@ -0,0 +1,2 @@
+import { EChartRenderSpecOperator } from '../../../types';
+export declare const chartTitleStyleOperator: EChartRenderSpecOperator;

package/lib/types/model/mode-converter/render-spec-operators/tool-tip-operator.d.ts

@@ -0,0 +1,2 @@
+import { EChartRenderSpecOperator } from '../../../types';
+export declare const toolTipStyleOperator: EChartRenderSpecOperator;

package/lib/types/model/mode-converter/render-spec-operators/tools.d.ts

@@ -0,0 +1,13 @@
+import { ChartStyle, EChartSeriesItem, EChartSpec, IChartConfig, ILabelStyle } from '../../../types';
+import { ISpecGrid } from './operator-types';
+type PartialLabelStyle = Partial<Pick<ILabelStyle, 'visible' | 'color' | 'fontSize' | 'italic' | 'bold' | 'underline' | 'strikethrough' | 'showMaxLabel' | 'showMinLabel'>>;
+export declare function applyLabelStyle(spec: Record<string, any>, path: string, labelStyle: PartialLabelStyle): void;
+export declare function applyLineStyle(spec: Record<string, any>, path: string, labelStyle: PartialLabelStyle): void;
+export declare function toArray<T = unknown>(value: T | T[]): T[];
+export declare function seriesForEach(series: EChartSpec['series'], func: (item: EChartSeriesItem, index: number) => void): void;
+export declare function toPercentage(value: number, fixed?: number): string;
+export declare const getLegendOrSeriesMaxWidth: (gridInfo: ISpecGrid, config: IChartConfig, style: ChartStyle) => number;
+export declare const getCategoryLabelVertical: (gridInfo: ISpecGrid, style: ChartStyle) => number;
+export declare const getCategoryLabelHorizontal: (gridInfo: ISpecGrid, style: ChartStyle, seriesCount: number, axisLabelMaxWidth?: number) => number;
+export declare const getIntegerValue: (value: number, digit?: number) => number;
+export {};

package/lib/types/model/mode-converter/render-spec-operators/watermark.operator.d.ts

@@ -0,0 +1,2 @@
+import { EChartRenderSpecOperator } from '../../../types';
+export declare const chartWaterMarkerOperator: EChartRenderSpecOperator;

package/lib/types/model/spec-converter/spec-converter.d.ts

@@ -0,0 +1 @@
+export declare function convertToSpecFromModel(model: any): any;

package/lib/types/source/chart-source.d.ts

@@ -0,0 +1,32 @@
+import { Observable, BehaviorSubject } from 'rxjs';
+import { IChartDataSource, IUniverDataSet } from '../types';
+export declare abstract class ChartDataSource implements IChartDataSource {
+    protected _data$: BehaviorSubject<IUniverDataSet>;
+    /**
+     * The data source of the chart
+     */
+    data$: Observable<IUniverDataSet>;
+    protected _canSwitchOrient$: BehaviorSubject<boolean>;
+    /**
+     * The data source can switch the orient or not
+     */
+    canSwitchOrient$: Observable<boolean>;
+    protected _isRowDirection: BehaviorSubject<boolean>;
+    /**
+     * The data source is row direction or not
+     */
+    isRowDirection$: Observable<boolean>;
+    /**
+     * How to convert the data source to the dataset
+     */
+    abstract convertDataSet(): IUniverDataSet;
+    constructor();
+    protected _init(): void;
+    setData(data: IUniverDataSet): void;
+    updateCanSwitchOrient(flag: boolean): void;
+    updateIsRowDirection(flag: boolean): void;
+    getDataSet(): IUniverDataSet;
+    getDimensionCount(): number;
+    refresh(): void;
+    dispose(): void;
+}

package/lib/types/source/source-util.d.ts

@@ -0,0 +1,2 @@
+import { OptionDataValue } from '../types';
+export declare function getCategoryData(source: OptionDataValue[][], categoryIndex: number, isRowDirection: boolean): OptionDataValue[];

package/lib/types/source/static-chart-source.d.ts

@@ -0,0 +1,7 @@
+import { IUniverDataSet } from '../types';
+import { ChartDataSource } from './chart-source';
+export declare class StaticChartSource extends ChartDataSource {
+    constructor();
+    initData(data: IUniverDataSet): void;
+    convertDataSet(): IUniverDataSet;
+}

package/lib/types/types.d.ts

@@ -0,0 +1,271 @@
+import { CellValue, IDisposable, LocaleService, Nullable } from '@univerjs/core';
+import { Observable } from 'rxjs';
+import { AreaLineStyle, AxisAlignEnum, AxisValueType, CategoryType, ChartBorderDashType, ChartTypeBits, DataOrientation, InvalidValueType, IRuntimeAxisPosition, IRuntimeAxisPriority, LabelAlignEnum, LegendPositionEnum, LinePointShape, PieLabelPosition, RadarShape, SelectModeEnum, SeriesLabelPosition, TitlePositionEnum } from './enum';
+import { IEchartTheme } from './model/constants/build-in-theme';
+export type DeepPartial<T> = T extends Record<string, any> ? T extends any[] ? T : {
+    [key in keyof T]+?: DeepPartial<T[key]>;
+} : T;
+export interface IChartDataSource {
+    data$: Observable<IUniverDataSet>;
+    canSwitchOrient$: Observable<boolean>;
+    isRowDirection$: Observable<boolean>;
+    convertDataSet(): IUniverDataSet;
+    dispose(): void;
+    getDataSet(): IUniverDataSet;
+    getDimensionCount(): number;
+    refresh(): void;
+}
+export type ChartDataSourceValue = Nullable<CellValue>;
+export type ChartDataSourceValues = Array<Array<ChartDataSourceValue>>;
+export interface IDimensionDefinition {
+    type?: 'number' | 'ordinal' | 'time' | 'float' | 'int';
+    name?: string;
+    displayName?: string;
+}
+export type DimensionDefinitionLoose = IDimensionDefinition['name'] | IDimensionDefinition;
+export type OptionDataValue = string | number | Date | null | undefined;
+export interface IUniverDataSet {
+    source: OptionDataValue[][];
+    dimensions: Array<DimensionDefinitionLoose>;
+}
+export interface IChartContext {
+    headers?: string[];
+    categoryType?: CategoryType;
+    categoryIndex?: number;
+    categoryResourceIndexes?: number[];
+    seriesIndexes?: number[];
+    seriesResourceIndexes?: number[];
+    transform?: {
+        categoryIndex?: number;
+        seriesIndexes?: number[];
+    };
+}
+export interface IChartData {
+    category?: IChartDataCategory;
+    headers?: string[];
+    series: IChartDataSeries[];
+    maxValue: number;
+    minValue: number;
+    /**
+     * the dataset of the chart, it should match echart dataset option
+     */
+    dataset?: IUniverDataSet;
+}
+export interface IChartDataCategory {
+    index: number;
+    name: string;
+    type: CategoryType;
+    items: IChartDataItem[];
+    keys: string[];
+}
+export interface IChartDataSeries {
+    index: number;
+    name: string;
+    items: IChartDataItem[];
+}
+interface IChartDataItem {
+    value: OptionDataValue;
+    label: string;
+}
+export interface IRuntimeAxis {
+    priority: IRuntimeAxisPriority;
+    position: IRuntimeAxisPosition;
+    type: AxisValueType;
+}
+export interface IChartRuntimeContext {
+    themeColors?: string[];
+    axes: IRuntimeAxis[];
+    themeInfo: IEchartTheme;
+    hasSecondaryAxis: boolean;
+    localeService: LocaleService;
+    emptyTips: string;
+}
+export interface ILabelStyle {
+    visible: boolean;
+    content: string;
+    fontSize: number;
+    color: string;
+    align: LabelAlignEnum;
+    bold: boolean;
+    family: string;
+    strikethrough: boolean;
+    italic: boolean;
+    underline: boolean;
+    padAngle: boolean;
+    axisTitleAlign?: AxisAlignEnum | undefined;
+    showMaxLabel?: boolean;
+    showMinLabel?: boolean;
+}
+export interface ILegendStyle {
+    position?: LegendPositionEnum;
+    label?: Omit<ILabelStyle, 'visible' | 'align' | 'content'>;
+    selectMode?: SelectModeEnum;
+}
+export interface IGridLineStyle {
+    visible: boolean;
+    color: string;
+    width: number;
+}
+export interface IAxisOptions {
+    lineVisible: boolean;
+    label: Omit<ILabelStyle, 'align' | 'content'>;
+    lineStyle: IGridLineStyle;
+    gridLine: IGridLineStyle;
+    tick: {
+        visible: boolean;
+        lineWidth: number;
+        lineColor: string;
+        length: number;
+        position: PieLabelPosition;
+    };
+    reverse?: boolean;
+    min?: number | null;
+    max?: number | null;
+}
+export interface ISeriesLabelStyle extends ILabelStyle {
+    contentType: number;
+    position: SeriesLabelPosition;
+}
+export interface IPieLabelStyle extends Omit<ILabelStyle, 'align' | 'content'> {
+    contentType: number;
+    position: PieLabelPosition;
+}
+export interface IPointStyle {
+    shape: LinePointShape;
+    size: number;
+    color: Nullable<string>;
+}
+export interface IDataPointStyle extends IPointStyle {
+}
+export interface ISeriesStyle {
+    chartType?: ChartTypeBits.Line | ChartTypeBits.Column | ChartTypeBits.Area;
+    rightYAxis?: boolean;
+    color: Nullable<string>;
+    fillOpacity: number;
+    border: {
+        opacity: number;
+        color: Nullable<string>;
+        width: number;
+        dashType: ChartBorderDashType;
+    };
+    label: ISeriesLabelStyle;
+    point: IPointStyle;
+    dataPoints: {
+        [index: number]: IDataPointStyle;
+    };
+}
+export type RightYAxisOptions = Omit<IAxisOptions, 'reverse'>;
+export interface IAllSeriesStyle extends Pick<ISeriesStyle, 'border' | 'label' | 'rightYAxis' | 'point' | 'color'> {
+}
+export interface IChartStyle {
+    runtime: IChartRuntimeContext;
+    width: number;
+    height: number;
+    theme: string;
+    invalidValueType: InvalidValueType;
+    gradientFill: boolean;
+    backgroundColor: Nullable<string>;
+    titleFontSize: number;
+    fontSize: number;
+    fontColor: string;
+    borderColor: Nullable<string>;
+    titles: {
+        title: Omit<ILabelStyle, 'visible'>;
+        subtitle: Omit<ILabelStyle, 'visible'>;
+        xAxisTitle: Omit<ILabelStyle, 'visible'>;
+        yAxisTitle: Omit<ILabelStyle, 'visible'>;
+        rightYAxisTitle: Omit<ILabelStyle, 'visible'>;
+        titlePosition: TitlePositionEnum;
+    };
+    legend: ILegendStyle;
+    xAxis: IAxisOptions;
+    yAxis: IAxisOptions;
+    rightYAxis: RightYAxisOptions;
+    allSeriesStyle: IAllSeriesStyle;
+    seriesStyleMap: {
+        [id: string]: ISeriesStyle;
+    };
+    pie: {
+        doughnutHole: Nullable<number>;
+        labelStyle: IPieLabelStyle;
+        borderColor: string;
+        hasPaddingAngle: boolean;
+        isHalfPie: boolean;
+        rosePie: boolean;
+        showLabelLine: boolean;
+    };
+    area: {
+        lineStyle: AreaLineStyle;
+    };
+    radar: {
+        shape: RadarShape;
+        fill: boolean;
+    };
+    tooltip: {
+        indicatorLabelColor: string;
+        indicatorLineType: ChartBorderDashType;
+        indicatorLineColor: string;
+        indicatorLabelTextColor: string;
+    };
+}
+export type ChartStyle = DeepPartial<IChartStyle>;
+export interface IChartDataAggregation {
+    aggregate?: boolean;
+    topN?: number;
+}
+export interface IChartConfig extends IChartData {
+    type: ChartTypeBits;
+}
+export interface IChartSnapshot {
+    id: string;
+    chartType: ChartTypeBits;
+    orient?: DataOrientation;
+    context?: Pick<IChartContext, 'categoryIndex' | 'seriesIndexes' | 'transform'>;
+    style?: ChartStyle;
+    dataAggregation?: IChartDataAggregation;
+}
+export interface IChartRenderSpecConverter<ChartRenderSpec = Record<string, any>> {
+    canConvert: (config: IChartConfig) => boolean;
+    convert: (config: IChartConfig, style: ChartStyle) => ChartRenderSpec;
+}
+export type ChartConfigInterceptor = (config: IChartConfig) => IChartConfig;
+export type RenderSpecOperator<ChartRenderSpec> = (spec: ChartRenderSpec, style: ChartStyle, config: IChartConfig, instance: IChartInstance) => void;
+export interface IChartRenderModelStylizeInit<Spec> {
+    chartStyle: ChartStyle;
+    chartConfig: IChartConfig;
+    chartInstance?: IChartInstance<Spec>;
+}
+export interface IChartRenderModel<Spec extends Record<string, any> = Record<string, any>> extends IDisposable {
+    toSpec(chartConfig: IChartConfig, style: ChartStyle): Spec;
+    stylizeSpec(spec: Spec, stylizeInit: IChartRenderModelStylizeInit<Spec>, rect: IChartHostRect): Spec;
+    createChartInstance(): IChartInstance<Spec>;
+    dispose(): void;
+}
+export interface IChartThemeOptions {
+    colors: string[];
+}
+export interface IChartInstance<Spec = Record<string, any>> extends IDisposable {
+    container: HTMLElement | string;
+    mount(id: string | HTMLElement): void;
+    render(spec: Spec): void;
+    exportImg(): Promise<string>;
+    onDispose?(dispose: () => void): void;
+    resize(): void;
+}
+export interface IChartInstanceConstructor<Spec> {
+    new (container: HTMLElement | string): IChartInstance<Spec>;
+}
+export type OptionalDataValue = number | string | null | undefined;
+export type ExtractArrayItem<T> = T extends Array<infer U> ? U : never;
+export type EChartSpec = echarts.EChartsOption;
+export type EChartSeriesItem = ExtractArrayItem<EChartSpec['series']> & {
+    rawData?: number[];
+    seriesId: string;
+};
+export type EChartInstance = IChartInstance<EChartSpec>;
+export type EChartRenderSpecOperator = RenderSpecOperator<EChartSpec>;
+export interface IChartHostRect {
+    width: number;
+    height: number;
+}
+export {};

package/lib/types/util.d.ts

@@ -0,0 +1,22 @@
+import { ChartTypeBits } from './enum';
+export declare const chartBitsUtils: {
+    has(bit: number, attribute: number): boolean;
+    baseOn(bit: number, base: number): boolean;
+    remove(bit: number, attribute: number): number;
+    chartBitToString(bit: ChartTypeBits): "" | "line" | "pie" | "bar" | "scatter" | "radar" | "combination";
+};
+export declare const setProperty: (data: Record<string, any>, propertyPath: string, value: any) => void;
+/**
+ * Set graphic element to data.
+ * because we use graphic element to draw watermark title, so we need to set it to data.
+ */
+export declare const setGraphicToSpec: (spec: Record<string, any>, graphicElements: unknown[]) => void;
+export declare const translateAngleToRadian: (angle: number) => number;
+interface ISize {
+    width: number;
+    height: number;
+}
+export declare const ChartTextMeasureCache: Map<string, ISize>;
+export declare const calcPosition: (text: string, font: string) => ISize;
+export declare const clearChartTextMeasureCache: () => void;
+export {};