@visactor/vchart-types 0.10.0-alpha.2

package/types/component/indicator/interface.d.ts

@@ -0,0 +1,37 @@
+import type { IPercent } from '../../typings/layout';
+import type { ConvertToMarkStyleSpec, ITextMarkSpec } from '../../typings/visual';
+import type { IComponentSpec } from '../base/interface';
+import type { IComponent } from '../interface';
+import type { IRichTextCharacter } from '@visactor/vrender-core';
+export interface IIndicatorItemSpec {
+    visible?: boolean;
+    field?: string;
+    space?: number;
+    autoLimit?: boolean;
+    autoFit?: boolean;
+    fitPercent?: number;
+    fitStrategy?: 'default' | 'inscribed';
+    style?: Omit<ConvertToMarkStyleSpec<ITextMarkSpec>, 'visible' | 'text'> & {
+        type?: 'text' | 'rich' | 'html';
+        text?: string | string[] | number | number[] | IRichTextCharacter[];
+    };
+}
+export type IIndicator = IComponent;
+export interface IIndicatorSpec extends IComponentSpec {
+    visible?: boolean;
+    fixed?: boolean;
+    trigger?: 'hover' | 'select' | 'none';
+    gap?: number;
+    offsetX?: number | IPercent;
+    offsetY?: number | IPercent;
+    limitRatio?: number;
+    title?: IIndicatorItemSpec;
+    content?: IIndicatorItemSpec[] | IIndicatorItemSpec;
+}
+export interface IIndicatorItemTheme extends IIndicatorItemSpec {
+    style?: Omit<ITextMarkSpec, 'visible'>;
+}
+export interface IIndicatorTheme extends IIndicatorSpec {
+    title?: IIndicatorItemTheme;
+    content?: IIndicatorItemTheme;
+}

package/types/component/indicator/util.d.ts

@@ -0,0 +1,13 @@
+import type { IIndicatorItemSpec } from './interface';
+export interface IIndicatorDatum {
+    type: 'title' | 'content';
+    index: number;
+    datum: any;
+    spec: IIndicatorItemSpec;
+}
+export interface IIndicatorMapper {
+    title: IIndicatorItemSpec;
+    content: IIndicatorItemSpec[];
+    datum: () => any;
+}
+export declare const indicatorMapper: (data: Array<any>, op: IIndicatorMapper) => any[];

package/types/component/interface/common.d.ts

@@ -0,0 +1,39 @@
+import type { ISeriesFilter } from '../../region/interface';
+import type { IAnimate } from '../../animation/interface';
+import type { ILayoutModel, IModelConstructor, IModelOption, IModelSpecInfo } from '../../model/interface';
+import type { IRegion } from '../../region/interface';
+import type { ISeries } from '../../series/interface';
+import type { Maybe, StringOrNumber } from '../../typings';
+import type { IGraphic } from '@visactor/vrender-core';
+import type { IChartSpecInfo } from '../../chart/interface';
+export interface IComponentOption extends IModelOption {
+    getAllRegions: () => IRegion[];
+    getRegionsInIndex: (index?: number[]) => IRegion[];
+    getRegionsInIds: (ids: number[]) => IRegion[];
+    getRegionsInUserIdOrIndex: (user_ids?: StringOrNumber[], index?: number[]) => IRegion[];
+    getAllSeries: () => ISeries[];
+    getSeriesInIndex: (index?: number[]) => ISeries[];
+    getSeriesInIds: (ids?: number[]) => ISeries[];
+    getSeriesInUserIdOrIndex: (user_ids?: StringOrNumber[], index?: number[]) => ISeries[];
+    getAllComponents: () => IComponent[];
+    getComponentByIndex: (key: string, index: number) => IComponent | undefined;
+    getComponentByUserId: (userId: StringOrNumber) => IComponent | undefined;
+    getComponentsByKey: (key: string) => IComponent[];
+    getComponentsByType: (type: string) => IComponent[];
+}
+export interface IComponent extends ILayoutModel {
+    readonly name: string;
+    readonly animate?: IAnimate;
+    getRegions: () => IRegion[];
+    getBindSeriesFilter?: () => ISeriesFilter;
+    changeRegions: (regions: IRegion[]) => void;
+    getVRenderComponents: () => IGraphic[];
+    clear: () => void;
+}
+export interface IComponentConstructor extends IModelConstructor {
+    type: string;
+    specKey?: string;
+    getSpecInfo: (chartSpec: any, chartSpecInfo?: IChartSpecInfo) => Maybe<IModelSpecInfo[]>;
+    createComponent: (specInfo: IModelSpecInfo, options: IComponentOption) => IComponent;
+    new (spec: any, options: IComponentOption): IComponent;
+}

