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

package/lib/types/chart-model-api/types.d.ts

@@ -0,0 +1,452 @@
+import type { ChartBorderDashType, ChartTypeBits, LabelContentType, LinePointShape, RadarShape, WordCloudShapeEnum } from '../enum';
+import type { ChartModel } from '../models/chart-model';
+import type { ChartStyle, IChartContext, IChartDataAggregation, IChartDataCategory, IChartDataSeries } from '../types';
+import type { ChartKnownTypeName } from './chart-type-manifest';
+import type { ChartModelChangedGroup, ChartModelDiagnosticCode, ChartModelPatchGroup, ChartModelPatchSemantic } from './constants';
+export type DeepReadonly<T> = T extends (...args: any[]) => unknown ? T : T extends readonly (infer U)[] ? readonly DeepReadonly<U>[] : T extends object ? {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+} : T;
+export type DeepPartial<T> = T extends (...args: any[]) => unknown ? T : T extends readonly (infer U)[] ? DeepPartial<U>[] : T extends object ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : T;
+/**
+ * Chart type names accepted by create/update model patches.
+ * Aliases are accepted and validation normalizes them:
+ * `doughnut` -> `donut`, `combo` -> `combination`.
+ */
+/**
+ * Chart type names returned by readback APIs. `unsupported` is only used when an
+ * existing ChartModel has a raw type that this semantic API cannot edit safely.
+ */
+export type ChartTypeName = ChartKnownTypeName | typeof import('./chart-type-registry').UNSUPPORTED_CHART_TYPE_NAME;
+export type { ChartKnownTypeName } from './chart-type-manifest';
+export type ChartTitleSpec = string | {
+    text?: string;
+    visible?: boolean;
+    position?: 'top' | 'bottom' | 'left' | 'right';
+    alignment?: 'left' | 'center' | 'right';
+    fontSize?: number;
+    color?: string;
+    bold?: boolean;
+};
+export type ChartLegendSpec = boolean | {
+    visible?: boolean;
+    position?: 'top' | 'bottom' | 'left' | 'right';
+    selectMode?: 'single' | 'multiple' | 'close';
+    fontSize?: number;
+    color?: string;
+    bold?: boolean;
+    italic?: boolean;
+};
+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?: 'inside' | 'outside';
+    };
+    format?: string | null;
+    titleStyle?: {
+        color?: string;
+        fontSize?: number;
+        bold?: boolean;
+        italic?: boolean;
+        family?: string;
+    };
+    label?: {
+        visible?: boolean;
+        color?: string;
+        fontSize?: number;
+        rotate?: number;
+    };
+    gridLine?: {
+        visible?: boolean;
+        color?: string;
+        width?: number;
+    };
+}
+export type ChartAxisSpec = IChartAxisSpec;
+export interface IChartAxesSpec {
+    x?: ChartAxisSpec;
+    y?: ChartAxisSpec;
+    rightY?: Omit<ChartAxisSpec, 'reverse'>;
+}
+export type ChartAxesSpec = IChartAxesSpec;
+export type ChartSeriesSelector = {
+    /**
+     * Preferentially matches IChartDataSeries.index. When no series data is
+     * available, builders treat it as an already-resolved series array position.
+     */
+    index: number;
+} | {
+    name: string;
+};
+export interface IChartSeriesPatch {
+    selector: ChartSeriesSelector;
+    name?: string;
+    type?: 'column' | 'line' | 'area';
+    color?: string;
+    fillOpacity?: number;
+    border?: {
+        color?: string | null;
+        width?: number;
+        opacity?: number;
+        dashType?: ChartBorderDashType;
+    };
+    point?: {
+        shape?: LinePointShape;
+        size?: number;
+        color?: string | null;
+    };
+    rightAxis?: boolean;
+    label?: {
+        visible?: boolean;
+        position?: 'top' | 'bottom' | 'inside' | 'outside';
+        contentType?: LabelContentType;
+        color?: string;
+        fontSize?: number;
+        bold?: boolean;
+        italic?: boolean;
+    };
+    dataPoints?: Record<number, {
+        shape?: LinePointShape;
+        size?: number;
+        color?: string | null;
+        fillOpacity?: number;
+    }>;
+}
+export type ChartSeriesPatch = IChartSeriesPatch;
+export interface IChartWordCloudSpec {
+    shape?: WordCloudShapeEnum;
+    maskImageId?: string | null;
+    repeat?: boolean;
+}
+export type ChartWordCloudSpec = IChartWordCloudSpec;
+export interface IChartWordCloudDescription {
+    shape?: WordCloudShapeEnum;
+    maskImageId?: string;
+    repeat?: boolean;
+    effectiveShapeSource: 'shape' | 'maskImage';
+}
+export type ChartWordCloudDescription = IChartWordCloudDescription;
+export interface IChartAppearanceSpec {
+    background?: {
+        color?: string | null;
+        gradient?: boolean;
+    };
+    border?: {
+        color?: string | null;
+        width?: number;
+    };
+    font?: {
+        color?: string;
+        size?: number;
+        family?: string;
+    };
+}
+export type ChartAppearanceSpec = IChartAppearanceSpec;
+/**
+ * Selects source fields for an explicit Scatter mapping.
+ *
+ * `xIndex` and `yIndex` are required, distinct indexes into the chart source.
+ * `labelIndex` is optional. Any mapped row with a non-finite x or y value makes
+ * the complete point source invalid. Omitting `mapping.scatter` preserves the
+ * established inferred Scatter behavior.
+ *
+ * @example
+ * ```ts
+ * mapping: {
+ *   scatter: { labelIndex: 0, xIndex: 1, yIndex: 2 }
+ * }
+ * ```
+ */
+export interface IChartScatterMappingSpec {
+    xIndex: number;
+    yIndex: number;
+    labelIndex?: number;
+}
+/**
+ * Selects source fields for an explicit Bubble mapping.
+ *
+ * `xIndex` and `yIndex` are required and distinct. Labels, size values, and
+ * series grouping are optional. Any mapped row with a non-finite x or y value
+ * makes the complete point source invalid. Omitting `mapping.bubble` preserves
+ * the established inferred Bubble behavior.
+ *
+ * @example
+ * ```ts
+ * mapping: {
+ *   bubble: {
+ *     labelIndex: 0,
+ *     xIndex: 1,
+ *     yIndex: 2,
+ *     sizeIndex: 3,
+ *     seriesIndex: 4
+ *   }
+ * }
+ * ```
+ */
+export interface IChartBubbleMappingSpec extends IChartScatterMappingSpec {
+    sizeIndex?: number;
+    seriesIndex?: number;
+}
+export interface IChartMappingSpec {
+    categoryIndex?: number | null;
+    /**
+     * Logical source-field indexes selected as chart measures.
+     * For WordCloud, `seriesIndexes[0]` is the single numeric weight measure;
+     * `categoryIndex` selects the term field.
+     */
+    seriesIndexes?: number[] | null;
+    useDateAxis?: boolean | null;
+    scatter?: IChartScatterMappingSpec;
+    bubble?: IChartBubbleMappingSpec;
+}
+export type ChartMappingSpec = IChartMappingSpec;
+export interface IChartAggregationSpec {
+    aggregate?: boolean;
+    topN?: number | null;
+}
+export type ChartAggregationSpec = IChartAggregationSpec;
+export interface IChartPieSpec {
+    doughnutHole?: number | null;
+    /** Slice offset as a ratio of the pie radius. */
+    explosion?: number;
+    borderColor?: string;
+    hasPaddingAngle?: boolean;
+    isHalfPie?: boolean;
+    rosePie?: boolean;
+    showLabelLine?: boolean;
+    valueScale?: number;
+    valueSuffix?: string;
+    digitalFixed?: number;
+    label?: {
+        visible?: boolean;
+        position?: 'inside' | 'outside';
+        contentType?: LabelContentType;
+        color?: string;
+        fontSize?: number;
+        bold?: boolean;
+        italic?: boolean;
+    };
+}
+export type ChartPieSpec = IChartPieSpec;
+export interface IChartRadarSpec {
+    shape?: RadarShape;
+    fill?: boolean;
+}
+export type ChartRadarSpec = IChartRadarSpec;
+/**
+ * Pareto-specific persisted options. The descending bars, cumulative-percentage
+ * line, and secondary percentage axis are chart invariants, not configuration.
+ */
+export interface IChartParetoSpec {
+    /** Omitted keeps the current color; null clears it back to the theme default. */
+    barColor?: string | null;
+    /** Omitted keeps the current color; null clears it back to the theme default. */
+    cumulativeLineColor?: string | null;
+    /**
+     * Whether zero-valued categories remain in the Pareto bars and cumulative line.
+     * Defaults to false. For values [5, 0, -2], false keeps [5], while true keeps
+     * [5, 0]; negative values are always excluded and zeros sort after positives.
+     */
+    includeZeroValues?: boolean;
+}
+export type ChartParetoSpec = IChartParetoSpec;
+/**
+ * Escape hatch for engine-level style groups not covered by semantic fields.
+ * Prefer title/legend/axes/series/etc. when a semantic field exists.
+ */
+export type ChartAdvancedStylePatch = DeepPartial<Pick<ChartStyle, 'tooltip' | 'area' | 'funnel' | 'relation' | 'waterfall'>>;
+/**
+ * Model-only create spec. Host source, drawing layout, and command execution stay
+ * in the sheet/slide adapter layer.
+ */
+export interface IChartModelCreateSpec {
+    type: ChartKnownTypeName;
+    title?: ChartTitleSpec;
+    legend?: ChartLegendSpec;
+    axes?: ChartAxesSpec;
+    series?: ChartSeriesPatch[];
+    wordCloud?: ChartWordCloudSpec;
+    appearance?: ChartAppearanceSpec;
+    mapping?: ChartMappingSpec;
+    aggregation?: ChartAggregationSpec;
+    pie?: ChartPieSpec;
+    radar?: ChartRadarSpec;
+    pareto?: ChartParetoSpec;
+    advancedStyle?: ChartAdvancedStylePatch;
+    theme?: string;
+}
+export type ChartModelCreateSpec = IChartModelCreateSpec;
+/**
+ * Model-only patch. It can cover every supported model semantic field, while
+ * omitted fields and `undefined` mean no change. `null` clears the value where
+ * the field explicitly supports clearing.
+ */
+export interface IChartModelPatch {
+    type?: ChartKnownTypeName;
+    title?: ChartTitleSpec;
+    legend?: ChartLegendSpec;
+    axes?: ChartAxesSpec;
+    series?: ChartSeriesPatch[];
+    wordCloud?: ChartWordCloudSpec;
+    appearance?: ChartAppearanceSpec;
+    mapping?: ChartMappingSpec;
+    aggregation?: ChartAggregationSpec;
+    pie?: ChartPieSpec;
+    radar?: ChartRadarSpec;
+    pareto?: ChartParetoSpec;
+    advancedStyle?: ChartAdvancedStylePatch;
+    theme?: string;
+}
+export type ChartModelPatch = IChartModelPatch;
+export interface IChartModelDiagnostic {
+    code: ChartModelDiagnosticCode;
+    severity: 'error' | 'warning';
+    message: string;
+    path?: string;
+    details?: unknown;
+    allowedValues?: readonly unknown[];
+    suggestion?: string;
+}
+export type ChartModelDiagnostic = IChartModelDiagnostic;
+export interface IChartValidationResult<TNormalized = unknown> {
+    ok: boolean;
+    diagnostics: ChartModelDiagnostic[];
+    normalized?: DeepReadonly<TNormalized>;
+}
+export type ChartValidationResult<TNormalized = unknown> = IChartValidationResult<TNormalized>;
+/**
+ * Patch to pass into the host adapter's chart config command.
+ *
+ * Do not JSON-roundtrip this object before applying it. `undefined` inside
+ * context/dataAggregation can be an intentional clear signal for command merge
+ * semantics, not just an absent field.
+ */
+export interface IChartModelConfigPatch {
+    chartType?: ChartTypeBits;
+    style?: ChartStyle;
+    context?: IChartContext;
+    dataAggregation?: Partial<IChartDataAggregation>;
+}
+export type ChartModelConfigPatch = IChartModelConfigPatch;
+export interface IChartModelUpdateResult<TChanged extends string = ChartModelChangedGroup, TDiagnostic = ChartModelDiagnostic> {
+    ok: boolean;
+    diagnostics: TDiagnostic[];
+    /** Model config groups touched by configPatch; source/layout are adapter-owned. */
+    changed: TChanged[];
+    /** Absent when the update is valid but produces no model config change. */
+    configPatch?: ChartModelConfigPatch;
+}
+export type ChartModelUpdateResult<TChanged extends string = ChartModelChangedGroup, TDiagnostic = ChartModelDiagnostic> = IChartModelUpdateResult<TChanged, TDiagnostic>;
+export interface IChartModelPatchSemantics {
+    omitted: ChartModelPatchSemantic.NoChange;
+    undefined: ChartModelPatchSemantic.NoChange;
+    null: ChartModelPatchSemantic.ClearWhereSupported;
+    object: ChartModelPatchSemantic.SemanticMerge;
+    array: ChartModelPatchSemantic.ReplaceUnlessSelectorMerge;
+    unknownField: ChartModelPatchSemantic.ValidationError;
+}
+export type ChartModelPatchSemantics = IChartModelPatchSemantics;
+export interface IChartCapabilities {
+    version: string;
+    chartTypes: readonly ChartKnownTypeName[];
+    patchSemantics: ChartModelPatchSemantics;
+    createGroups: readonly ChartModelPatchGroup[];
+    updateGroups: readonly ChartModelPatchGroup[];
+    styleGroups: readonly ChartModelPatchGroup[];
+    advancedStyle: {
+        supported: boolean;
+    };
+}
+export type ChartModelCapabilities = IChartCapabilities;
+export interface IChartModelInstanceCapabilities extends IChartCapabilities {
+    chartId: string;
+    type: ChartTypeName;
+    rawType?: number;
+    unsupportedGroups: readonly ChartModelPatchGroup[];
+}
+export type ChartModelInstanceCapabilities = IChartModelInstanceCapabilities;
+export interface IChartSeriesDescription {
+    index: number;
+    name: string;
+    type?: 'column' | 'line' | 'area';
+    color?: string | null;
+    fillOpacity?: number;
+    border?: ChartSeriesPatch['border'];
+    point?: ChartSeriesPatch['point'];
+    rightAxis?: boolean;
+    label?: {
+        visible?: boolean;
+        position?: 'top' | 'bottom' | 'inside' | 'outside';
+        contentType?: LabelContentType;
+        color?: string;
+        fontSize?: number;
+        bold?: boolean;
+        italic?: boolean;
+    };
+    dataPoints?: ChartSeriesPatch['dataPoints'];
+    data?: DeepReadonly<IChartDataSeries>;
+}
+export type ChartSeriesDescription = IChartSeriesDescription;
+export interface IChartModelDescription {
+    id: string;
+    type: ChartTypeName;
+    rawType?: number;
+    diagnostics?: ChartModelDiagnostic[];
+    title?: ChartTitleSpec;
+    legend?: ChartLegendSpec;
+    axes?: ChartAxesSpec;
+    wordCloud?: ChartWordCloudDescription;
+    appearance?: ChartAppearanceSpec;
+    mapping?: ChartMappingSpec;
+    aggregation?: ChartAggregationSpec;
+    pie?: ChartPieSpec;
+    radar?: ChartRadarSpec;
+    pareto?: ChartParetoSpec;
+    series: ChartSeriesDescription[];
+    category?: DeepReadonly<IChartDataCategory>;
+    theme?: string;
+    /**
+     * Frozen cloned readback for fields not yet represented by semantic
+     * description fields. Treat this as an escape hatch, not update input.
+     */
+    rawStyle?: DeepReadonly<ChartStyle>;
+}
+export type ChartModelDescription = IChartModelDescription;
+/**
+ * Stateless semantic operations for an existing ChartModel.
+ *
+ * This API never resolves host source/layout and never executes commands.
+ * update() only builds a configPatch; sheet/slide adapters decide how to apply it.
+ */
+export interface IChartModelApi {
+    describe(chartModel: ChartModel): ChartModelDescription;
+    /** Static capabilities of the model API, independent of any chart instance. */
+    getCapabilities(): ChartModelCapabilities;
+    /** Capabilities plus readback for one existing chart model. */
+    getInstanceCapabilities(chartModel: ChartModel): ChartModelInstanceCapabilities;
+    /**
+     * Validates patch shape, enums, and scalar ranges only. Selectors that depend
+     * on current chart data are resolved by update(), so a valid patch can still
+     * fail when applied to a specific ChartModel.
+     */
+    validatePatch(patch: ChartModelPatch): ChartValidationResult<ChartModelPatch>;
+    /**
+     * Builds a model config patch for an existing ChartModel without mutating it.
+     * The returned configPatch is applied by host adapters through their command layer.
+     */
+    update(chartModel: ChartModel, patch: ChartModelPatch): ChartModelUpdateResult;
+}
+export type ChartModelApi = IChartModelApi;

