@univerjs-pro/engine-chart 1.0.0-alpha.3 → 1.0.0-alpha.5

package/lib/types/chart-builder/chart-builder-adapter.d.ts

@@ -0,0 +1,13 @@
+import type { IChartRenderModelImageExportOptions, IChartRenderModelImageExportResult, IUniverDataSet } from '../types';
+import type { ChartPendingConfig, IChartDescription, IResolvedChartData } from './chart-types';
+/** Host-owned persistence and rendering capabilities used by a chart builder. */
+export interface IChartBuilderAdapter<THostDescription extends object = object> {
+    /** Reads the canonical host description, optionally evaluating pending config against an alternate data set without persisting either. */
+    describe(config?: ChartPendingConfig, dataSet?: IUniverDataSet): IChartDescription & THostDescription;
+    /** Persists one pending semantic configuration patch. */
+    commit(config: ChartPendingConfig): void;
+    /** Materializes fresh engine semantic data for the effective pending state without mutating the host. */
+    resolveData(config: ChartPendingConfig): IResolvedChartData;
+    /** Renders the hosted chart as an image when rendering is available. */
+    exportImage(options?: IChartRenderModelImageExportOptions): Promise<IChartRenderModelImageExportResult | null>;
+}

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

@@ -0,0 +1,35 @@
+import type { DeepReadonly } from '@univerjs/core';
+import type { IChartBuilderAdapter } from './chart-builder-adapter';
+import type { ChartPendingConfig, IChartDescription, IResolvedChartData } from './chart-types';
+import type { IChartConfigOperation } from './configuration/chart-config-operation';
+import type { IUniverDataSet } from '../types';
+import { ChartTypeString } from './chart-types';
+/** Maintains an immutable chart baseline plus pending semantic configuration changes. */
+export declare class ChartBuilder<THostDescription extends object = object> {
+    readonly id: string;
+    readonly adapter: IChartBuilderAdapter<THostDescription>;
+    protected _baseline: IChartDescription & THostDescription;
+    protected _pending: ChartPendingConfig;
+    /** Creates a builder for one chart identity and host adapter. */
+    constructor(id: string, baseline: IChartDescription & THostDescription, adapter: IChartBuilderAdapter<THostDescription>);
+    /** Returns the effective chart type after applying pending changes. */
+    get type(): ChartTypeString;
+    /** Changes the chart type and discards pending options that the new type cannot represent. */
+    setType(type: ChartTypeString): void;
+    /** Merges a semantic patch into the pending configuration. */
+    mergePending(patch: ChartPendingConfig): void;
+    /** Applies one typed configuration operation to the pending state. */
+    apply(operation: IChartConfigOperation): void;
+    /** Returns a frozen description composed from the baseline and pending state. */
+    describe(): DeepReadonly<IChartDescription & THostDescription>;
+    /** Materializes a fresh deeply read-only engine data result for this hosted builder. */
+    resolveData(): DeepReadonly<IResolvedChartData>;
+    /** Persists pending changes through the host adapter and refreshes the baseline. */
+    commit(): void;
+    protected refreshBaseline(): void;
+    /** Supplies host-owned pending data when `describe()` needs to refresh source metadata. */
+    protected getDescriptionDataSetOverride(): IUniverDataSet | undefined;
+    /** Adds host-owned pending fields before the public description is frozen. */
+    protected composeHostDescription(description: IChartDescription & THostDescription): IChartDescription & THostDescription;
+    private _discardIncompatiblePending;
+}

package/lib/types/chart-builder/chart-description.d.ts

@@ -0,0 +1,3 @@
+import type { DeepReadonly } from '@univerjs/core';
+import type { IChartDescription } from './chart-types';
+export type ChartDescription<THost extends object = object> = DeepReadonly<IChartDescription & THost>;

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