package/types/component/interface/index.d.ts

@@ -0,0 +1,4 @@
+export * from './common';
+export * from './type';
+export * from './tooltip-helper';
+export * from './theme';

package/types/component/interface/theme.d.ts

@@ -0,0 +1,44 @@
+import type { IAxisCommonTheme, ICartesianAxisCommonTheme, IPolarAxisCommonTheme } from '../axis';
+import type { IBrushTheme } from '../brush';
+import type { ICrosshairTheme } from '../crosshair/interface';
+import type { IDataZoomTheme, IScrollBarTheme } from '../data-zoom';
+import type { IIndicatorTheme } from '../indicator/interface';
+import type { IDiscreteLegendTheme, IColorLegendTheme, ISizeLegendTheme } from '../legend';
+import type { IMapLabelTheme } from '../map-label';
+import type { IMarkAreaTheme } from '../marker/mark-area/interface';
+import type { IMarkLineTheme } from '../marker/mark-line/interface';
+import type { IMarkPointTheme } from '../marker/mark-point/interface';
+import type { IPlayerTheme } from '../player';
+import type { ITitleTheme } from '../title';
+import type { ITooltipTheme } from '../tooltip/interface';
+import type { ComponentTypeEnum } from './type';
+import type { ITotalLabelTheme } from '../label';
+import type { IPoptipTheme } from '../poptip/interface';
+import type { IColorKey } from '../../theme';
+export interface IComponentTheme {
+    axis?: IAxisCommonTheme;
+    axisBand?: IAxisCommonTheme;
+    axisLinear?: IAxisCommonTheme;
+    axisX?: ICartesianAxisCommonTheme;
+    axisY?: ICartesianAxisCommonTheme;
+    axisZ?: ICartesianAxisCommonTheme;
+    axisRadius?: IPolarAxisCommonTheme;
+    axisAngle?: IPolarAxisCommonTheme;
+    [ComponentTypeEnum.discreteLegend]?: IDiscreteLegendTheme;
+    [ComponentTypeEnum.colorLegend]?: IColorLegendTheme;
+    [ComponentTypeEnum.sizeLegend]?: ISizeLegendTheme;
+    [ComponentTypeEnum.markLine]?: IMarkLineTheme;
+    [ComponentTypeEnum.markArea]?: IMarkAreaTheme;
+    [ComponentTypeEnum.markPoint]?: IMarkPointTheme;
+    [ComponentTypeEnum.tooltip]?: ITooltipTheme<string | IColorKey>;
+    [ComponentTypeEnum.crosshair]?: ICrosshairTheme;
+    [ComponentTypeEnum.dataZoom]?: IDataZoomTheme;
+    [ComponentTypeEnum.scrollBar]?: IScrollBarTheme;
+    [ComponentTypeEnum.indicator]?: IIndicatorTheme;
+    [ComponentTypeEnum.player]?: IPlayerTheme;
+    [ComponentTypeEnum.brush]?: IBrushTheme;
+    [ComponentTypeEnum.title]?: ITitleTheme;
+    [ComponentTypeEnum.mapLabel]?: IMapLabelTheme;
+    [ComponentTypeEnum.poptip]?: IPoptipTheme;
+    [ComponentTypeEnum.totalLabel]?: ITotalLabelTheme;
+}

package/types/component/interface/tooltip-helper.d.ts

@@ -0,0 +1,5 @@
+import type { ITooltipHelper } from '../../model/tooltip-helper';
+import type { IComponent } from './common';
+export interface IComponentTooltipHelper extends ITooltipHelper {
+    component: IComponent;
+}

package/types/component/interface/type.d.ts