package/lib/types/chart-model-api/utils.d.ts

@@ -0,0 +1,10 @@
+import type { ChartModelDiagnostic, ChartValidationResult } from './types';
+export declare function createChartModelDiagnostic(code: ChartModelDiagnostic['code'], message: string, path?: string, severity?: ChartModelDiagnostic['severity'], details?: unknown, metadata?: Pick<ChartModelDiagnostic, 'allowedValues' | 'suggestion'>): ChartModelDiagnostic;
+export declare function hasChartModelDiagnosticError(diagnostics: ChartModelDiagnostic[]): boolean;
+export declare function validateKnownKeys(value: unknown, allowedKeys: ReadonlySet<string>, diagnostics: ChartModelDiagnostic[], path?: string): void;
+export declare function setIfDefined(target: Record<string, any>, path: string, value: unknown): void;
+export declare function setContextIfDefined(target: Record<string, any>, key: string, value: unknown): void;
+export declare function deepAssign(target: Record<string, any>, source: Record<string, any>): void;
+export declare function cloneReadonly<T>(value: T): T;
+export declare function deepFreeze<T>(value: T): T;
+export declare function okResult<TNormalized>(diagnostics: ChartModelDiagnostic[], normalized: TNormalized): ChartValidationResult<TNormalized>;