@@ -0,0 +1,459 @@
+import type { AreaLineStyle, BarShape, ChartAxisDimension, ChartBorderDashType, ChartMarkLineLabelPosition, ChartSemanticAxis, ChartTrendlineType, ChartWaterfallPointRole, InvalidValueType, IRuntimeAxisPosition, LabelAlignEnum, LabelContentType, LegendPositionEnum, LinePointShape, PieLabelPosition, RadarShape, RelationChartLayoutEnum, SelectModeEnum, SeriesLabelPosition, TitlePositionEnum, WaterfallStackTypeEnum, WordCloudShapeEnum } from '../enum';
+import type { IChartData } from '../types';
+export { ChartAxisDimension, ChartMarkLineLabelPosition, ChartSemanticAxis, ChartWaterfallPointRole } from '../enum';
+/** Canonical semantic chart type names exposed by the chart facade. */
+export declare enum ChartTypeString {
+    Line = "line",
+    Column = "column",
+    ColumnStacked = "columnStacked",
+    ColumnPercentStacked = "columnPercentStacked",
+    Bar = "bar",
+    BarStacked = "barStacked",
+    BarPercentStacked = "barPercentStacked",
+    Pie = "pie",
+    Donut = "donut",
+    Area = "area",
+    AreaStacked = "areaStacked",
+    AreaPercentStacked = "areaPercentStacked",
+    Radar = "radar",
+    Scatter = "scatter",
+    Combination = "combination",
+    WordCloud = "wordCloud",
+    Funnel = "funnel",
+    Bubble = "bubble",
+    Relation = "relation",
+    Waterfall = "waterfall",
+    Pareto = "pareto",
+    Sankey = "sankey",
+    Heatmap = "heatmap",
+    Boxplot = "boxplot"
+}
+export declare enum ChartSeriesTypeString {
+    Column = "column",
+    Line = "line",
+    Area = "area"
+}
+export declare enum ChartVisualMapType {
+    Continuous = "continuous",
+    Piecewise = "piecewise"
+}
+export declare enum ChartAxisTickPosition {
+    Inside = "inside",
+    Outside = "outside"
+}
+export declare enum ChartWordCloudShapeSource {
+    Shape = "shape",
+    MaskImage = "maskImage"
+}
+export declare enum ChartWaterfallStyleTarget {
+    Positive = "positive",
+    Negative = "negative",
+    Subtotal = "subtotal"
+}
+export declare const DEFAULT_CHART_TYPE = ChartTypeString.Line;
+export declare const CARTESIAN_CHART_TYPES: ReadonlySet<ChartTypeString>;
+export declare const AXIS_CHART_TYPES: ReadonlySet<ChartTypeString>;
+export declare const AREA_CHART_TYPES: ReadonlySet<ChartTypeString>;
+export interface IChartFontSpec {
+    color?: string;
+    fontSize?: number;
+    bold?: boolean;
+    italic?: boolean;
+    family?: string;
+}
+export interface IChartTitleOptions extends IChartFontSpec {
+    text?: string;
+    visible?: boolean;
+    position?: TitlePositionEnum;
+    alignment?: LabelAlignEnum;
+}
+export type ChartTitleSpec = string | IChartTitleOptions;
+export interface IChartSubtitleOptions extends IChartFontSpec {
+    text?: string;
+    alignment?: LabelAlignEnum;
+}
+export type ChartSubtitleSpec = string | IChartSubtitleOptions;
+export interface IChartLegendOptions extends IChartFontSpec {
+    visible?: boolean;
+    position?: LegendPositionEnum;
+    selectMode?: SelectModeEnum;
+    wrap?: boolean;
+}
+export type ChartLegendSpec = boolean | IChartLegendOptions;
+export interface IChartAxisLabelSpec extends IChartFontSpec {
+    visible?: boolean;
+    rotate?: number;
+}
+export interface IChartAxisSpec {
+    title?: string;
+    min?: number | null;
+    max?: number | null;
+    reverse?: boolean;
+    line?: {
+        visible?: boolean;
+        color?: string;
+        width?: number;
+    };
+    tick?: {
+        visible?: boolean;
+        color?: string;
+        width?: number;
+        length?: number;
+        position?: ChartAxisTickPosition;
+    };
+    format?: string | null;
+    titleStyle?: IChartFontSpec;
+    label?: IChartAxisLabelSpec;
+    gridLine?: {
+        visible?: boolean;
+        color?: string;
+        width?: number;
+    };
+}
+export interface IChartAxesSpec {
+    x?: IChartAxisSpec;
+    y?: IChartAxisSpec;
+    rightY?: Omit<IChartAxisSpec, 'reverse'>;
+}
+/** Physical location resolved for one semantic axis. */
+export interface IChartAxisBindingDescription {
+    /** Canvas dimension occupied by the axis. */
+    dimension: ChartAxisDimension;
+    /** Physical edge where the axis is drawn. */
+    position: IRuntimeAxisPosition;
+}
+/** Optional label appearance for a fixed-axis mark line. */
+export interface IChartMarkLineLabelSpec {
+    /** Whether the label is visible. */
+    visible?: boolean;
+    /** Explicit label text; omission uses the formatted axis coordinate. */
+    text?: string;
+    /** Physical label placement along the line. */
+    position?: ChartMarkLineLabelPosition;
+    /** Label text color. */
+    color?: string;
+    /** Label font size in pixels. */
+    fontSize?: number;
+    /** Whether the label is bold. */
+    bold?: boolean;
+}
+interface IChartMarkLineStyleSpec {
+    label?: IChartMarkLineLabelSpec;
+    color?: string;
+    width?: number;
+    opacity?: number;
+    dashType?: ChartBorderDashType;
+}
+/** A fixed line addressed by semantic axis and an axis-appropriate coordinate. */
+export type IChartMarkLineSpec = IChartMarkLineStyleSpec & ({
+    axis: ChartSemanticAxis.Category | ChartSemanticAxis.SecondaryCategory;
+    categoryIndex: number;
+} | {
+    axis: ChartSemanticAxis.PrimaryValue | ChartSemanticAxis.SecondaryValue;
+    value: number;
+});
+export type ChartSeriesSelector = {
+    index: number;
+} | {
+    name: string;
+};
+export interface IChartSeriesBorderSpec {
+    color?: string | null;
+    width?: number;
+    opacity?: number;
+    dashType?: ChartBorderDashType;
+}
+export interface IChartSeriesPointSpec {
+    shape?: LinePointShape;
+    size?: number;
+    color?: string | null;
+}
+export interface IChartSeriesLabelSpec extends IChartFontSpec {
+    visible?: boolean;
+    position?: SeriesLabelPosition;
+    contentType?: LabelContentType;
+}
+export interface IChartHeatmapLabelSpec extends IChartFontSpec {
+    visible?: boolean;
+    position?: SeriesLabelPosition;
+}
+export interface IChartSeriesStyleSpec {
+    color?: string;
+    fillOpacity?: number;
+    border?: IChartSeriesBorderSpec;
+    point?: IChartSeriesPointSpec;
+    rightAxis?: boolean;
+    label?: IChartSeriesLabelSpec;
+}
+export interface IChartSeriesPatch extends IChartSeriesStyleSpec {
+    selector: ChartSeriesSelector;
+    type?: ChartSeriesTypeString;
+    dataPoints?: Record<number, {
+        shape?: LinePointShape;
+        size?: number;
+        color?: string | null;
+        fillOpacity?: number;
+    }>;
+    waterfallStyles?: Partial<Record<ChartWaterfallStyleTarget, Omit<IChartSeriesPatch, 'selector' | 'waterfallStyles'>>>;
+}
+export interface IChartTrendlineSpec {
+    selector: ChartSeriesSelector;
+    type: ChartTrendlineType;
+    name?: string;
+    color?: string;
+    width?: number;
+    opacity?: number;
+    dashType?: ChartBorderDashType;
+    order?: number;
+    period?: number;
+    showFormula?: boolean;
+    showR2?: boolean;
+    formulaColor?: string;
+    r2Color?: string;
+}
+export interface IChartHeatmapSpec {
+    visualMapType?: ChartVisualMapType;
+    min?: number;
+    max?: number;
+    /** Unit appended to the minimum and maximum visual-map labels. */
+    unit?: string;
+    /** Style for the value rendered inside each Heatmap cell. */
+    label?: IChartHeatmapLabelSpec;
+}
+export interface IChartWordCloudSpec {
+    shape?: WordCloudShapeEnum;
+    maskImageId?: string | null;
+    repeat?: boolean;
+}
+export interface IChartWordCloudDescription {
+    shape?: WordCloudShapeEnum;
+    maskImageId?: string;
+    repeat?: boolean;
+    effectiveShapeSource: ChartWordCloudShapeSource;
+}
+export interface IChartAppearanceSpec {
+    background?: {
+        /** CSS background color. Use `'transparent'` for an explicit transparent chart and host background. */
+        color?: string | null;
+        gradient?: boolean;
+    };
+    border?: {
+        color?: string | null;
+        /** Persisted host-border width. Use `0` to hide the host border without changing host-owned stroke state. */
+        width?: number;
+    };
+    font?: {
+        color?: string;
+        size?: number;
+        family?: string;
+    };
+}
+export interface IChartScatterMappingSpec {
+    xIndex: number;
+    yIndex: number;
+    labelIndex?: number | null;
+}
+export interface IChartBubbleMappingSpec extends IChartScatterMappingSpec {
+    sizeIndex?: number | null;
+    seriesIndex?: number | null;
+}
+export interface IChartMappingSpec {
+    categoryIndex?: number | null;
+    seriesIndexes?: number[] | null;
+    useDateAxis?: boolean | null;
+    scatter?: IChartScatterMappingSpec | null;
+    bubble?: IChartBubbleMappingSpec | null;
+}
+export interface IChartAggregationSpec {
+    aggregate?: boolean | null;
+    topN?: number | null;
+}
+export interface IChartPieLabelSpec extends IChartFontSpec {
+    visible?: boolean;
+    position?: PieLabelPosition;
+    contentType?: LabelContentType;
+}
+export interface IChartPieSpec {
+    doughnutHole?: number | null;
+    explosion?: number;
+    borderColor?: string;
+    hasPaddingAngle?: boolean;
+    isHalfPie?: boolean;
+    rosePie?: boolean;
+    showLabelLine?: boolean;
+    valueScale?: number;
+    valueSuffix?: string;
+    digitalFixed?: number;
+    label?: IChartPieLabelSpec;
+}
+export interface IChartRadarSpec {
+    shape?: RadarShape;
+    fill?: boolean;
+}
+/** Supported Pareto bar-border appearance. */
+export interface IChartParetoBorderStyleSpec {
+    color?: string;
+    width?: number;
+    opacity?: number;
+    dashType?: ChartBorderDashType;
+}
+/** Supported point appearance for the Pareto cumulative line. */
+export interface IChartParetoPointStyleSpec {
+    shape?: LinePointShape;
+    size?: number;
+    color?: string;
+}
+interface IChartParetoLabelStyleBase extends Omit<IChartSeriesLabelSpec, 'contentType' | 'position'> {
+    contentType?: LabelContentType.Empty | LabelContentType.SeriesName | LabelContentType.CategoryName | LabelContentType.Value;
+}
+/** Pareto bar-label appearance. */
+export interface IChartParetoBarLabelStyleSpec extends IChartParetoLabelStyleBase {
+    position?: SeriesLabelPosition;
+}
+/** Pareto cumulative-line label appearance. */
+export interface IChartParetoLineLabelStyleSpec extends IChartParetoLabelStyleBase {
+    position?: Exclude<SeriesLabelPosition, SeriesLabelPosition.Outside>;
+}
+/** Supported appearance for the Pareto business bars. */
+export interface IChartParetoBarStyleSpec {
+    color?: string;
+    opacity?: number;
+    border?: IChartParetoBorderStyleSpec;
+    label?: IChartParetoBarLabelStyleSpec;
+}
+/** Supported appearance for the derived Pareto cumulative line. */
+export interface IChartParetoLineStyleSpec {
+    color?: string;
+    opacity?: number;
+    width?: number;
+    dashType?: ChartBorderDashType;
+    point?: IChartParetoPointStyleSpec;
+    label?: IChartParetoLineLabelStyleSpec;
+}
+/** Pareto semantic configuration exposed through the Facade. */
+export interface IChartParetoSpec {
+    barStyle?: IChartParetoBarStyleSpec;
+    cumulativeLineStyle?: IChartParetoLineStyleSpec;
+    includeZeroValues?: boolean;
+}
+export interface IChartAxisPointerSpec {
+    indicatorLabelColor?: string;
+    indicatorLineType?: ChartBorderDashType;
+    indicatorLineColor?: string;
+    indicatorLabelTextColor?: string;
+}
+export interface IChartAreaSpec {
+    lineStyle?: AreaLineStyle | null;
+}
+export interface IChartBarSpec {
+    is3D?: boolean;
+    shape?: BarShape;
+    rotX?: number;
+    rotY?: number;
+}
+export interface IChartFunnelSpec {
+    gap?: number | null;
+    useAbsoluteValue?: boolean | null;
+}
+export interface IChartRelationForceSpec {
+    gravity?: number;
+    repulsion?: number;
+    edgeLength?: number;
+}
+export interface IChartRelationSpec {
+    layout?: RelationChartLayoutEnum | null;
+    useValueAsSymbolSize?: boolean | null;
+    emphasisEnabled?: boolean | null;
+    force?: IChartRelationForceSpec | null;
+    circularLabelRotation?: boolean | null;
+    nodeShape?: LinePointShape | null;
+}
+/** Waterfall semantic configuration exposed through the Facade. */
+export interface IChartWaterfallSpec {
+    stackType?: WaterfallStackTypeEnum;
+    useSubtotal?: boolean;
+    pointRoles?: IChartWaterfallPointRoleSpec[];
+    connector?: boolean | IChartWaterfallConnectorStyleSpec;
+    styles?: Partial<Record<ChartWaterfallStyleTarget, Omit<IChartSeriesPatch, 'selector'>>>;
+}
+/** Public Waterfall series selector; numbers are stable source-series indexes. */
+export type ChartWaterfallSeriesSelector = number | {
+    name: string;
+};
+/** Assigns a semantic role to one Waterfall source data point. */
+export interface IChartWaterfallPointRoleSpec {
+    series: ChartWaterfallSeriesSelector;
+    dataPointIndex: number;
+    role: ChartWaterfallPointRole;
+}
+/** Optional appearance overrides for derived Waterfall connectors. */
+export interface IChartWaterfallConnectorStyleSpec {
+    color?: string;
+    width?: number;
+    opacity?: number;
+    dashType?: ChartBorderDashType;
+}
+interface IChartSemanticConfig {
+    type?: ChartTypeString;
+    title?: ChartTitleSpec | null;
+    subtitle?: ChartSubtitleSpec | null;
+    trendlines?: IChartTrendlineSpec[] | null;
+    heatmap?: IChartHeatmapSpec | null;
+    invalidValueStrategy?: InvalidValueType | null;
+    legend?: ChartLegendSpec | null;
+    axes?: IChartAxesSpec | null;
+    allSeriesStyle?: IChartSeriesStyleSpec | null;
+    series?: IChartSeriesPatch[] | null;
+    wordCloud?: IChartWordCloudSpec | null;
+    appearance?: IChartAppearanceSpec | null;
+    mapping?: IChartMappingSpec | null;
+    aggregation?: IChartAggregationSpec | null;
+    pie?: IChartPieSpec | null;
+    radar?: IChartRadarSpec | null;
+    pareto?: IChartParetoSpec | null;
+    axisPointer?: IChartAxisPointerSpec | null;
+    area?: IChartAreaSpec | null;
+    bar?: IChartBarSpec | null;
+    funnel?: IChartFunnelSpec | null;
+    relation?: IChartRelationSpec | null;
+    waterfall?: IChartWaterfallSpec | null;
+    markLines?: IChartMarkLineSpec[] | null;
+    theme?: string | null;
+    /** Persisted absolute series colors. A non-empty value overrides theme colors. */
+    palette?: string[] | null;
+}
+/** Data-free metadata and semantic styling for one source series. */
+export interface IChartSeriesDescription extends IChartSeriesStyleSpec {
+    name: string;
+    type?: ChartSeriesTypeString;
+    dataPoints?: IChartSeriesPatch['dataPoints'];
+    waterfallStyles?: IChartSeriesPatch['waterfallStyles'];
+}
+/** Data-free metadata for the configured category field. */
+export interface IChartCategoryDescription {
+    name: string;
+}
+/** Materialized engine semantic data returned explicitly by hosted builders. */
+export type IResolvedChartData = IChartData;
+export interface IChartDescription extends Omit<IChartSemanticConfig, 'series'> {
+    id: string;
+    type: ChartTypeString;
+    /** Series metadata keyed by source field index; materialized values are available from `resolveData()`. */
+    series: Partial<Record<number, IChartSeriesDescription>>;
+    /** Category metadata only; materialized category values are available from `resolveData()`. */
+    category?: IChartCategoryDescription;
+    /**
+     * Resolved semantic-axis locations for axis charts. Non-axis charts omit this field.
+     * Use these bindings when choosing the semantic `axis` passed to `setMarkLines()`;
+     * for example, `description.axisBindings.category.position` identifies where the
+     * category axis is currently drawn. `secondaryValue` is omitted when absent.
+     *
+     * @example
+     * ```ts
+     * const description = builder.describe();
+     * const categoryAxis = description.axisBindings!.category!;
+     * console.log(categoryAxis.dimension, categoryAxis.position);
+     * ```
+     */
+    axisBindings?: Partial<Record<ChartSemanticAxis, IChartAxisBindingDescription>>;
+}

