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

package/lib/types/index.d.ts

@@ -1,11 +1,11 @@
 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, findCategoryOperator, findHeaderOperator, findSeriesOperator, generateChartModelContextByOperators, pieSeriesFilterOperator, } from './models/chart-data-operators/operators';
+export { defaultChartContextOperators, findCategoryIndexes, findSeriesOperator, generateChartModelContextByOperators, inferChartContextOperator, pieSeriesFilterOperator, } from './models/chart-data-operators/operators';
 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 } from './models/chart-runtime-style';
+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';
@@ -16,12 +16,15 @@ export { defaultChartConfig, RTLChartStyle, themeColors } from './models/constan
 export { 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 { OffscreenChartHost } from './models/offscreen-chart-host';
 export { registerWordCloudChartMakImageService, WordCloudMuskImageService } from './models/word-cloud-musk-image.service';
 export { ChartDataSource } from './source/chart-source';
 export { StaticChartSource } from './source/static-chart-source';
-export type { ChartDataSourceValue, ChartDataSourceValues, DimensionDefinitionLoose, IChartDataSource, IDimensionDefinition, IUniverDataSet, OptionDataValue, } from './types';
+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 * from './utils/echarts';

package/lib/types/models/chart-data-operators/operators.d.ts

@@ -12,8 +12,7 @@ export declare function countTypesFromArray(arrayData: Array<OptionDataValue | u
 };
 export declare function toColumnOrient<T = any>(dataSource: T[][]): T[][];
 export declare function findCategoryIndexes(dataSource: ChartDataSource): number[];
-export declare const findHeaderOperator: IChartContextOperator;
-export declare const findCategoryOperator: IChartContextOperator;
+export declare const inferChartContextOperator: IChartContextOperator;
 export declare const findSeriesOperator: IChartContextOperator;
 export declare const pieSeriesFilterOperator: IChartContextOperator;
 export declare const defaultChartContextOperators: IChartContextOperator[];

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

@@ -10,3 +10,4 @@ import { ChartTypeBits } from '../enum';
  * the runtime render style consumed by physical-position operators.
  */
 export declare function resolveChartRuntimeStyle(style: ChartStyle, chartType?: ChartTypeBits): ChartStyle;
+export declare function resolveChartStyleBackgroundColor(style?: Pick<ChartStyle, 'backgroundColor'> | null): string;

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

@@ -1,4 +1,4 @@
-import type { ChartStyle, EChartInstance, EChartSpec, IChartConfig, IChartHostRect, IChartInstance, IChartRenderModel, IChartRenderModelStylizeInit } from '../types';
+import type { ChartHostRenderMode, ChartImageSource, ChartStyle, EChartInstance, EChartSpec, IChartConfig, IChartHostRect, IChartInstance, IChartRenderAsImageOptions, IChartRenderInstance, IChartRenderInstanceCreateContext, IChartRenderModel, IChartRenderModelStylizeInit, IChartRenderRuntimeOptions } from '../types';
 import type { IWordCloudRenderConfig } from '../wordcloud-chart/word-cloud-render-config';
 import { Disposable } from '@univerjs/core';
 export interface IEChartRenderModelOptions {
@@ -14,6 +14,10 @@ export declare class EChartRenderModel extends Disposable implements IChartRende
     private _addSpecConverters;
     private _addSpecOperators;
     createChartInstance(): IChartInstance<EChartSpec>;
+    createChartInstance(mode: ChartHostRenderMode, context?: IChartRenderInstanceCreateContext<EChartSpec>): IChartRenderInstance;
+    clearRuntimeCache(chartId: string): void;
+    clearAllRuntimeCache(): void;
+    dispose(): void;
     toSpec(config: IChartConfig, style: ChartStyle): import("echarts").EChartsOption;
     stylizeSpec(spec: EChartSpec, stylizeInit: IChartRenderModelStylizeInit<EChartSpec>, rect: IChartHostRect): import("echarts").EChartsOption | {
         backgroundColor: string;
@@ -30,8 +34,8 @@ export declare class EChartRenderEngine extends Disposable implements EChartInst
     resize(echartsProvider?: any): void;
     private _ensureChartInstance;
     get containerElement(): HTMLElement | null;
-    render(spec: EChartSpec, echartsProvider?: any): void;
+    render(spec: EChartSpec, echartsProviderOrOptions?: any | IChartRenderRuntimeOptions): void;
+    renderAsImage(spec: EChartSpec, options: IChartRenderAsImageOptions): Promise<ChartImageSource>;
     exportImg(echartsProvider?: any): Promise<string>;
-    onDispose(): void;
     dispose(): void;
 }

package/lib/types/models/image-chart-host.d.ts

@@ -0,0 +1,17 @@
+import type { ChartImageSource, IChartHostLease, IChartHostRect, IChartHostStyle, IImageChartHost } from '../types';
+import { Disposable } from '@univerjs/core';
+export declare function chartImageSourceToDataUrl(image: ChartImageSource): string;
+export declare abstract class ImageChartHost extends Disposable implements IImageChartHost {
+    readonly chartId: string;
+    readonly mode: "image";
+    private readonly _offscreenChartHost;
+    constructor(chartId: string);
+    abstract getRect(): IChartHostRect | null;
+    abstract setStyle(style: IChartHostStyle): void;
+    abstract nextVersion(): number;
+    abstract commitSnapshot(image: ChartImageSource, version: number): boolean;
+    abstract requestPaint(): void;
+    abstract invalidateSnapshot(): void;
+    acquireOffscreenHost(rect: IChartHostRect): IChartHostLease;
+    dispose(): void;
+}

package/lib/types/models/offscreen-chart-host.d.ts

@@ -0,0 +1,7 @@
+import type { IChartHostLease, IChartHostRect } from '../types';
+import { Disposable } from '@univerjs/core';
+export declare class OffscreenChartHost extends Disposable {
+    private readonly _leases;
+    acquire(rect: IChartHostRect): IChartHostLease;
+    dispose(): void;
+}

package/lib/types/types.d.ts

@@ -413,6 +413,63 @@ export interface IChartRenderSpecConverter<ChartRenderSpec = Record<string, any>
 }
 export type ChartConfigInterceptor = (config: IChartConfig) => IChartConfig;
 export type RenderSpecOperator<ChartRenderSpec> = (spec: ChartRenderSpec, style: ChartStyle, config: IChartConfig, instance: IChartInstance) => void;
+export type ChartHostRenderMode = 'image' | 'dom';
+export interface IChartHostStyle {
+    stroke?: string;
+    fill?: string;
+    [key: string]: any;
+}
+export interface IChartHostLease extends IDisposable {
+    readonly mountNode: HTMLElement;
+}
+export interface IChartHost extends IDisposable {
+    readonly chartId: string;
+    readonly mode: ChartHostRenderMode;
+    getRect(): IChartHostRect | null;
+    setStyle(style: IChartHostStyle): void;
+}
+export interface IImageChartHost extends IChartHost {
+    readonly mode: 'image';
+    nextVersion(): number;
+    commitSnapshot(image: ChartImageSource, version: number): boolean;
+    requestPaint(): void;
+    invalidateSnapshot(): void;
+    acquireOffscreenHost(rect: IChartHostRect): IChartHostLease;
+}
+export interface IDomChartHost extends IChartHost {
+    readonly mode: 'dom';
+    ensureMount(): Promise<HTMLElement | null>;
+    checkMounted(): boolean;
+    syncLayout(): void;
+    markReady(): void;
+    markNotReady(): void;
+}
+export interface IChartRenderInput {
+    chartId: string;
+    config: IChartConfig;
+    style: ChartStyle;
+}
+export interface IChartRenderInstance extends IDisposable {
+    readonly mode: ChartHostRenderMode;
+    bind(host: IChartHost): void;
+    render(input: IChartRenderInput): Promise<void>;
+    resize(): void;
+}
+export interface IChartRenderInstanceStyleInput<Spec = Record<string, any>> extends IChartRenderInput {
+    mode: ChartHostRenderMode;
+    spec?: Spec;
+}
+export interface IChartRenderInstanceSpecInput<Spec = Record<string, any>> extends IChartRenderInput {
+    mode: ChartHostRenderMode;
+    spec: Spec;
+}
+export interface IChartRenderInstanceCreateContext<Spec = Record<string, any>> {
+    resolveHostStyle?: (input: IChartRenderInstanceStyleInput<Spec>) => IChartHostStyle;
+    resolveRenderBackgroundColor?: (input: IChartRenderInstanceStyleInput<Spec> & {
+        hostStyle: IChartHostStyle;
+    }) => string | undefined;
+    prepareSpec?: (input: IChartRenderInstanceSpecInput<Spec>) => Spec;
+}
 export interface IChartRenderModelStylizeInit<Spec> {
     chartStyle: ChartStyle;
     chartConfig: IChartConfig;
@@ -423,17 +480,49 @@ export interface IChartRenderModel<Spec extends Record<string, any> = Record<str
     stylizeSpec(spec: Spec, stylizeInit: IChartRenderModelStylizeInit<Spec>, rect: IChartHostRect): Spec;
     updateWatermark(addWatermark: boolean): void;
     createChartInstance(): IChartInstance<Spec>;
+    createChartInstance(mode: ChartHostRenderMode, context?: IChartRenderInstanceCreateContext<Spec>): IChartRenderInstance;
+    clearRuntimeCache?(chartId: string): void;
+    clearAllRuntimeCache?(): void;
     dispose(): void;
 }
 export interface IChartThemeOptions {
     colors: string[];
 }
+export declare enum ChartImageSourceType {
+    Url = "url",
+    Canvas = "canvas",
+    ImageBitmap = "imageBitmap"
+}
+export type ChartImageSource = {
+    type: ChartImageSourceType.Url;
+    url: string;
+} | {
+    type: ChartImageSourceType.Canvas;
+    canvas: HTMLCanvasElement;
+} | {
+    type: ChartImageSourceType.ImageBitmap;
+    imageBitmap: ImageBitmap;
+};
+export interface IChartRenderAsImageOptions {
+    width: number;
+    height: number;
+    pixelRatio?: number;
+    backgroundColor?: string;
+    echartsProvider?: any;
+    chartId?: string;
+    host: HTMLElement;
+}
+export interface IChartRenderRuntimeOptions {
+    echartsProvider?: any;
+    chartId?: string;
+}
 export interface IChartInstance<Spec = Record<string, any>> extends IDisposable {
     container: HTMLElement | string;
     mount(id: string | HTMLElement): void;
     render(spec: Spec, echartsProvider?: any): void;
+    render(spec: Spec, options?: IChartRenderRuntimeOptions): void;
+    renderAsImage(spec: Spec, options: IChartRenderAsImageOptions): Promise<ChartImageSource>;
     exportImg(): Promise<string>;
-    onDispose?(dispose: () => void): void;
     resize(): void;
 }
 export interface IChartInstanceConstructor<Spec> {

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

@@ -1,4 +1,5 @@
 import type { echarts as EchartsType } from '../../../utils/echarts';
 import type { IWordCloudEChartsSeriesOption } from '../../types';
 export declare function registerWordCloudChart(echarts: typeof EchartsType): typeof EchartsType;
+export declare function waitForWordCloudImageResourcesReady(spec: unknown, timeout?: number): Promise<void>;
 export type { IWordCloudEChartsSeriesOption };

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

@@ -0,0 +1,29 @@
+import type { IWordCloudEncodedWord } from '../../types';
+import type { IEChartsWordCloudRenderLayout } from './layout';
+import type { IEChartsWordCloudDesignWordsBuildResult } from './words';
+export interface IWordCloudRuntimeContext {
+    chartId?: string;
+}
+export interface IWordCloudFinalLayoutCachePayload {
+    placed: IEChartsWordCloudRenderLayout[];
+}
+interface ICacheCounter {
+    hit: number;
+    miss: number;
+}
+export interface IWordCloudRuntimeCacheStats {
+    designWords: ICacheCounter;
+    layoutWords: ICacheCounter;
+    finalLayout: ICacheCounter;
+}
+export declare function withWordCloudRuntimeContext<T>(context: IWordCloudRuntimeContext, fn: () => T): T;
+export declare function getCurrentWordCloudRuntimeContext(): IWordCloudRuntimeContext | undefined;
+export declare function getOrCreateCachedWordCloudDesignWords(chartId: string | undefined, key: string, factory: () => IEChartsWordCloudDesignWordsBuildResult): IEChartsWordCloudDesignWordsBuildResult;
+export declare function getOrCreateCachedWordCloudLayoutWords(chartId: string | undefined, key: string, factory: () => IWordCloudEncodedWord[]): IWordCloudEncodedWord[];
+export declare function getCachedWordCloudFinalLayout(chartId: string | undefined, key: string): IWordCloudFinalLayoutCachePayload | undefined;
+export declare function setCachedWordCloudFinalLayout(chartId: string | undefined, key: string, value: IWordCloudFinalLayoutCachePayload): void;
+export declare function clearWordCloudRuntimeCache(chartId: string): void;
+export declare function clearAllWordCloudRuntimeCache(): void;
+export declare function getWordCloudRuntimeCacheStats(chartId?: string): IWordCloudRuntimeCacheStats;
+export declare function createStableWordCloudCacheKey(parts: readonly unknown[]): string;
+export {};