package/lib/types/chart-model-api/validate.d.ts

@@ -0,0 +1,5 @@
+import type { ChartModelCreateSpec, ChartModelDiagnostic, ChartModelPatch, ChartValidationResult } from './types';
+import { ChartModelPatchGroup } from './constants';
+export declare function validateChartModelCreateSpec(spec: ChartModelCreateSpec): ChartValidationResult<ChartModelCreateSpec>;
+export declare function validateChartModelPatch(patch: ChartModelPatch, effectiveType?: string): ChartValidationResult<ChartModelPatch>;
+export declare function validateChartModelSupportedGroups(patch: ChartModelCreateSpec | ChartModelPatch, supportedGroups: readonly ChartModelPatchGroup[], diagnostics: ChartModelDiagnostic[], ignoreRequiredType?: boolean): void;

package/lib/types/enum.d.ts

@@ -389,3 +389,11 @@ export declare enum WaterfallSeriesTypeEnum {
     negative = 8,
     subtotal = 16
 }
+export declare enum ParetoSeriesIndex {
+    Bar = 0,
+    Line = 1
+}
+export declare enum ParetoSeriesPart {
+    Bar = "bar",
+    Line = "line"
+}

package/lib/types/f-base-chart.d.ts

@@ -0,0 +1,25 @@
+import type { ChartModelChangedGroup, ChartModelDescription, ChartModelDiagnostic, ChartModelPatch, ChartModelUpdateResult } from './chart-model-api';
+import type { IChartRenderModelImageExportOptions, IChartRenderModelImageExportResult } from './types';
+export type FChartDescription<TIdentity extends object, TDataSource> = {
+    identity: TIdentity;
+    dataSource: TDataSource;
+};
+export type FAnyChartDescription = ChartModelDescription & FChartDescription<object, unknown>;
+export type FChartUpdateResult<TChart = unknown, TChanged extends string = ChartModelChangedGroup, TDiagnostic = ChartModelDiagnostic> = ChartModelUpdateResult<TChanged, TDiagnostic> & {
+    chart: TChart | null;
+};
+export declare abstract class FBaseChart<TDescription extends object = FAnyChartDescription, TUpdateResult extends FChartUpdateResult<unknown, string, unknown> = FChartUpdateResult> {
+    abstract getId(): string;
+    abstract describe(): TDescription | null;
+    abstract update(patch: ChartModelPatch): Promise<TUpdateResult>;
+    abstract exportImage(options?: IChartRenderModelImageExportOptions): Promise<IChartRenderModelImageExportResult | null>;
+    abstract remove(): Promise<boolean>;
+}
+export declare abstract class FBaseCharts<TChart extends FBaseChart<object, FChartUpdateResult<unknown, string, unknown>>, TCreateSpec, TCapabilities> {
+    abstract create(spec: TCreateSpec): Promise<TChart>;
+    abstract get(id: string): TChart | null;
+    abstract list(): TChart[];
+    abstract update(chart: TChart | string, patch: ChartModelPatch): ReturnType<TChart['update']>;
+    abstract remove(chart: TChart | string): Promise<boolean>;
+    abstract getCapabilities(): TCapabilities;
+}