package/lib/types/chart-builder/configuration/aggregation.d.ts

@@ -0,0 +1,7 @@
+import type { IChartAggregationSpec } from '../chart-types';
+export declare enum ChartAggregationTarget {
+    Aggregate = "aggregate",
+    TopN = "topN"
+}
+export declare const setAggregation: (value: IChartAggregationSpec) => import("./chart-config-operation").IChartConfigOperation;
+export declare const clearAggregation: (target?: ChartAggregationTarget) => import("./chart-config-operation").IChartConfigOperation;

package/lib/types/chart-builder/configuration/appearance.d.ts

@@ -0,0 +1,8 @@
+import type { IChartAppearanceSpec } from '../chart-types';
+export declare enum ChartAppearanceTarget {
+    Background = "background",
+    Border = "border",
+    Font = "font"
+}
+export declare const setAppearance: (value: IChartAppearanceSpec) => import("./chart-config-operation").IChartConfigOperation;
+export declare const clearAppearance: (target?: ChartAppearanceTarget) => import("./chart-config-operation").IChartConfigOperation;

package/lib/types/chart-builder/configuration/area.d.ts

@@ -0,0 +1,3 @@
+import type { AreaLineStyle } from '../../enum';
+export declare const setAreaLineStyle: (value: AreaLineStyle) => import("./chart-config-operation").IChartConfigOperation;
+export declare const clearAreaLineStyle: () => import("./chart-config-operation").IChartConfigOperation;