@@ -0,0 +1,35 @@
+export type ComponentType = keyof typeof ComponentTypeEnum | string;
+export declare enum ComponentTypeEnum {
+    cartesianAxis = "cartesianAxis",
+    cartesianBandAxis = "cartesianAxis-band",
+    cartesianLinearAxis = "cartesianAxis-linear",
+    cartesianTimeAxis = "cartesianAxis-time",
+    cartesianLogAxis = "cartesianAxis-log",
+    cartesianSymlogAxis = "cartesianAxis-symlog",
+    polarAxis = "polarAxis",
+    polarBandAxis = "polarAxis-band",
+    polarLinearAxis = "polarAxis-linear",
+    crosshair = "crosshair",
+    cartesianCrosshair = "cartesianCrosshair",
+    polarCrosshair = "polarCrosshair",
+    dataZoom = "dataZoom",
+    geoCoordinate = "geoCoordinate",
+    indicator = "indicator",
+    discreteLegend = "discreteLegend",
+    continuousLegend = "continuousLegend",
+    colorLegend = "colorLegend",
+    sizeLegend = "sizeLegend",
+    mapLabel = "mapLabel",
+    markLine = "markLine",
+    markArea = "markArea",
+    markPoint = "markPoint",
+    tooltip = "tooltip",
+    title = "title",
+    player = "player",
+    scrollBar = "scrollBar",
+    label = "label",
+    totalLabel = "totalLabel",
+    brush = "brush",
+    poptip = "poptip",
+    customMark = "customMark"
+}

package/types/component/label/base-label.d.ts

@@ -0,0 +1,35 @@
+import { BaseComponent } from '../base/base-component';
+import type { IComponentOption } from '../interface';
+import { ComponentTypeEnum } from '../interface/type';
+import type { IRegion } from '../../region/interface';
+import type { IModelRenderOption } from '../../model/interface';
+import type { ILabelSpec } from './interface';
+import type { IGraphic } from '@visactor/vrender-core';
+export declare abstract class BaseLabelComponent<T = any> extends BaseComponent<T> {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    layoutType: 'none';
+    layoutZIndex: number;
+    constructor(spec: T, options: IComponentOption);
+    protected _interactiveConfig(labelSpec: ILabelSpec): {
+        hover: boolean;
+        select: boolean;
+        state: {
+            hover?: Partial<import("../..").ITextMarkSpec>;
+            hover_reverse?: Partial<import("../..").ITextMarkSpec>;
+            selected?: Partial<import("../..").ITextMarkSpec>;
+            selected_reverse?: Partial<import("../..").ITextMarkSpec>;
+        };
+    };
+    _compareSpec(spec: T, prevSpec: T): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    onRender(ctx: IModelRenderOption): void;
+    changeRegions(regions: IRegion[]): void;
+    protected _getNeedClearVRenderComponents(): IGraphic[];
+}

package/types/component/label/index.d.ts

@@ -0,0 +1,4 @@
+export * from './interface';
+export * from './label';
+export * from './total-label';
+export * from './label-transformer';

package/types/component/label/interface.d.ts

@@ -0,0 +1,44 @@
+import type { BaseLabelAttrs } from '@visactor/vrender-components';
+import type { ConvertToMarkStyleSpec, Datum, ITextMarkSpec } from '../../typings';
+import type { IComponentSpec } from '../base/interface';
+import type { IRichTextCharacter } from '@visactor/vrender-core';
+import type { ILabelMark } from '../../mark/label';
+import type { ISeries } from '../../series';
+export interface ILabelFormatMethodContext {
+    series?: ISeries;
+}
+export interface ILabelSpec extends IComponentSpec {
+    visible?: boolean;
+    interactive?: boolean;
+    textType?: string;
+    formatMethod?: (text: string | string[], datum?: Datum, ctx?: ILabelFormatMethodContext) => string | string[] | IRichTextCharacter[];
+    formatter?: string;
+    offset?: number;
+    position?: string;
+    style?: ConvertToMarkStyleSpec<ITextMarkSpec>;
+    state?: LabelStateStyle<Partial<ITextMarkSpec>>;
+    overlap?: BaseLabelAttrs['overlap'];
+    smartInvert?: BaseLabelAttrs['smartInvert'];
+    animation?: BaseLabelAttrs['animation'];
+    dataFilter?: BaseLabelAttrs['dataFilter'];
+    customLayoutFunc?: BaseLabelAttrs['customLayoutFunc'];
+    customOverlapFunc?: BaseLabelAttrs['customOverlapFunc'];
+    labelLayout?: 'series' | 'region';
+    centerOffset?: number;
+    support3d?: boolean;
+    syncState?: boolean;
+}
+type LabelStateStyle<T> = {
+    hover?: T;
+    hover_reverse?: T;
+    selected?: T;
+    selected_reverse?: T;
+};
+export type ITotalLabelSpec = Pick<ILabelSpec, 'visible' | 'formatMethod' | 'interactive' | 'offset' | 'style' | 'state'>;
+export interface ITotalLabelTheme extends Pick<ILabelSpec, 'visible' | 'interactive' | 'offset' | 'overlap' | 'smartInvert' | 'animation'> {
+    style?: ITextMarkSpec;
+}
+export type TransformedLabelSpec = ILabelSpec & {
+    getStyleHandler: (series: ISeries) => (mark?: ILabelMark) => void;
+};
+export {};