package/lib/types/index.d.ts

@@ -1,32 +1,135 @@
-export { AreaLineStyle, AxisAlignEnum, AxisValueType, CategoryType, ChartAttributeBits, ChartBorderDashType, ChartSourceDataTypeEnum, ChartTrendlineType, ChartTypeBits, DataOrientation, InvalidValueType, IRuntimeAxisPosition, IRuntimeAxisPriority, LabelAlignEnum, LabelContentType, LegendPositionEnum, LinePointShape, PieLabelPosition, RadarShape, RelationChartLayoutEnum, SelectModeEnum, SeriesLabelPosition, StackType, TextAlign, TextVerticalAlign, TitlePositionEnum, WaterfallSeriesTypeEnum, WaterfallStackTypeEnum, WordCloudShapeEnum, } from './enum';
-export { buildChartData } from './models/chart-data-operators/build-chart-data';
-export { defaultChartContextOperators, findCategoryIndexes, findSeriesOperator, generateChartModelContextByOperators, inferChartContextOperator, pieSeriesFilterOperator, } from './models/chart-data-operators/operators';
+export { chartModelApi } from './chart-model-api/chart-model-api';
+export { buildDonutStyle } from './chart-model-api/chart-type';
+export { chartTypeBitsToName } from './chart-model-api/chart-type';
+export { chartTypeNameToBits } from './chart-model-api/chart-type';
+export { UNSUPPORTED_CHART_TYPE_NAME } from './chart-model-api/chart-type-registry';
+export { CHART_MODEL_API_CAPABILITIES_VERSION } from './chart-model-api/constants';
+export { CHART_MODEL_DEFAULT_DONUT_HOLE } from './chart-model-api/constants';
+export { CHART_MODEL_PATCH_SEMANTICS } from './chart-model-api/constants';
+export { CHART_MODEL_UNSUPPORTED_TYPE_SUGGESTION } from './chart-model-api/constants';
+export { ChartModelChangedGroup } from './chart-model-api/constants';
+export { ChartModelDiagnosticCode } from './chart-model-api/constants';
+export { ChartModelPatchGroup } from './chart-model-api/constants';
+export { ChartModelPatchSemantic } from './chart-model-api/constants';
+export { buildChartModelConfigPatch, buildCreateChartModelConfigPatch } from './chart-model-api/patch-builder';
+export type { ChartAdvancedStylePatch } from './chart-model-api/types';
+export type { ChartAggregationSpec } from './chart-model-api/types';
+export type { ChartAppearanceSpec } from './chart-model-api/types';
+export type { ChartAxesSpec } from './chart-model-api/types';
+export type { ChartAxisSpec } from './chart-model-api/types';
+export type { ChartKnownTypeName } from './chart-model-api/types';
+export type { ChartLegendSpec } from './chart-model-api/types';
+export type { ChartMappingSpec } from './chart-model-api/types';
+export type { ChartModelApi } from './chart-model-api/types';
+export type { ChartModelCapabilities } from './chart-model-api/types';
+export type { ChartModelConfigPatch } from './chart-model-api/types';
+export type { ChartModelCreateSpec } from './chart-model-api/types';
+export type { ChartModelDescription } from './chart-model-api/types';
+export type { ChartModelDiagnostic } from './chart-model-api/types';
+export type { ChartModelInstanceCapabilities } from './chart-model-api/types';
+export type { ChartModelPatch } from './chart-model-api/types';
+export type { ChartModelPatchSemantics } from './chart-model-api/types';
+export type { ChartModelUpdateResult } from './chart-model-api/types';
+export type { ChartParetoSpec } from './chart-model-api/types';
+export type { ChartPieSpec } from './chart-model-api/types';
+export type { ChartRadarSpec } from './chart-model-api/types';
+export type { ChartSeriesDescription } from './chart-model-api/types';
+export type { ChartSeriesPatch } from './chart-model-api/types';
+export type { ChartSeriesSelector } from './chart-model-api/types';
+export type { ChartTitleSpec } from './chart-model-api/types';
+export type { ChartTypeName } from './chart-model-api/types';
+export type { ChartValidationResult } from './chart-model-api/types';
+export type { ChartWordCloudDescription } from './chart-model-api/types';
+export type { ChartWordCloudSpec } from './chart-model-api/types';
+export type { DeepReadonly } from './chart-model-api/types';
+export { createChartModelDiagnostic } from './chart-model-api/utils';
+export { hasChartModelDiagnosticError } from './chart-model-api/utils';
+export { validateChartModelCreateSpec } from './chart-model-api/validate';
+export { validateChartModelPatch } from './chart-model-api/validate';
+export { AreaLineStyle, AxisAlignEnum, AxisValueType, CategoryType, ChartAttributeBits, ChartBorderDashType, ChartSourceDataTypeEnum, ChartTrendlineType, ChartTypeBits, DataOrientation, InvalidValueType, IRuntimeAxisPosition, IRuntimeAxisPriority, LabelAlignEnum, LabelContentType, LegendPositionEnum, LinePointShape, ParetoSeriesIndex, ParetoSeriesPart, PieLabelPosition, RadarShape, RelationChartLayoutEnum, SelectModeEnum, SeriesLabelPosition, StackType, TextAlign, TextVerticalAlign, TitlePositionEnum, WaterfallSeriesTypeEnum, WaterfallStackTypeEnum, WordCloudShapeEnum, } from './enum';
+export type { FAnyChartDescription, FChartDescription, FChartUpdateResult, } from './f-base-chart';
+export { FBaseChart, FBaseCharts, } from './f-base-chart';
+export { buildChartData, RelationColumnIndex } from './models/chart-data-operators/build-chart-data';
+export { CartesianPointRoleIndex, CartesianPointValueIndex } from './models/chart-data-operators/cartesian-point-data';
+export { defaultChartContextOperators, findCategoryIndexes, findCategoryOperator, findHeaderOperator, findSeriesOperator, generateChartModelContextByOperators, pieSeriesFilterOperator, } from './models/chart-data-operators/operators';
+export { CHART_HOST_DEFAULT_BORDER_COLOR, CHART_HOST_DEFAULT_BORDER_RADIUS, CHART_HOST_DEFAULT_BORDER_WIDTH, composeChartHostFrameImage, getChartHostFrameContentRect, resolveDefaultChartHostFrameStyle, resolveChartHostFrameStyle, shouldComposeChartHostFrame, } from './models/chart-host-style';
+export type { IResolveChartHostFrameStyleInput, IResolveDefaultChartHostFrameStyleInput, } from './models/chart-host-style';
 export type { IChartLocaleTexts } from './models/chart-locale-texts';
 export { getDefaultChartLocaleTexts, replaceLocaleParams } from './models/chart-locale-texts';