package/lib/types/chart-builder/configuration/axes.d.ts

@@ -0,0 +1,26 @@
+import type { IChartAxisSpec } from '../chart-types';
+export declare enum ChartAxisTarget {
+    Min = "min",
+    Max = "max",
+    Reverse = "reverse",
+    Line = "line",
+    Tick = "tick",
+    Format = "format",
+    Label = "label",
+    GridLine = "gridLine"
+}
+export declare enum ChartAxisName {
+    X = "x",
+    Y = "y",
+    RightY = "rightY"
+}
+export declare const setXAxis: (value: IChartAxisSpec) => import("./chart-config-operation").IChartConfigOperation;
+export declare const clearXAxis: (target?: ChartAxisTarget) => import("./chart-config-operation").IChartConfigOperation;
+export declare const setYAxis: (value: IChartAxisSpec) => import("./chart-config-operation").IChartConfigOperation;
+export declare const clearYAxis: (target?: ChartAxisTarget) => import("./chart-config-operation").IChartConfigOperation;
+export declare const setRightYAxis: (value: IChartAxisSpec) => import("./chart-config-operation").IChartConfigOperation;
+export declare const clearRightYAxis: (target?: ChartAxisTarget) => import("./chart-config-operation").IChartConfigOperation;
+export declare const setAxisTitle: (axis: ChartAxisName, value: string) => import("./chart-config-operation").IChartConfigOperation;
+export declare const clearAxisTitle: (axis: ChartAxisName) => import("./chart-config-operation").IChartConfigOperation;
+export declare const setUseDateAxis: (value: boolean) => import("./chart-config-operation").IChartConfigOperation;
+export declare const resetUseDateAxis: () => import("./chart-config-operation").IChartConfigOperation;

