@univerjs-pro/engine-chart 0.25.0 → 1.0.0-alpha.0

package/lib/types/models/chart-runtime-axes.d.ts

@@ -0,0 +1,38 @@
+import type { ChartStyle, IChartContext, IRuntimeAxis } from '../types';
+import { ChartTypeBits } from '../enum';
+export interface IGetChartRuntimeAxesParams {
+    chartType: ChartTypeBits;
+    context?: Pick<IChartContext, 'categoryIndex' | 'seriesIndexes'>;
+    style?: ChartStyle;
+    direction?: ChartStyle['direction'];
+}
+/**
+ * Builds the transient axis model consumed by chart converters.
+ *
+ * Persisted `ChartStyle` axis options are semantic buckets, while converters and
+ * style operators consume axes by physical `position`, value `type`, and runtime
+ * `priority`. This function centralizes the mapping from chart type, data
+ * context, per-series secondary-axis switches, and document direction. The
+ * returned priorities are runtime-only roles and should not be treated as the
+ * persisted `yAxis` / `rightYAxis` bucket names.
+ *
+ * Cases handled here:
+ * - Heatmap always returns two text axes because both dimensions come from
+ *   `heatmapData`; the vertical axis is left in LTR and right in RTL, while the
+ *   bottom axis remains text.
+ * - Horizontal bar charts use a vertical primary category axis, left in LTR and
+ *   right in RTL, plus a numeric bottom axis. If the normal source context has
+ *   no category, the category axis is still kept so ECharts can use implicit
+ *   row-index categories and every cartesian series has both axes.
+ * - Scatter and bubble charts use a numeric bottom axis instead of a category
+ *   bottom axis. Their vertical value axis still follows the normal RTL and
+ *   secondary-axis visibility rules.
+ * - Other vertical category/value charts use a bottom text axis when a category
+ *   exists. Their left/right value axes are derived from
+ *   `allSeriesStyle.rightYAxis` and `seriesStyleMap[*].rightYAxis`; RTL merges
+ *   `RTLChartStyle` first so the default value axis is physical right unless a
+ *   user override brings the left axis back.
+ * - Pareto keeps its Excel-like sorted layout. RTL does not apply default axis
+ *   mirroring, and the right value axis is always available.
+ */
+export declare function getChartRuntimeAxes(params: IGetChartRuntimeAxesParams): IRuntimeAxis[];

package/lib/types/models/chart-runtime-style.d.ts

@@ -0,0 +1,12 @@
+import type { ChartStyle } from '../types';
+import { ChartTypeBits } from '../enum';
+/**
+ * Converts persisted semantic chart style buckets into transient render buckets.
+ *
+ * Persisted `style.yAxis` is the primary vertical axis configuration, and
+ * `style.rightYAxis` is the secondary vertical axis configuration. RTL can draw
+ * the primary vertical axis on the physical right, but that must not change the
+ * saved field names. This resolver swaps y-axis option/title buckets only in
+ * the runtime render style consumed by physical-position operators.
+ */
+export declare function resolveChartRuntimeStyle(style: ChartStyle, chartType?: ChartTypeBits): ChartStyle;

package/lib/types/{model → models}/constants/default-chart-style.d.ts

@@ -1,5 +1,7 @@
-import { AreaLineStyle, AxisAlignEnum, ChartBorderDashType, ChartTypeBits, InvalidValueType, LabelContentType, LegendPositionEnum, LinePointShape, PieLabelPosition, RadarShape, SelectModeEnum, SeriesLabelPosition, TextAlign, TitlePositionEnum, WaterfallStackTypeEnum } from '../../enum';
+import type { ChartStyle } from '../../types';
+import { AreaLineStyle, AxisAlignEnum, ChartBorderDashType, ChartTypeBits, InvalidValueType, LabelContentType, LegendPositionEnum, LinePointShape, PieLabelPosition, RadarShape, SelectModeEnum, SeriesLabelPosition, TextAlign, TitlePositionEnum, WaterfallStackTypeEnum, WordCloudShapeEnum } from '../../enum';
 export declare const themeColors: string[];