-export { ChartModel } from './models/chart-model';
-export { CHART_DEBOUNCE_TIME } from './models/chart-model';
-export { resolveChartRuntimeStyle, resolveChartStyleBackgroundColor } from './models/chart-runtime-style';
-export { ChartThemeService, registerChartThemeService } from './models/chart-theme.service';
+export { CHART_DEBOUNCE_TIME, ChartModel, } from './models/chart-model';
+export { resolveChartRenderModelImageExportInput } from './models/chart-render-input-resolver';
+export type { IChartRenderInputRuntime, IResolveChartRenderModelImageExportInputParams, } from './models/chart-render-input-resolver';
+export { ChartRenderModelManagerService, IChartRenderModelManagerService, registerChartRenderModelManagerService, } from './models/chart-render-model-manager.service';
+export { resolveChartRuntimeStyle, resolveChartStyleBackgroundColor, } from './models/chart-runtime-style';
+export { ChartThemeService, registerChartThemeService, } from './models/chart-theme.service';
 export { getThemeAxesByType } from './models/constants/build-in-theme';
 export { themeDefault, UniverTheme1, UniverTheme2, UniverTheme3, UniverTheme4, UniverTheme5, UniverTheme6, UniverThemeGradient1, UniverThemeGradient2, UniverThemeGradient3, UniverThemeGradient4, UniverThemeGradient5, UniverThemeGradient6, } from './models/constants/build-in-theme';
 export type { IEchartTheme } from './models/constants/build-in-theme';
 export { getThemeProps } from './models/constants/build-in-theme';
 export { defaultChartHeight, defaultChartWidth, EChartRenderEngineName } from './models/constants/default';
 export { defaultChartConfig, RTLChartStyle, themeColors } from './models/constants/default-chart-style';