package/types/component/label/label-transformer.d.ts

@@ -0,0 +1,8 @@
+import type { IChartSpec } from '../../typings';
+import { BaseComponentSpecTransformer } from '../base';
+export declare class LabelSpecTransformer<T extends IChartSpec = any, K = any> extends BaseComponentSpecTransformer<T, K> {
+    protected _initTheme(spec: T, chartSpec: any): {
+        spec: T;
+        theme: K;
+    };
+}

package/types/component/label/label.d.ts

@@ -0,0 +1,55 @@
+import type { IComponentOption } from '../interface';
+import { ComponentTypeEnum } from '../interface/type';
+import type { IRegion } from '../../region/interface';
+import type { IModelInitOption, IModelSpecInfo } from '../../model/interface';
+import type { ISeries } from '../../series/interface';
+import type { ILabel, IMark as IVGrammarMark } from '@visactor/vgrammar-core';
+import type { IComponentMark } from '../../mark/component';
+import { BaseLabelComponent } from './base-label';
+import type { Maybe } from '@visactor/vutils';
+import type { IGroup } from '@visactor/vrender-core';
+import type { TransformedLabelSpec } from './interface';
+import type { ILabelMark } from '../../mark/label';
+import type { ICompilableMark } from '../../compile/mark';
+import type { IChartSpecInfo } from '../../chart/interface';
+import type { IChartSpec } from '../../typings';
+import { LabelSpecTransformer } from './label-transformer';
+export interface ILabelInfo {
+    baseMark: ICompilableMark;
+    labelMark: ILabelMark;
+    series: ISeries;
+    labelSpec: TransformedLabelSpec;
+}
+export interface ILabelComponentContext {
+    region: IRegion;
+    labelInfo: ILabelInfo[];
+}
+export declare class Label<T extends IChartSpec = any> extends BaseLabelComponent<T> {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    static specKey: string;
+    specKey: string;
+    static readonly transformerConstructor: any;
+    readonly transformerConstructor: typeof LabelSpecTransformer;
+    layoutZIndex: number;
+    protected _labelInfoMap: Map<IRegion, ILabelInfo[]>;
+    protected _labelComponentMap: Map<IComponentMark, () => ILabelInfo | ILabelInfo[]>;
+    protected _layoutRule: 'series' | 'region';
+    constructor(spec: T, options: IComponentOption);
+    static getSpecInfo(chartSpec: any, chartSpecInfo: IChartSpecInfo): Maybe<IModelSpecInfo[]>;
+    init(option: IModelInitOption): void;
+    reInit(spec?: T): void;
+    initEvent(): void;
+    protected _delegateLabelEvent(component: IGroup): void;
+    protected _initTextMark(): void;
+    protected _initLabelComponent(): void;
+    protected _initTextMarkStyle(): void;
+    updateLayoutAttribute(): void;
+    protected _updateMultiLabelAttribute(labelInfo: ILabelInfo[], labelComponent: IComponentMark): void;
+    protected _updateSingleLabelAttribute(labelInfo: ILabelInfo, labelComponent: IComponentMark): void;
+    protected _updateLabelComponentAttribute(component: ILabel, target: IVGrammarMark | IVGrammarMark[], labelInfos: ILabelInfo[]): void;
+    compileMarks(): void;
+    getVRenderComponents(): any[];
+}
+export declare const registerLabel: () => void;