package/lib/types/chart-builder/configuration/axis-pointer.d.ts

@@ -0,0 +1,9 @@
+import type { IChartAxisPointerSpec } from '../chart-types';
+export declare enum ChartAxisPointerTarget {
+    IndicatorLabelColor = "indicatorLabelColor",
+    IndicatorLabelTextColor = "indicatorLabelTextColor",
+    IndicatorLineColor = "indicatorLineColor",
+    IndicatorLineType = "indicatorLineType"
+}
+export declare const setAxisPointer: (value: IChartAxisPointerSpec) => import("./chart-config-operation").IChartConfigOperation;
+export declare const clearAxisPointer: (target?: ChartAxisPointerTarget) => import("./chart-config-operation").IChartConfigOperation;

package/lib/types/chart-builder/configuration/bar.d.ts

@@ -0,0 +1,3 @@
+import type { IChartBarSpec } from '../chart-types';
+export declare const setBar: (value: IChartBarSpec) => import("./chart-config-operation").IChartConfigOperation;
+export declare const clearBar: () => import("./chart-config-operation").IChartConfigOperation;

package/lib/types/chart-builder/configuration/cartesian-series.d.ts

@@ -0,0 +1,25 @@
+import type { ChartPendingConfig, IChartSeriesStyleSpec } from '../chart-types';
+export declare enum ChartAllSeriesStyleTarget {
+    Border = "border",
+    Color = "color",
+    FillOpacity = "fillOpacity",
+    Label = "label",
+    Point = "point",
+    RightAxis = "rightAxis"
+}
+export declare enum ChartSeriesClearTarget {
+    Border = "border",
+    Color = "color",
+    DataPoints = "dataPoints",
+    FillOpacity = "fillOpacity",
+    Label = "label",
+    Point = "point",
+    RightAxis = "rightAxis"
+}
+export type ChartPublicSeriesSelector = number | {
+    name: string;
+};
+export declare const setSeries: (selector: ChartPublicSeriesSelector, patch: Omit<NonNullable<ChartPendingConfig["series"]>[number], "selector">) => import("./chart-config-operation").IChartConfigOperation;
+export declare const clearSeries: (selector: ChartPublicSeriesSelector, target?: ChartSeriesClearTarget) => import("./chart-config-operation").IChartConfigOperation;
+export declare const setAllSeriesStyle: (style: IChartSeriesStyleSpec) => import("./chart-config-operation").IChartConfigOperation;
+export declare const clearAllSeriesStyle: (target?: ChartAllSeriesStyleTarget) => import("./chart-config-operation").IChartConfigOperation;