-export { EChartRenderModel } from './models/echart-render-model';
+export { EChartRenderEngine, EChartRenderModel } from './models/echart-render-model';
 export type { IEChartRenderModelOptions } from './models/echart-render-model';
 export { echartToChartModelInit, isChartModelInit } from './models/echart-to-chart-model-init';
 export { chartImageSourceToDataUrl, ImageChartHost } from './models/image-chart-host';
 export type { IChartModelInitParams } from './models/mode-converter/mode-converter';
-export { convertModelFromInitData, convertModelToSpec, generateChartModelContext } from './models/mode-converter/mode-converter';
+export { convertModelFromInitData, convertModelToSpec, } from './models/mode-converter/mode-converter';
 export { OffscreenChartHost } from './models/offscreen-chart-host';
-export { registerWordCloudChartMakImageService, WordCloudMuskImageService } from './models/word-cloud-musk-image.service';
+export { registerWordCloudChartMakImageService, WordCloudMuskImageService, } from './models/word-cloud-musk-image.service';
 export { ChartDataSource } from './source/chart-source';
 export { StaticChartSource } from './source/static-chart-source';
-export { ChartImageSourceType } from './types';
-export type { ChartDataSourceValue, ChartDataSourceValues, ChartHostRenderMode, ChartImageSource, DimensionDefinitionLoose, IChartDataSource, IChartHost, IChartHostLease, IChartHostStyle, IChartRenderAsImageOptions, IChartRenderInput, IChartRenderInstance, IChartRenderInstanceCreateContext, IChartRenderInstanceSpecInput, IChartRenderInstanceStyleInput, IDimensionDefinition, IDomChartHost, IImageChartHost, IUniverDataSet, OptionDataValue, } from './types';
-export type { ChartDirection, ChartStyle, DeepPartial, IAllSeriesStyle, IAxisOptions, IChartConfig, IChartContext, IChartData, IChartDataAggregation, IChartDataCategory, IChartDataSeries, IChartHostRect, IChartInstance, IChartRenderModel, IChartSnapshot, IChartStyle, IGridLineStyle, ILabelStyle, ILegendStyle, IPieLabelStyle, IPointStyle, IRelationForceOptions, IRuntimeAxis, ISeriesLabelStyle, ISeriesStyle, ITrendLine, RightYAxisOptions, } from './types';
-export { chartBitsUtils, chartTypeCanUseTrendLine } from './util';
+export { ChartHostRenderMode, ChartImageSourceType } from './types';
+export type { ChartDataSourceValue, ChartDataSourceValues, ChartDirection, ChartElementEventHandler, ChartElementEventType, ChartElementKind, ChartImageSource, ChartStyle, DeepPartial, DimensionDefinitionLoose, IAllSeriesStyle, IAxisOptions, IChartConfig, IChartContext, IChartData, IChartDataAggregation, IChartDataCategory, IChartDataSeries, IChartDataSource, IChartElementBounds, IChartElementEvent, IChartElementHit, IChartElementOverlay, IChartHost, IChartHostBorderStyle, IChartHostLease, IChartHostRect, IChartHostStyle, IChartInstance, IChartRenderAsImageOptions, IChartRenderInput, IChartRenderInstance, IChartRenderInstanceCreateContext, IChartRenderInstanceSpecInput, IChartRenderInstanceStyleInput, IChartRenderModel, IChartRenderModelImageExportInput, IChartRenderModelImageExportOptions, IChartRenderModelImageExportResult, IChartSnapshot, IChartStyle, IDimensionDefinition, IDomChartHost, IGridLineStyle, IImageChartHost, ILabelStyle, ILegendStyle, IPieLabelStyle, IPointStyle, IRelationForceOptions, IRuntimeAxis, ISeriesLabelStyle, ISeriesStyle, ITrendLine, IUniverDataSet, OptionDataValue, RightYAxisOptions, } from './types';
+export { chartBitsUtils, chartTypeCanUseTrendLine, } from './util';
 export * from './utils/echarts';
 export { WordCloudResourceConfig } from './word-cloud-resource/word-cloud-resource-config';