package/types/component/label/total-label.d.ts

@@ -0,0 +1,28 @@
+import { ComponentTypeEnum } from '../interface/type';
+import type { MarkType } from '../../mark/interface';
+import type { ISeries } from '../../series/interface';
+import { BaseLabelComponent } from './base-label';
+import type { IModelInitOption, IModelSpecInfo } from '../../model/interface';
+import type { Maybe } from '../../typings';
+import type { IChartSpecInfo } from '../../chart/interface';
+export declare class TotalLabel extends BaseLabelComponent {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    static specKey: string;
+    specKey: string;
+    layoutZIndex: number;
+    private _textMark?;
+    private _baseMark?;
+    static getSpecInfo(chartSpec: any, chartSpecInfo?: IChartSpecInfo): Maybe<IModelSpecInfo[]>;
+    init(option: IModelInitOption): void;
+    protected _initTextMark(): void;
+    _initTextMarkStyle(): void;
+    protected _initLabelComponent(): void;
+    updateLayoutAttribute(): void;
+    compileMarks(): void;
+    getVRenderComponents(): any[];
+    protected _getSeries(): ISeries;
+}
+export declare function totalLabelPosition(series: ISeries, type: MarkType): string;
+export declare const registerTotalLabel: () => void;

package/types/component/label/totalLabel.d.ts

@@ -0,0 +1,27 @@
+import type { IComponentOption } from '../interface';
+import { ComponentTypeEnum } from '../interface/type';
+import type { MarkType } from '../../mark/interface';
+import type { ISeries } from '../../series/interface';
+import { BaseLabelComponent } from './base-label';
+import type { ITotalLabelSpec, ITotalLabelTheme } from './interface';
+import type { IModelInitOption } from '../../model/interface';
+export declare class TotalLabel extends BaseLabelComponent {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    layoutZIndex: number;
+    private _textMark?;
+    private _baseMark?;
+    series: ISeries;
+    protected _theme: ITotalLabelTheme;
+    static createComponent(spec: ITotalLabelSpec, options: IComponentOption): TotalLabel[];
+    init(option: IModelInitOption): void;
+    protected _initTextMark(): void;
+    _initTextMarkStyle(): void;
+    protected _initLabelComponent(): void;
+    updateLayoutAttribute(): void;
+    compileMarks(): void;
+    getVRenderComponents(): any[];
+}
+export declare function totalLabelPosition(series: ISeries, type: MarkType): string;
+export declare const registerTotalLabel: () => void;

package/types/component/label/util.d.ts

@@ -0,0 +1,65 @@
+import type { Datum } from '../../typings/common';
+import type { ILabelInfo } from './label';
+import type { LabelItem, Strategy } from '@visactor/vrender-components';
+import type { ILabelSpec } from './interface';
+export declare const labelRuleMap: {
+    rect: typeof barLabel;
+    symbol: typeof symbolLabel;
+    arc: typeof pieLabel;
+    point: typeof pointLabel;
+    'line-data': typeof lineDataLabel;
+    stackLabel: typeof stackLabel;
+    line: typeof LineLabel;
+    area: typeof LineLabel;
+    rect3d: typeof barLabel;
+    arc3d: typeof pieLabel;
+    treemap: typeof treemapLabel;
+};
+export declare function defaultLabelConfig(rule: string, labelInfo: ILabelInfo): any;
+export declare function textAttribute(labelInfo: ILabelInfo, datum: Datum, formatMethod?: ILabelSpec['formatMethod'], formatter?: ILabelSpec['formatter']): any;
+export declare function symbolLabel(labelInfo: ILabelInfo): {
+    position: string | ((datum: Datum) => any);
+    overlap: boolean | {
+        strategy: Strategy[];
+        avoidBaseMark: boolean;
+    };
+};
+export declare function lineDataLabel(labelInfo: ILabelInfo): {
+    position: string | ((datum: Datum) => any);
+    overlap: boolean | {
+        strategy: Strategy[];
+        avoidBaseMark: boolean;
+    };
+};
+export declare function barLabel(labelInfo: ILabelInfo): {
+    position: import("@visactor/vrender-components").Functional<string>;
+    overlap: boolean | {
+        strategy: Strategy[];
+    };
+    smartInvert: boolean;
+};
+export declare function pointLabel(labelInfo: ILabelInfo): {
+    position: string;
+    overlap: boolean | {
+        avoidBaseMark: boolean;
+    };
+};
+export declare function pieLabel(labelInfo: ILabelInfo): {
+    position: import("@visactor/vrender-components").Functional<string>;
+    smartInvert: boolean | import("@visactor/vrender-components").SmartInvertAttrs;
+};
+export declare function stackLabel(labelInfo: ILabelInfo): {
+    customLayoutFunc: (labels: LabelItem[]) => import("@visactor/vrender-core").IText[];
+    dataFilter: (labels: LabelItem[]) => LabelItem[];
+    overlap: {
+        strategy: any;
+    };
+};
+export declare function treemapLabel(labelInfo: ILabelInfo): {
+    customLayoutFunc: (labels: LabelItem[]) => import("@visactor/vrender-core").IText[];
+    overlap: boolean;
+};
+export declare function LineLabel(labelInfo: ILabelInfo): {
+    position: string;
+    data: any;
+};