package/lib/types/chart-builder/configuration/chart-config-operation.d.ts

@@ -0,0 +1,40 @@
+import type { ChartPendingConfig } from '../chart-types';
+/** Top-level semantic groups accepted by the fluent chart builder. */
+export declare enum ChartConfigGroup {
+    AllSeriesStyle = "allSeriesStyle",
+    Area = "area",
+    AxisPointer = "axisPointer",
+    Aggregation = "aggregation",
+    Appearance = "appearance",
+    Axes = "axes",
+    Bar = "bar",
+    Heatmap = "heatmap",
+    Funnel = "funnel",
+    InvalidValueStrategy = "invalidValueStrategy",
+    Legend = "legend",
+    Mapping = "mapping",
+    MarkLines = "markLines",
+    Palette = "palette",
+    Pareto = "pareto",
+    Pie = "pie",
+    Radar = "radar",
+    Relation = "relation",
+    Series = "series",
+    Subtitle = "subtitle",
+    Theme = "theme",
+    Title = "title",
+    Trendlines = "trendlines",
+    WordCloud = "wordCloud",
+    Waterfall = "waterfall"
+}
+export declare enum ChartConfigOperationMode {
+    Merge = "merge",
+    Replace = "replace"
+}
+export interface IChartConfigOperation {
+    readonly group: keyof ChartPendingConfig;
+    readonly mode: ChartConfigOperationMode;
+    readonly patch: ChartPendingConfig;
+}
+export declare function chartConfigOperation<K extends ChartConfigGroup>(group: K, value: ChartPendingConfig[K], mode?: ChartConfigOperationMode): IChartConfigOperation;
+export declare function mergeChartPendingConfig(current: ChartPendingConfig, next: ChartPendingConfig): ChartPendingConfig;