-export * from './wordcloud-chart';
+export { WORD_CLOUD_DEFAULT_OPTION, WORD_CLOUD_SERIES_TYPE } from './wordcloud-chart/adapters/echarts/echarts-options';
+export { registerWordCloudChart } from './wordcloud-chart/adapters/echarts/install';
+export { layoutWordCloudChart } from './wordcloud-chart/canvas';
+export { resolveLayoutOptions } from './wordcloud-chart/canvas';
+export * from './wordcloud-chart/core/layout/font-scale';
+export { createBuiltinMaskGrid } from './wordcloud-chart/core/shape/built-in-shapes';
+export { createMaskGridFromShape } from './wordcloud-chart/core/shape/built-in-shapes';
+export { createTextMaskGrid } from './wordcloud-chart/core/shape/built-in-shapes';
+export { normalizeMaskGrid } from './wordcloud-chart/core/shape/built-in-shapes';
+export { segmentMaskGrid } from './wordcloud-chart/core/shape/built-in-shapes';
+export { encodeWordCloudWords } from './wordcloud-chart/core/text/formatter';
+export { normalizeWordCloudData } from './wordcloud-chart/core/text/normalize';
+export { DEFAULT_WORD_CLOUD_CHART_SPEC } from './wordcloud-chart/defaults';
+export { resolveWordCloudSpec } from './wordcloud-chart/defaults';
+export type { INormalizedWordCloudDatum } from './wordcloud-chart/types';
+export type { IResolvedWordCloudSpec } from './wordcloud-chart/types';
+export type { IWordCloudBounds } from './wordcloud-chart/types';
+export type { IWordCloudChartSpec } from './wordcloud-chart/types';
+export type { IWordCloudDataSource } from './wordcloud-chart/types';
+export type { IWordCloudEChartsMaskSource } from './wordcloud-chart/types';
+export type { IWordCloudEChartsSeriesDataItem } from './wordcloud-chart/types';
+export type { IWordCloudEChartsSeriesOption } from './wordcloud-chart/types';
+export type { IWordCloudEncodedWord } from './wordcloud-chart/types';
+export type { IWordCloudEncoding } from './wordcloud-chart/types';
+export type { IWordCloudFieldMapping } from './wordcloud-chart/types';
+export type { IWordCloudLayoutMask } from './wordcloud-chart/types';
+export type { IWordCloudLayoutOptions } from './wordcloud-chart/types';
+export type { IWordCloudLayoutResult } from './wordcloud-chart/types';
+export type { IWordCloudMaskGrid } from './wordcloud-chart/types';
+export type { IWordCloudMaskShapeSpec } from './wordcloud-chart/types';
+export type { IWordCloudPlacedWord } from './wordcloud-chart/types';
+export type { IWordCloudProtocolSpec } from './wordcloud-chart/types';
+export type { IWordCloudSegmentationRegion } from './wordcloud-chart/types';
+export type { IWordCloudSegmentationResult } from './wordcloud-chart/types';
+export type { IWordCloudSeriesDataItem } from './wordcloud-chart/types';
+export type { IWordCloudSeriesOption } from './wordcloud-chart/types';
+export type { IWordCloudSpecBase } from './wordcloud-chart/types';
+export type { IWordCloudTextMarkAttrs } from './wordcloud-chart/types';
+export type { IWordCloudTextMarkSpec } from './wordcloud-chart/types';
+export type { IWordCloudTextMeasurer } from './wordcloud-chart/types';
+export type { IWordCloudTextSprite } from './wordcloud-chart/types';
+export type { WordCloudFontSizeRange } from './wordcloud-chart/types';
+export type { WordCloudShape } from './wordcloud-chart/types';
+export { DEFAULT_WORD_CLOUD_SHAPE } from './wordcloud-chart/types';
+export { normalizeWordCloudShape } from './wordcloud-chart/types';
+export { SUPPORTED_WORD_CLOUD_SHAPES } from './wordcloud-chart/types';
+export { DEFAULT_WORD_CLOUD_RENDER_CONFIG } from './wordcloud-chart/word-cloud-render-config';
+export { resolveWordCloudRenderConfig } from './wordcloud-chart/word-cloud-render-config';
+export type { IResolvedWordCloudRenderConfig } from './wordcloud-chart/word-cloud-render-config';
+export type { IWordCloudRenderConfig } from './wordcloud-chart/word-cloud-render-config';