package/types/component/legend/base-legend.d.ts

@@ -0,0 +1,62 @@
+import type { DataView } from '@visactor/vdataset';
+import type { IRegion } from '../../region/interface';
+import { BaseComponent } from '../base/base-component';
+import type { IEffect } from '../../model/interface';
+import type { ILayoutRect, ILayoutType, IOrientType, IPoint, StringOrNumber } from '../../typings';
+import { CompilableData } from '../../compile/data/compilable-data';
+import type { ILegend, ILegendCommonSpec } from './interface';
+import type { IGraphic, IGroup } from '@visactor/vrender-core';
+export declare abstract class BaseLegend<T extends ILegendCommonSpec> extends BaseComponent<T> implements ILegend {
+    layoutType: ILayoutType;
+    layoutZIndex: number;
+    layoutLevel: number;
+    static specKey: string;
+    specKey: string;
+    protected _orient: IOrientType;
+    get orient(): IOrientType;
+    protected _visible: boolean;
+    get visible(): boolean;
+    protected _position: 'start' | 'middle' | 'end';
+    get position(): "start" | "end" | "middle";
+    protected _legendData: CompilableData;
+    getLegendData(): any;
+    private _preSelectedData;
+    protected _selectedData: StringOrNumber[];
+    getSelectedData(): StringOrNumber[];
+    protected _legendComponent: IGroup;
+    private _cacheAttrs;
+    effect: IEffect;
+    protected _seriesUserId?: StringOrNumber[];
+    protected _seriesIndex?: number[];
+    protected _regionUserId?: StringOrNumber[];
+    protected _regionUserIndex?: number[];
+    setAttrFromSpec(): void;
+    created(): void;
+    onRender(ctx: any): void;
+    _compareSpec(spec: T, prevSpec: T): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    changeRegions(regions: IRegion[]): void;
+    protected abstract _initLegendData(): DataView;
+    protected abstract _initSelectedData(): void;
+    protected abstract _getLegendAttributes(rect: ILayoutRect): any;
+    protected abstract _getLegendConstructor(): any;
+    protected abstract _initEvent(): void;
+    private _bindLegendDataChange;
+    protected initData(): void;
+    setSelectedData(selectedData: StringOrNumber[]): void;
+    afterSetLayoutStartPoint(pos: IPoint): void;
+    getBoundsInRect(rect: ILayoutRect, fullSpace: ILayoutRect): {
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+    };
+    onDataUpdate(): void;
+    protected _getNeedClearVRenderComponents(): IGraphic[];
+    clear(): void;
+}

package/types/component/legend/continuous/index.d.ts

@@ -0,0 +1,2 @@
+export * from './legend';
+export * from './interface';

package/types/component/legend/continuous/interface.d.ts