+export declare const RTLChartStyle: ChartStyle;
 export declare const defaultChartConfig: {
     allSeriesId: string;
     invalidValueType: InvalidValueType;
@@ -68,7 +70,7 @@ export declare const defaultChartConfig: {
         areaOpacity: number;
     };
     wordCloud: {
-        maskImage: string;
+        shape: WordCloudShapeEnum;
         repeat: boolean;
     };
     waterfall: {

package/lib/types/{model → models}/echart-render-model.d.ts

@@ -1,10 +1,15 @@
 import type { ChartStyle, EChartInstance, EChartSpec, IChartConfig, IChartHostRect, IChartInstance, IChartRenderModel, IChartRenderModelStylizeInit } from '../types';
+import type { IWordCloudRenderConfig } from '../wordcloud-chart/word-cloud-render-config';
 import { Disposable } from '@univerjs/core';
+export interface IEChartRenderModelOptions {
+    wordCloudRenderConfig?: IWordCloudRenderConfig;
+}
 export declare class EChartRenderModel extends Disposable implements IChartRenderModel {
     private _specConverters;
     private _specOperators;
     private _addWatermark;
-    constructor(_addWatermark: boolean);
+    private readonly _wordCloudRenderConfig?;
+    constructor(_addWatermark: boolean, options?: IEChartRenderModelOptions);
     updateWatermark(addWatermark: boolean): void;
     private _addSpecConverters;
     private _addSpecOperators;

package/lib/types/models/mode-converter/converters/word-cloud-converter.d.ts

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

package/lib/types/{model → models}/mode-converter/mode-converter.d.ts

@@ -53,7 +53,7 @@ export interface IChartModelInitParams {
     isRowDirection?: boolean;
     localeTexts?: IChartLocaleTexts;
 }
-export declare function generateChartModelContext(chartModel: ChartModel, dataSource: StaticChartSource): IChartContext | null;
+export declare function generateChartModelContext(chartModel: ChartModel, dataSource: StaticChartSource): IChartContext;
 /**
  * Convert the initial data to a chart model.
  * @param initJson The initial data of the chart model.
@@ -66,7 +66,7 @@ export declare function generateChartModelContext(chartModel: ChartModel, dataSo
  * const inject = sheet.getInject(); *
  * const data = {
  *     dimensions: ['a', 'b', 'c'],
- *     source: [['test', 1, 3], ['test1', 2, 2], ['tes2', 3, 1], ['test3', 4, 4], ]
+ *     source: [['test', 1, 3], ['test1', 2, 2], ['tes2', 3, 1], ['test3', 4, 4]]
  * } *
  * const initData = {
  *     chartType: 4,

package/lib/types/models/mode-converter/render-spec-operators/implicit-category-axis.operator.d.ts

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

package/lib/types/{model → models}/mode-converter/render-spec-operators/index.d.ts

@@ -3,10 +3,12 @@ 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 { implicitCategoryAxisOperator } from './implicit-category-axis.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 { rtlRenderSpecOperator } from './rtl-render-spec.operator';
 export { seriesStyleOperator } from './series-style-operator/series-style-operator';
 export { stackOperator } from './stack.operator';
 export { chartThemeOperator } from './theme.operator';

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

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

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

@@ -0,0 +1,37 @@
+import type { ChartDirection, ChartStyle, EChartRenderSpecOperator, EChartSpec, IChartConfig } from '../../../types';
+import { InvalidValueType } from '../../../enum';
+interface ITooltipFormatterDataContext {
+    category: IChartConfig['category'];
+    xAxisFormat: ChartStyle['xAxis'] extends infer T ? T extends {
+        format?: infer F;
+    } ? F : undefined : undefined;
+    invalidValueType: InvalidValueType;
+    blankText: string;
+    minText: string;
+    q1Text: string;
+    medianText: string;
+    q3Text: string;
+    maxText: string;
+    wordText: string;
+    frequencyText: string;
+    isDateAxis: boolean | undefined;
+    allSeriesStyle: ChartStyle['allSeriesStyle'];
+    seriesStyleMap: ChartStyle['seriesStyleMap'];
+    runtimeThemeColors: string[];
+    relationNodeMap: Map<string, string>;
+    negativeMap: Map<string, boolean>;
+    getRenderColor: (color: string) => string;
+}
+interface ITooltipFormatters {
+    axis: (params: any) => string;
+    item: (params: any) => string;
+    radar: (params: any) => string;
+    wordCloud: (params: any) => string;
+}
+export declare function excelDateToUnixMilliseconds(excelDate: number, useDefault1900DateSystem?: boolean): number;
+export declare function createTooltipFormatterDataContext(spec: EChartSpec, style: ChartStyle, config: IChartConfig): ITooltipFormatterDataContext;
+export declare function createLTRTooltipFormatters(context: ITooltipFormatterDataContext, config: IChartConfig): ITooltipFormatters;
+export declare function createRTLTooltipFormatters(context: ITooltipFormatterDataContext, config: IChartConfig): ITooltipFormatters;
+export declare function createTooltipFormatters(context: ITooltipFormatterDataContext, config: IChartConfig, direction: ChartDirection): ITooltipFormatters;
+export declare const toolTipStyleOperator: EChartRenderSpecOperator;
+export {};

package/lib/types/models/mode-converter/render-spec-operators/tool-tip-renderer.d.ts

@@ -0,0 +1,15 @@
+import type { ChartDirection } from '../../../types';
+export declare const tooltipBaseCss = "max-width: 280px; white-space: nowrap; text-overflow: ellipsis; overflow: hidden;";
+export declare const rtlTooltipCss = "direction:rtl;text-align:right;";
+export declare function getTooltipExtraCss(backgroundColor: string, direction: ChartDirection): string;
+export declare function getLTRTooltipMarker(color: string): string;
+export declare function getRTLTooltipMarker(color: string): string;
+export declare function normalizeRTLTooltipMarker(marker: string | undefined): string;
+export declare function wrapTooltipAutoDirection(content: string): string;
+export declare function wrapTooltipLTRDirection(content: string): string;
+export declare function renderRTLTooltipRow(content: string): string;
+export declare function renderRTLTooltipBlock(rows: string[]): string;
+export declare function renderRTLTitleRow(content: string): string;
+export declare function renderRTLMarkerTextRow(text: string, marker?: string): string;
+export declare function renderRTLValueLabelRow(label: string, value: unknown, marker?: string, boldValue?: boolean): string;
+export declare function renderRTLEdgeRow(sourceName: string, targetName: string, value: unknown, marker?: string): string;

package/lib/types/{model → models}/word-cloud-musk-image.service.d.ts

@@ -5,7 +5,7 @@ export declare class WordCloudMuskImageService extends Disposable {
     constructor();
     loadMuskImage(name: string, url: string): void;
     loadMuskImages(): void;
-    getWordCloudImageMask(imgName: string): HTMLImageElement | undefined;
+    getWordCloudImageMask(imageName: string): HTMLImageElement | undefined;
     getWordCloudImageMaskMap(): Map<string, HTMLImageElement>;
     dispose(): void;
 }

package/lib/types/source/option-data-value.d.ts

@@ -0,0 +1,3 @@
+import type { OptionDataValue } from '../types';
+import { ChartSourceDataTypeEnum } from '../enum';
+export declare function inferOptionSourceType(value: OptionDataValue | boolean): ChartSourceDataTypeEnum;

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

@@ -1,6 +1,6 @@
 import type { OptionDataValue } from '../types';
 import { ChartSourceDataTypeEnum } from '../enum';
-export declare function getCategoryData(source: OptionDataValue[][], categoryIndex: number, isRowDirection: boolean, sourceType: ChartSourceDataTypeEnum[][]): {
-    categoryData: OptionDataValue[];
+export declare function getCategoryData(source: OptionDataValue[][], categoryIndex: number, isRowDirection: boolean, sourceType?: ChartSourceDataTypeEnum[][]): {
+    categoryData: Array<OptionDataValue | undefined>;
     isAllDateTime: boolean;
 };

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

@@ -6,6 +6,7 @@ export declare class StaticChartSource extends ChartDataSource {
     private _columnDirectionDataSetCache;
     constructor();
     initData(data: IUniverDataSet, isRowDirection?: boolean): void;
+    setData(data: IUniverDataSet): void;
     updateIsRowDirection(flag: boolean): void;
     refresh(): void;
     convertDataSet(): IUniverDataSet;

package/lib/types/types.d.ts

@@ -1,12 +1,14 @@
-import type { CellValue, IDisposable, Nullable } from '@univerjs/core';
+import type { IDisposable, Nullable } from '@univerjs/core';
 import type { Observable } from 'rxjs';
 import type { AreaLineStyle, AxisAlignEnum, AxisValueType, CategoryType, ChartBorderDashType, ChartSourceDataTypeEnum, ChartTrendlineType, ChartTypeBits, DataOrientation, InvalidValueType, IRuntimeAxisPosition, IRuntimeAxisPriority, LabelAlignEnum, LegendPositionEnum, LinePointShape, PieLabelPosition, RadarShape, RelationChartLayoutEnum, SelectModeEnum, SeriesLabelPosition, TitlePositionEnum, WaterfallSeriesTypeEnum, WaterfallStackTypeEnum, WordCloudShapeEnum } from './enum';
-import type { IEchartTheme } from './model/constants/build-in-theme';
-import type { IChartLocaleTexts } from './model/chart-locale-texts';
+import type { IChartLocaleTexts } from './models/chart-locale-texts';
+import type { IEchartTheme } from './models/constants/build-in-theme';
 import type { BarSeriesOption } from './utils/echarts';
+import type { IWordCloudRenderConfig } from './wordcloud-chart/word-cloud-render-config';
 export type DeepPartial<T> = T extends Record<string, any> ? T extends any[] ? T : {
     [key in keyof T]+?: DeepPartial<T[key]>;
 } : T;
+export type ChartDirection = 'ltr' | 'rtl';
 export interface IChartDataSource {
     data$: Observable<IUniverDataSet>;
     canSwitchOrient$: Observable<boolean>;
@@ -17,8 +19,6 @@ export interface IChartDataSource {
     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;
@@ -26,10 +26,13 @@ export interface IDimensionDefinition {
 }
 export type DimensionDefinitionLoose = IDimensionDefinition['name'] | IDimensionDefinition;
 export type OptionDataValue = string | number | Date | null | undefined;
+export type ChartDataSourceValue = OptionDataValue;
+export type ChartDataSourceValues = ChartDataSourceValue[][];
 export interface IUniverDataSet {
     source: OptionDataValue[][];
     dimensions: Array<DimensionDefinitionLoose>;
     sourceType?: ChartSourceDataTypeEnum[][];
+    sourceLabels?: string[][];
 }
 export interface IChartContext {
     headers?: string[];
@@ -163,6 +166,7 @@ export interface IChartRuntimeContext {
     themeColors?: string[];
     axes: IRuntimeAxis[];
     themeInfo: IEchartTheme;
+    wordCloudRenderConfig?: IWordCloudRenderConfig;
     /**
      * The function to transform the color to the render color with considering the system theme is dark mode or not.
      * @param {string} color - The color to be rendered.
@@ -175,7 +179,6 @@ export interface IChartRuntimeContext {
     isDarkMode: boolean;
     hasSecondaryAxis: boolean;
     localeTexts: IChartLocaleTexts;
-    wordCloudImageMaskMap: Map<string, HTMLImageElement>;
 }
 export interface ILabelStyle {
     visible: boolean;
@@ -238,6 +241,7 @@ export interface IDataPointStyle extends IPointStyle {
 }
 export interface ISeriesStyle {
     chartType?: ChartTypeBits.Line | ChartTypeBits.Column | ChartTypeBits.Area;
+    /** Compatibility switch for placing this series on the secondary vertical axis. It does not change the yAxis/rightYAxis option bucket semantics. */
     rightYAxis?: boolean;
     color: Nullable<string>;
     fillOpacity: number;
@@ -284,6 +288,8 @@ export interface ITrendLine {
 }
 export interface IChartStyle {
     runtime: IChartRuntimeContext;
+    /** Runtime-only locale direction. It must not be persisted in chart snapshots. */
+    direction: ChartDirection;
     width: number;
     height: number;
     theme: string;
@@ -298,13 +304,17 @@ export interface IChartStyle {
         title: Omit<ILabelStyle, 'visible'>;
         subtitle: Omit<ILabelStyle, 'visible'>;
         xAxisTitle: Omit<ILabelStyle, 'visible'>;
+        /** Primary vertical axis title. RTL may render it on the physical right, but it is still persisted here. */
         yAxisTitle: Omit<ILabelStyle, 'visible'>;
+        /** Secondary vertical axis title. */
         rightYAxisTitle: Omit<ILabelStyle, 'visible'>;
         titlePosition: TitlePositionEnum;
     };
     legend: ILegendStyle;
     xAxis: IAxisOptions;
+    /** Primary vertical axis options. This is a semantic bucket, not the physical left-axis bucket. */
     yAxis: IAxisOptions;
+    /** Secondary vertical axis options. Do not store RTL primary vertical axis edits here. */
     rightYAxis: RightYAxisOptions;
     allSeriesStyle: IAllSeriesStyle;
     seriesStyleMap: {
@@ -335,8 +345,8 @@ export interface IChartStyle {
         useAbsValue: boolean;
     };
     wordCloud: {
-        shape: WordCloudShapeEnum;
-        maskImage: string;
+        maskImage?: string;
+        shape?: WordCloudShapeEnum;
         repeat: boolean;
     };
     relation: {

package/lib/types/util.d.ts

@@ -3,9 +3,10 @@ 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" | "bar" | "scatter" | "pie" | "radar" | "graph" | "funnel" | "sankey" | "boxplot" | "heatmap" | "combination" | "wordCloud";
+    chartBitToString(bit: ChartTypeBits): "" | "line" | "wordCloud" | "bar" | "scatter" | "pie" | "radar" | "graph" | "funnel" | "sankey" | "boxplot" | "heatmap" | "combination";
 };
 export declare const setProperty: (data: Record<string, any>, propertyPath: string, value: any) => void;
+export declare const getProperty: <T = any>(data: Record<string, any> | undefined, propertyPath: string) => T | undefined;
 /**
  * Set graphic element to data.
  * because we use graphic element to draw watermark title, so we need to set it to data.

package/lib/types/utils/echarts.d.ts

@@ -1,4 +1,4 @@
-import { extendChartView, extendSeriesModel, format, getInstanceByDom, graphic, helper, init, List, number, registerLayout, registerPreprocessor, util } from 'echarts';
+import { extendChartView, extendSeriesModel, format, getInstanceByDom, graphic, helper, init, List, number, registerAction, registerLayout, registerPreprocessor, util } from 'echarts';
 export declare const echarts: {
     extendChartView: typeof extendChartView;
     extendSeriesModel: typeof extendSeriesModel;
@@ -9,6 +9,7 @@ export declare const echarts: {
     init: typeof init;
     List: typeof List;
     number: typeof number;
+    registerAction: typeof registerAction;
     registerLayout: typeof registerLayout;
     registerPreprocessor: typeof registerPreprocessor;
     util: typeof util;

package/lib/types/word-cloud-resource/word-cloud-shape-resource.d.ts

@@ -0,0 +1,5 @@
+import type { IWordCloudEChartsMaskSource, WordCloudShape } from '../wordcloud-chart/types';
+export declare const WORD_CLOUD_SHAPE_RESOURCE_KEYS: Partial<Record<WordCloudShape, string>>;
+export declare function getWordCloudShapeImageSources(): string[];
+export declare function resolveWordCloudShapeImageSource(shape: unknown): string | undefined;
+export declare function resolveWordCloudShapeMaskSource(shape: unknown): IWordCloudEChartsMaskSource;

package/lib/types/wordcloud-chart/adapters/echarts/chart-view.d.ts

@@ -0,0 +1,7 @@
+import type { echarts as EchartsType } from '../../../utils/echarts';
+import { WORD_CLOUD_SERIES_TYPE } from './echarts-options';
+export interface IRegisterWordCloudChartViewContext {
+    createTextElement(layout: any, data: any, dataIndex: number, seriesModel: any): unknown;
+}
+export declare function registerWordCloudChartView(echarts: typeof EchartsType, context: IRegisterWordCloudChartViewContext): void;
+export { WORD_CLOUD_SERIES_TYPE };

package/lib/types/wordcloud-chart/adapters/echarts/echarts-options.d.ts

@@ -0,0 +1,24 @@
+export declare const WORD_CLOUD_SERIES_TYPE = "wordCloud";
+export declare const WORD_CLOUD_DEFAULT_OPTION: {
+    readonly z: 2;
+    readonly maskSource: import("../..").IWordCloudEChartsMaskSource;
+    readonly colorBy: "data";
+    readonly keepAspect: false;
+    readonly left: "center";
+    readonly top: "center";
+    readonly width: "96%";
+    readonly height: "96%";
+    readonly right: null;
+    readonly bottom: null;
+    readonly fontSizeRange: readonly [16, 56];
+    readonly rotations: readonly [0, -45, 45, 90, -90];
+    readonly randomSeed: 1;
+    readonly gridSize: 4;
+    readonly padding: 1;
+    readonly zoomToFit: {
+        readonly shrink: true;
+        readonly enlarge: false;
+        readonly fontSizeLimitMin: 16;
+        readonly minShrinkRatio: 0.8;
+    };
+};

package/lib/types/wordcloud-chart/adapters/echarts/install.d.ts

@@ -0,0 +1,4 @@
+import type { echarts as EchartsType } from '../../../utils/echarts';
+import type { IWordCloudEChartsSeriesOption } from '../../types';
+export declare function registerWordCloudChart(echarts: typeof EchartsType): typeof EchartsType;
+export type { IWordCloudEChartsSeriesOption };

package/lib/types/wordcloud-chart/adapters/echarts/layout-register.d.ts

@@ -0,0 +1,5 @@
+import type { echarts as EchartsType } from '../../../utils/echarts';
+import { WORD_CLOUD_SERIES_TYPE } from './echarts-options';
+export type PerformWordCloudSeriesLayout = (seriesModel: unknown, ecModel: unknown, api: unknown) => void;
+export declare function registerWordCloudLayout(echarts: typeof EchartsType, performSeriesLayout: PerformWordCloudSeriesLayout): void;
+export { WORD_CLOUD_SERIES_TYPE };

package/lib/types/wordcloud-chart/adapters/echarts/layout.d.ts

@@ -0,0 +1,82 @@
+import type { WordCloudCollisionShape } from '../../core/collision/engine';
+import type { IWordCloudBounds, IWordCloudClipMask, IWordCloudEncodedWord, IWordCloudLayoutResult, IWordCloudLayoutStats, IWordCloudMaskGrid, IWordCloudTextMeasurer, WordCloudShape } from '../../types';
+export interface IEChartsWordCloudLayoutConfig {
+    width: number;
+    height: number;
+    cellSize: number;
+    padding: number;
+    shape: WordCloudShape | string | undefined;
+    rotations: number[];
+    randomSeed: number;
+    collisionShape: WordCloudCollisionShape;
+    maskImage?: HTMLImageElement | HTMLCanvasElement | null;
+    drawOutOfBound: boolean;
+    shapeSampleSize?: number | null;
+    shapeInsideRatio?: number | null;
+    shapePaddingRatio?: number | null;
+    shapeFit?: 'contain' | 'cover' | 'stretch' | 'fill';
+    shapeMaskMode?: 'auto' | 'alpha' | 'luminance';
+    shapeAlphaThreshold?: number | null;
+    shapeLuminanceThreshold?: number | null;
+    shapeInvert?: boolean;
+    zoomToFitShrink: boolean;
+    zoomToFitEnlarge: boolean;
+    zoomToFitFontSizeLimitMin: number;
+    zoomToFitFontSizeLimitMax?: number;
+    zoomToFitMinShrinkRatio?: number;
+}
+export interface IEChartsWordCloudRenderLayout {
+    dataIndex: number;
+    text: string;
+    name: string;
+    value: number;
+    cx: number;
+    cy: number;
+    width: number;
+    height: number;
+    rawWidth: number;
+    rawHeight: number;
+    fontSize: number;
+    fontFamily: string;
+    fontWeight: string | number;
+    rotate: number;
+    corners: Array<{
+        x: number;
+        y: number;
+    }>;
+    clipBounds?: IWordCloudBounds;
+    clipMask?: IWordCloudClipMask;
+    phase: 1 | 2;
+}
+export interface IEChartsWordCloudLayoutResult {
+    placed: IEChartsWordCloudRenderLayout[];
+    skipped: IWordCloudEncodedWord[];
+    phase2PlacedCount: number;
+    gridCells: number;
+    usedCells: number;
+    footprintCacheSize: number;
+    failureCacheStats: {
+        size: number;
+        hit: number;
+        miss: number;
+    };
+    zoomRatio: number;
+    enlargeRatio: number;
+    bounds?: IEChartsWordCloudLayoutBounds | null;
+    stats?: IWordCloudLayoutStats;
+}
+export interface IEChartsWordCloudLayoutBounds {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    width: number;
+    height: number;
+    cx: number;
+    cy: number;
+}
+export declare function layoutEChartsWordsWithZoomToFit(words: readonly IWordCloudEncodedWord[], config: IEChartsWordCloudLayoutConfig, measurer: IWordCloudTextMeasurer): IEChartsWordCloudLayoutResult;
+export declare function convertCoreLayoutToEChartsLayout(result: IWordCloudLayoutResult): IEChartsWordCloudLayoutResult;
+export declare function buildWordCloudLayoutStats(layout: IEChartsWordCloudLayoutResult): IEChartsWordCloudLayoutResult;
+export declare function createEChartsMaskGrid(maskImage: HTMLImageElement | HTMLCanvasElement | null | undefined, width: number, height: number, options: Pick<IEChartsWordCloudLayoutConfig, 'shapeFit' | 'shapeMaskMode' | 'shapeAlphaThreshold' | 'shapeLuminanceThreshold' | 'shapeInvert'>): IWordCloudMaskGrid | undefined;
+export declare function estimateGlobalZoomRatio(words: readonly IWordCloudEncodedWord[], config: IEChartsWordCloudLayoutConfig, maskGrid?: IWordCloudMaskGrid): number;

package/lib/types/wordcloud-chart/adapters/echarts/render-config.d.ts

@@ -0,0 +1,57 @@
+export declare const WORD_CLOUD_ECHARTS_RENDER_CONFIG: {
+    readonly fontSizeRange: readonly [16, 56];
+    readonly seriesStyle: {
+        readonly rotations: readonly [0, -45, 45, 90, -90];
+        readonly randomSeed: 1;
+        readonly gridSize: 4;
+        readonly padding: 1;
+        readonly width: "96%";
+        readonly height: "96%";
+    };
+    readonly search: {
+        readonly ringCount: 7;
+        readonly defaultBudget: 4500;
+    };
+    readonly placement: {
+        readonly renderRotationSign: -1;
+        readonly failureCacheLimit: 180;
+    };
+    readonly shapeMask: {
+        readonly sampleSize: null;
+        readonly insideRatio: null;
+        readonly paddingRatio: 0.02;
+        readonly fit: "contain";
+        readonly mode: "auto";
+        readonly alphaThreshold: 8;
+        readonly luminanceThreshold: 245;
+        readonly invert: false;
+    };
+    readonly globalFontScale: {
+        readonly minimumEffectiveScale: 1.03;
+        readonly binarySearchIterations: 12;
+    };
+    readonly fastAreaDensity: {
+        readonly areaRatio: 1;
+        readonly targetOccupancy: 0.62;
+        readonly safety: 1.03;
+        readonly cjkCharWidth: 1;
+        readonly whitespaceCharWidth: 0.28;
+        readonly narrowCharWidth: 0.32;
+        readonly wideCharWidth: 0.82;
+        readonly uppercaseCharWidth: 0.66;
+        readonly defaultCharWidth: 0.56;
+        readonly boldFactor: 1.06;
+        readonly fontHeightRatio: 1.16;
+        readonly rotationDiagonalInflate: 0.12;
+        readonly gridPerimeterOverhead: 0.9;
+        readonly gridAreaOverheadCells: 4;
+        readonly minimumSafety: 0.5;
+        readonly maximumSafety: 2;
+    };
+    readonly zoomToFit: {
+        readonly shrink: true;
+        readonly enlarge: false;
+        readonly fontSizeLimitMin: 16;
+        readonly minShrinkRatio: 0.8;
+    };
+};

package/lib/types/wordcloud-chart/adapters/echarts/series-model.d.ts

@@ -0,0 +1,7 @@
+import type { echarts as EchartsType } from '../../../utils/echarts';
+import { WORD_CLOUD_DEFAULT_OPTION, WORD_CLOUD_SERIES_TYPE } from './echarts-options';
+export interface IWordCloudEChartsHelper {
+    createDimensions(data: any[], options: Record<string, unknown>): any;
+}
+export declare function registerWordCloudSeriesModel(echarts: typeof EchartsType, helper: IWordCloudEChartsHelper): void;
+export { WORD_CLOUD_DEFAULT_OPTION, WORD_CLOUD_SERIES_TYPE };

package/lib/types/wordcloud-chart/adapters/echarts/text-measurer.d.ts

@@ -0,0 +1,12 @@
+export declare function createMeasureContext(): CanvasRenderingContext2D;
+export declare function createCanvasTextMeasurer(context: CanvasRenderingContext2D): {
+    measureText(word: any): {
+        width: number;
+        height: number;
+        actualBoundingBoxAscent: number;
+        actualBoundingBoxDescent: number;
+        actualBoundingBoxLeft: number;
+        actualBoundingBoxRight: number;
+    };
+    rasterizeText(word: any): import("../..").IWordCloudTextSprite;
+};

package/lib/types/wordcloud-chart/adapters/echarts/words.d.ts

@@ -0,0 +1,47 @@
+import type { IWordCloudEncodedWord, WordCloudFontSizeRange } from '../../types';
+import { createWordCloudFontSizeAccessor } from '../../core/layout/font-scale';
+export interface IEChartsWordCloudSourceRecord {
+    dataIndex: number;
+    key: string;
+    name: string;
+    text: string;
+    value: number;
+    raw: Record<string, unknown>;
+    explicitFontSize?: unknown;
+    fontFamily: string;
+    fontWeight: string | number;
+    padding: number;
+}
+export interface IEChartsWordCloudWordsBuildOptions {
+    fontSizeRange: WordCloudFontSizeRange;
+    rotations: number[];
+    randomSeed?: number | string;
+}
+export interface IEChartsWordCloudDesignWordsBuildOptions {
+    fontSizeRange: WordCloudFontSizeRange;
+}
+export interface IEChartsWordCloudLayoutWordsBuildOptions {
+    rotations: number[];
+    randomSeed?: number | string;
+}
+export interface IEChartsWordCloudDesignWord {
+    key: string;
+    recordIndex: number;
+    datumIndex: number;
+    name: string;
+    text: string;
+    value: number;
+    raw: Record<string, unknown>;
+    designFontSize: number;
+}
+export interface IEChartsWordCloudDesignWordsBuildResult {
+    words: IEChartsWordCloudDesignWord[];
+    fontSizeInfo: ReturnType<typeof createWordCloudFontSizeAccessor>['meta'];
+}
+export declare function buildEChartsWordCloudWords(records: readonly IEChartsWordCloudSourceRecord[], options: IEChartsWordCloudWordsBuildOptions): {
+    words: IWordCloudEncodedWord[];
+    fontSizeInfo: ReturnType<typeof createWordCloudFontSizeAccessor>['meta'];
+};
+export declare function buildEChartsWordCloudDesignWords(records: readonly IEChartsWordCloudSourceRecord[], options: IEChartsWordCloudDesignWordsBuildOptions): IEChartsWordCloudDesignWordsBuildResult;
+export declare function deriveEChartsWordCloudLayoutWords(designWords: readonly IEChartsWordCloudDesignWord[], records: readonly IEChartsWordCloudSourceRecord[], options: IEChartsWordCloudLayoutWordsBuildOptions): IWordCloudEncodedWord[];
+export declare function createEChartsWordCloudDesignWordsCacheKey(records: readonly IEChartsWordCloudSourceRecord[], fontSizeRange: WordCloudFontSizeRange): string;

package/lib/types/wordcloud-chart/canvas.d.ts

@@ -0,0 +1,8 @@
+import type { IWordCloudLayoutMask, IWordCloudLayoutOptions, IWordCloudLayoutResult, IWordCloudMaskGrid, IWordCloudSpecBase, IWordCloudTextMeasurer } from './types';
+export interface IWordCloudLayoutRuntime {
+    measurer: IWordCloudTextMeasurer;
+    mask?: IWordCloudLayoutMask;
+    maskGrid?: IWordCloudMaskGrid;
+}
+export declare function layoutWordCloudChart(spec: IWordCloudSpecBase, runtime: IWordCloudLayoutRuntime): IWordCloudLayoutResult;
+export declare function resolveLayoutOptions(spec: IWordCloudSpecBase): IWordCloudLayoutOptions;