package/lib/types/chart-builder/configuration/combination.d.ts

@@ -0,0 +1,10 @@
+import type { ChartSeriesTypeString } from '../chart-types';
+import type { ChartPublicSeriesSelector } from './cartesian-series';
+export declare enum ChartSeriesAxis {
+    Left = "left",
+    Right = "right"
+}
+export declare const setCombinationSeriesType: (selector: ChartPublicSeriesSelector, value: ChartSeriesTypeString) => import("./chart-config-operation").IChartConfigOperation;
+export declare const resetCombinationSeriesType: (selector: ChartPublicSeriesSelector) => import("./chart-config-operation").IChartConfigOperation;
+export declare const setCombinationSeriesAxis: (selector: ChartPublicSeriesSelector, value: ChartSeriesAxis) => import("./chart-config-operation").IChartConfigOperation;
+export declare const resetCombinationSeriesAxis: (selector: ChartPublicSeriesSelector) => import("./chart-config-operation").IChartConfigOperation;

package/lib/types/chart-builder/configuration/funnel.d.ts

@@ -0,0 +1,4 @@
+export declare const setFunnelGap: (value: number) => import("./chart-config-operation").IChartConfigOperation;
+export declare const resetFunnelGap: () => import("./chart-config-operation").IChartConfigOperation;
+export declare const setUseAbsoluteValue: (value: boolean) => import("./chart-config-operation").IChartConfigOperation;
+export declare const resetUseAbsoluteValue: () => import("./chart-config-operation").IChartConfigOperation;

package/lib/types/chart-builder/configuration/heatmap.d.ts

@@ -0,0 +1,9 @@
+import type { ChartVisualMapType, IChartHeatmapLabelSpec } from '../chart-types';
+export declare const setVisualMapType: (value: ChartVisualMapType) => import("./chart-config-operation").IChartConfigOperation;
+export declare const resetVisualMapType: () => import("./chart-config-operation").IChartConfigOperation;
+export declare const setValueRange: (min: number, max: number) => import("./chart-config-operation").IChartConfigOperation;
+export declare const clearValueRange: () => import("./chart-config-operation").IChartConfigOperation;
+export declare const setCellLabel: (value: IChartHeatmapLabelSpec) => import("./chart-config-operation").IChartConfigOperation;
+export declare const clearCellLabel: () => import("./chart-config-operation").IChartConfigOperation;
+export declare const setValueUnit: (value: string) => import("./chart-config-operation").IChartConfigOperation;
+export declare const clearValueUnit: () => import("./chart-config-operation").IChartConfigOperation;