@@ -0,0 +1,59 @@
+import type { IRectMarkSpec, ISymbolMarkSpec, ITextMarkSpec, StringOrNumber } from '../../../typings';
+import type { ILegendCommonSpec, NoVisibleMarkStyle } from '../interface';
+type Text = StringOrNumber;
+export type TextAttribute = {
+    visible?: boolean;
+    text?: Text;
+    space?: number;
+    style?: Omit<NoVisibleMarkStyle<ITextMarkSpec>, 'text'>;
+};
+export type HandlerTextAttribute = {
+    visible?: boolean;
+    precision?: number;
+    formatter?: (text: Text) => Text;
+    space?: number;
+    style?: Omit<NoVisibleMarkStyle<ITextMarkSpec>, 'text'>;
+};
+export type IContinuousLegendSpec = ILegendCommonSpec & {
+    field?: string;
+    scale?: string;
+    defaultSelected?: [number, number];
+    slidable?: boolean;
+    rail?: {
+        width?: number;
+        height?: number;
+        style?: Omit<NoVisibleMarkStyle<IRectMarkSpec>, 'width' | 'height'>;
+    };
+    handler?: {
+        visible?: boolean;
+        style?: NoVisibleMarkStyle<ISymbolMarkSpec>;
+    };
+    track?: {
+        style?: Omit<NoVisibleMarkStyle<IRectMarkSpec>, 'width' | 'height'>;
+    };
+    startText?: TextAttribute;
+    endText?: TextAttribute;
+    handlerText?: HandlerTextAttribute;
+};
+export type IColorLegendSpec = IContinuousLegendSpec & {
+    type: 'color';
+};
+export type ISizeLegendSpec = IContinuousLegendSpec & {
+    type: 'size';
+    sizeBackground?: Omit<NoVisibleMarkStyle<IRectMarkSpec>, 'visible' | 'width' | 'height'>;
+    align?: 'top' | 'bottom' | 'left' | 'right';
+};
+export type IContinuousLegendTheme = Omit<IContinuousLegendSpec, 'type' | 'field' | 'scale' | 'regionIndex' | 'regionId' | 'seriesIndex' | 'seriesId' | 'id' | 'defaultSelected'>;
+export interface IColorLegendTheme {
+    horizontal?: IContinuousLegendTheme;
+    vertical?: IContinuousLegendTheme;
+}
+export interface ISizeLegendTheme {
+    horizontal?: IContinuousLegendTheme & {
+        sizeBackground?: ISizeLegendSpec['sizeBackground'];
+    };
+    vertical?: IContinuousLegendTheme & {
+        sizeBackground?: ISizeLegendSpec['sizeBackground'];
+    };
+}
+export {};

package/types/component/legend/continuous/legend.d.ts

@@ -0,0 +1,28 @@
+import type { Maybe } from '@visactor/vutils';
+import { DataView } from '@visactor/vdataset';
+import type { IModelInitOption, IModelSpecInfo } from '../../../model/interface';
+import type { IComponentOption } from '../../interface';
+import { ComponentTypeEnum } from '../../interface/type';
+import type { IColorLegendSpec, ISizeLegendSpec } from './interface';
+import { BaseLegend } from '../base-legend';
+import type { ILayoutRect } from '../../../typings/layout';
+export declare class ContinuousLegend<T extends IColorLegendSpec | ISizeLegendSpec = IColorLegendSpec | ISizeLegendSpec> extends BaseLegend<T> {
+    static specKey: string;
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    private _field;
+    private _legendType;
+    static getSpecInfo(chartSpec: any): Maybe<IModelSpecInfo[]>;
+    constructor(spec: T, options: IComponentOption);
+    setAttrFromSpec(): void;
+    init(option: IModelInitOption): void;
+    private _getScaleInGlobal;
+    protected _initLegendData(): DataView;
+    protected _initSelectedData(): void;
+    private _addDefaultTitleText;
+    protected _getLegendAttributes(rect: ILayoutRect): any;
+    protected _getLegendConstructor(): any;
+    protected _initEvent(): void;
+}
+export declare const registerContinuousLegend: () => void;

package/types/component/legend/continuous/util.d.ts

@@ -0,0 +1,8 @@
+import type { IColorLegendSpec, ISizeLegendSpec } from './interface';
+import { ColorContinuousLegend, SizeContinuousLegend } from '@visactor/vrender-components';
+export declare function getContinuousLegendAttributes(spec: IColorLegendSpec | ISizeLegendSpec): any;
+export declare function isContinuousLegend(type: string): boolean;
+export declare const ContinuousLegendMap: {
+    color: typeof ColorContinuousLegend;
+    size: typeof SizeContinuousLegend;
+};

package/types/component/legend/discrete/index.d.ts

@@ -0,0 +1,2 @@
+export * from './legend';
+export * from './interface';