@univerjs-pro/chart-ui 1.0.0-alpha.8 → 1.0.0-beta.1

package/lib/types/services/chart-host-adapter.d.ts

@@ -0,0 +1,12 @@
+import type { ChartModel, ChartPendingConfig, IChartBuilderAdapter } from '@univerjs-pro/engine-chart';
+export declare abstract class IChartHostAdapter {
+    abstract getChartModel(): ChartModel;
+    abstract commit(config: ChartPendingConfig): void;
+}
+export declare class ChartHostAdapter extends IChartHostAdapter {
+    private readonly _model;
+    private readonly _commitTarget;
+    constructor(_model: ChartModel, _commitTarget: Pick<IChartBuilderAdapter, 'commit'>);
+    getChartModel(): ChartModel;
+    commit(config: ChartPendingConfig): void;
+}

package/lib/types/services/chart-image-export.service.d.ts

@@ -0,0 +1,26 @@
+import type { IDisposable } from '@univerjs/core';
+import { Disposable } from '@univerjs/core';
+export interface IChartImageExportTarget {
+    /** Stable host unit identifier when the renderer requires host context. */
+    readonly unitId?: string;
+    /** Stable host sub-unit identifier when the renderer requires host context. */
+    readonly subUnitId?: string;
+    /** Returns the stable Chart identifier. */
+    getId(): string;
+}
+/** UI-owned image-export implementation for one Chart host. */
+export interface IChartImageExportProvider {
+    /** Returns whether this provider owns the supplied Chart facade. */
+    supports(chart: IChartImageExportTarget): boolean;
+    /** Exports the supplied Chart through the host's existing UI renderer. */
+    exportImage(chart: IChartImageExportTarget): Promise<string | undefined>;
+}
+/** Routes Chart image export to the UI renderer owned by the Chart host. */
+export declare class ChartImageExportService extends Disposable {
+    private readonly _providers;
+    /** Registers one host UI image-export provider. */
+    register(provider: IChartImageExportProvider): IDisposable;
+    /** Exports a Chart through the first matching host UI provider. */
+    exportImage(chart: IChartImageExportTarget): Promise<string | undefined>;
+    dispose(): void;
+}

package/lib/types/services/chart-referenced-data-source-binding.service.d.ts

@@ -0,0 +1,13 @@
+import type { IReferencedUnitViewerSession } from '@univerjs-pro/embed-unit-ui';
+import type { IResourceRefChartDataSourceReference } from '@univerjs-pro/engine-chart';
+import type { IDisposable } from '@univerjs/core';
+import { IReferencedUnitCatalogService } from '@univerjs-pro/embed';
+export interface IChartReferencedDataSourceBindingOptions {
+    initialSource?: IResourceRefChartDataSourceReference;
+    onDataSourceChange(source: IResourceRefChartDataSourceReference): void;
+}
+export declare class ChartReferencedDataSourceBindingService {
+    private readonly _catalog;
+    constructor(_catalog: IReferencedUnitCatalogService);
+    bind(session: IReferencedUnitViewerSession, options: IChartReferencedDataSourceBindingOptions): IDisposable;
+}

package/lib/types/services/chart-snapshot-queue.d.ts

@@ -0,0 +1,59 @@
+import type { IChartModelRuntime } from '@univerjs-pro/engine-chart';
+import type { LocaleService } from '@univerjs/core';
+import { Disposable } from '@univerjs/core';
+import { Subject } from 'rxjs';
+export interface IChartSnapshotRequest {
+    unitId: string;
+    chartId: string;
+    width: number;
+    height: number;
+    dpr?: number;
+    mode?: string;
+}
+export interface IChartSnapshotEntry {
+    key: string;
+    status: 'pending' | 'ready' | 'error';
+    dataUrl?: string;
+    error?: unknown;
+}
+export interface IChartSnapshotInvalidation {
+    unitId: string;
+    chartId: string;
+}
+export interface IChartSnapshotInvalidationOptions {
+    waitForConfig?: boolean;
+}
+export interface IChartSnapshotRenderer<TRequest extends IChartSnapshotRequest, TRuntime extends IChartModelRuntime = IChartModelRuntime> {
+    render(request: TRequest, runtime: TRuntime): Promise<string>;
+}
+export interface IChartSnapshotRuntimeProvider<TRuntime extends IChartModelRuntime> {
+    ensureChartModel(unitId: string, chartId: string): TRuntime | undefined;
+    getChartModel(unitId: string, chartId: string): TRuntime | undefined;
+}
+export declare class ChartSnapshotQueue<TRequest extends IChartSnapshotRequest, TRuntime extends IChartModelRuntime = IChartModelRuntime> extends Disposable {
+    private readonly _localeService;
+    private readonly _modelService;
+    private readonly _renderer;
+    readonly snapshotUpdated$: Subject<IChartSnapshotEntry>;
+    readonly chartInvalidated$: Subject<IChartSnapshotInvalidation>;
+    private readonly _cache;
+    private readonly _queue;
+    private readonly _configWaitKeys;
+    private _rendering;
+    private _activeDrain;
+    constructor(_localeService: LocaleService, _modelService: IChartSnapshotRuntimeProvider<TRuntime>, _renderer: IChartSnapshotRenderer<TRequest, TRuntime>);
+    requestSnapshot(request: TRequest): IChartSnapshotEntry;
+    getSnapshot(request: TRequest): IChartSnapshotEntry | undefined;
+    exportImage(request: TRequest): Promise<string | undefined>;
+    invalidateChart(unitId: string, chartId: string, options?: IChartSnapshotInvalidationOptions): void;
+    getCacheKey(request: TRequest): string;
+    flushForTests(): Promise<void>;
+    dispose(): void;
+    private _drainQueue;
+    private _invalidateSnapshotsForDirectionChange;
+    private _runQueue;
+    private _renderOne;
+    private _waitForRuntimeConfig;
+    private _getChartKey;
+    private _getRuntimeModel;
+}

package/lib/types/services/chart-ui.service.d.ts

@@ -0,0 +1,19 @@
+import type { IDisposable } from '@univerjs/core';
+import type { ChartViewStateName, IChartViewStateDefinition, IChartViewStateMap } from './chart-view-state';
+import { Disposable } from '@univerjs/core';
+import { ChartViewStateRegistry } from './chart-view-state-registry';
+export interface IChartUIService<TRuntimeModel = unknown, TUpdateConfigParams = never> {
+    readonly activeRuntimeModel: TRuntimeModel | null;
+    executeChartUpdateConfig(params: TUpdateConfigParams): void;
+    registerViewState<K extends ChartViewStateName>(key: K, definition: IChartViewStateDefinition<IChartViewStateMap[K]>): IDisposable;
+    getViewState<K extends ChartViewStateName>(key: K): IChartViewStateDefinition<IChartViewStateMap[K]>;
+}
+export declare const IChartUIService: import("@wendellhu/redi").IdentifierDecorator<IChartUIService<unknown, never>>;
+export declare abstract class ChartUIService<TRuntimeModel, TUpdateConfigParams> extends Disposable implements IChartUIService<TRuntimeModel, TUpdateConfigParams> {
+    abstract readonly activeRuntimeModel: TRuntimeModel | null;
+    abstract executeChartUpdateConfig(params: TUpdateConfigParams): void;
+    private readonly _viewStates;
+    constructor(viewStates: ChartViewStateRegistry);
+    registerViewState<K extends ChartViewStateName>(key: K, definition: IChartViewStateDefinition<IChartViewStateMap[K]>): IDisposable;
+    getViewState<K extends ChartViewStateName>(key: K): IChartViewStateDefinition<IChartViewStateMap[K]>;
+}

package/lib/types/services/chart-view-state-projector.d.ts

@@ -0,0 +1,15 @@
+import type { ChartModel } from '@univerjs-pro/engine-chart';
+import type { Observable } from 'rxjs';
+import type { IChartViewStateMap } from './chart-view-state';
+import { ChartViewStateKey } from './chart-view-state';
+export interface IChartViewStateProjector {
+    get<K extends ChartViewStateKey>(model: ChartModel, key: K): IChartViewStateMap[K];
+    observe<K extends ChartViewStateKey>(model: ChartModel, key: K): Observable<IChartViewStateMap[K]>;
+}
+export declare class ChartViewStateProjector implements IChartViewStateProjector {
+    private readonly _observables;
+    get<K extends ChartViewStateKey>(model: ChartModel, key: K): IChartViewStateMap[K];
+    observe<K extends ChartViewStateKey>(model: ChartModel, key: K): Observable<IChartViewStateMap[K]>;
+    private _dependencies;
+    private _project;
+}

package/lib/types/services/chart-view-state-registry.d.ts

@@ -0,0 +1,11 @@
+import type { IDisposable } from '@univerjs/core';
+import type { ChartViewStateName, IChartViewStateDefinition, IChartViewStateMap } from './chart-view-state';
+export interface IChartViewStateRegistry {
+    registerViewState<K extends ChartViewStateName>(key: K, definition: IChartViewStateDefinition<IChartViewStateMap[K]>): IDisposable;
+    resolve<K extends ChartViewStateName>(key: K): IChartViewStateDefinition<IChartViewStateMap[K]>;
+}
+export declare class ChartViewStateRegistry implements IChartViewStateRegistry {
+    private readonly _definitions;
+    registerViewState<K extends ChartViewStateName>(key: K, definition: IChartViewStateDefinition<IChartViewStateMap[K]>): IDisposable;
+    resolve<K extends ChartViewStateName>(key: K): IChartViewStateDefinition<IChartViewStateMap[K]>;
+}

package/lib/types/services/chart-view-state.d.ts

@@ -0,0 +1,118 @@
+import type { ChartPendingConfig, ChartTypeBits, DeepNullish, IChartChordMappingSpec, IChartChordSpec, IChartGaugeSpec, IChartHeatmapSpec, IChartSeriesDescription, IChartSunburstSpec } from '@univerjs-pro/engine-chart';
+import type { Observable } from 'rxjs';
+import type { IChartHostAdapter } from './chart-host-adapter';
+export interface IChartEditorOption {
+    label: string;
+    value: string;
+}
+export interface IChartChordFieldOptions {
+    categoryFields: IChartEditorOption[];
+    valueFields: IChartEditorOption[];
+}
+export interface IChartEditorSeriesState {
+    dataPointOptions: IChartEditorOption[];
+    name: string;
+    selector: number;
+    style: DeepNullish<Omit<IChartSeriesDescription, 'name'>>;
+}
+/**
+ * Stable in-process identities used by the chart editor state registry.
+ *
+ * These values identify editor view state only. They are not command IDs,
+ * persisted values, or collaborative wire contracts.
+ */
+export declare enum ChartViewStateKey {
+    /** Authored style shared by all series. */
+    AllSeriesStyle = "allSeriesStyle",
+    Appearance = "appearance",
+    Aggregation = "aggregation",
+    Area = "area",
+    AutoGradientFill = "autoGradientFill",
+    Bar = "bar",
+    Axes = "axes",
+    AxisPointer = "axisPointer",
+    Candlestick = "candlestick",
+    ChartType = "chartType",
+    ChordFields = "chordFields",
+    ChordMapping = "chordMapping",
+    ChordStyle = "chordStyle",
+    Funnel = "funnel",
+    GaugeFields = "gaugeFields",
+    GaugeLabelIndex = "gaugeLabelIndex",
+    GaugeStyle = "gaugeStyle",
+    GaugeValueIndex = "gaugeValueIndex",
+    Heatmap = "heatmap",
+    Histogram = "histogram",
+    InvalidValueStrategy = "invalidValueStrategy",
+    Legend = "legend",
+    /** Authored category, series, hierarchy, and relation field mapping. */
+    Mapping = "mapping",
+    MappingFields = "mappingFields",
+    Pareto = "pareto",
+    ParetoDataPointOptions = "paretoDataPointOptions",
+    Pie = "pie",
+    PlotArea = "plotArea",
+    Radar = "radar",
+    Relation = "relation",
+    Series = "series",
+    Subtitle = "subtitle",
+    SunburstFields = "sunburstFields",
+    SunburstHierarchyIndexes = "sunburstHierarchyIndexes",
+    SunburstStyle = "sunburstStyle",
+    SunburstValueIndex = "sunburstValueIndex",
+    Theme = "theme",
+    Title = "title",
+    Treemap = "treemap",
+    Trendlines = "trendlines",
+    Waterfall = "waterfall",
+    WordCloud = "wordCloud"
+}
+export interface IChartViewStateMap {
+    [ChartViewStateKey.AllSeriesStyle]: ChartPendingConfig['allSeriesStyle'];
+    [ChartViewStateKey.Appearance]: ChartPendingConfig['appearance'];
+    [ChartViewStateKey.Aggregation]: ChartPendingConfig['aggregation'];
+    [ChartViewStateKey.Area]: ChartPendingConfig['area'];
+    [ChartViewStateKey.AutoGradientFill]: ChartPendingConfig['autoGradientFill'];
+    [ChartViewStateKey.Bar]: ChartPendingConfig['bar'];
+    [ChartViewStateKey.Axes]: ChartPendingConfig['axes'];
+    [ChartViewStateKey.AxisPointer]: ChartPendingConfig['axisPointer'];
+    [ChartViewStateKey.Candlestick]: ChartPendingConfig['candlestick'];
+    [ChartViewStateKey.ChartType]: ChartTypeBits;
+    [ChartViewStateKey.ChordFields]: IChartChordFieldOptions;
+    [ChartViewStateKey.ChordMapping]: IChartChordMappingSpec | undefined;
+    [ChartViewStateKey.ChordStyle]: DeepNullish<IChartChordSpec> | undefined;
+    [ChartViewStateKey.Funnel]: ChartPendingConfig['funnel'];
+    [ChartViewStateKey.GaugeFields]: IChartEditorOption[];
+    [ChartViewStateKey.GaugeLabelIndex]: number | undefined;
+    [ChartViewStateKey.GaugeStyle]: DeepNullish<IChartGaugeSpec> | undefined;
+    [ChartViewStateKey.GaugeValueIndex]: number | undefined;
+    [ChartViewStateKey.Heatmap]: DeepNullish<IChartHeatmapSpec> | undefined;
+    [ChartViewStateKey.Histogram]: ChartPendingConfig['histogram'];
+    [ChartViewStateKey.InvalidValueStrategy]: ChartPendingConfig['invalidValueStrategy'];
+    [ChartViewStateKey.Legend]: ChartPendingConfig['legend'];
+    [ChartViewStateKey.Mapping]: ChartPendingConfig['mapping'];
+    [ChartViewStateKey.MappingFields]: IChartEditorOption[];
+    [ChartViewStateKey.Pareto]: ChartPendingConfig['pareto'];
+    [ChartViewStateKey.ParetoDataPointOptions]: IChartEditorOption[];
+    [ChartViewStateKey.Pie]: ChartPendingConfig['pie'];
+    [ChartViewStateKey.PlotArea]: ChartPendingConfig['plotArea'];
+    [ChartViewStateKey.Radar]: ChartPendingConfig['radar'];
+    [ChartViewStateKey.Relation]: ChartPendingConfig['relation'];
+    [ChartViewStateKey.Series]: IChartEditorSeriesState[];
+    [ChartViewStateKey.Subtitle]: ChartPendingConfig['subtitle'];
+    [ChartViewStateKey.SunburstFields]: IChartEditorOption[];
+    [ChartViewStateKey.SunburstHierarchyIndexes]: number[];
+    [ChartViewStateKey.SunburstStyle]: DeepNullish<IChartSunburstSpec> | undefined;
+    [ChartViewStateKey.SunburstValueIndex]: number | undefined;
+    [ChartViewStateKey.Theme]: ChartPendingConfig['theme'];
+    [ChartViewStateKey.Title]: ChartPendingConfig['title'];
+    [ChartViewStateKey.Treemap]: ChartPendingConfig['treemap'];
+    [ChartViewStateKey.Trendlines]: ChartPendingConfig['trendlines'];
+    [ChartViewStateKey.Waterfall]: ChartPendingConfig['waterfall'];
+    [ChartViewStateKey.WordCloud]: ChartPendingConfig['wordCloud'];
+}
+export type ChartViewStateName = keyof IChartViewStateMap;
+export interface IChartViewStateDefinition<T> {
+    get(hostAdapter: IChartHostAdapter): Observable<T>;
+    set?(hostAdapter: IChartHostAdapter, value: T): void;
+}

package/lib/types/services/inline-chart-creation.d.ts

@@ -0,0 +1,42 @@
+import type { ChartStyle, PieSecondaryPlotType as PieSecondaryPlotTypeValue } from '@univerjs-pro/engine-chart';
+import type { ChartInlineCellValue } from '../components/ChartInlineTableEditor';
+import { ChartTypeBits } from '@univerjs-pro/engine-chart';
+export type ChartTypeOptionId = string;
+export interface IChartCreationIntent {
+    chartType: ChartTypeBits;
+    pieSecondaryPlotType?: PieSecondaryPlotTypeValue;
+}
+export declare enum InlineChartCreationIssueCode {
+    UnknownOption = "unknownOption",
+    EmptyData = "emptyData",
+    InvalidCandlestickData = "invalidCandlestickData"
+}
+export interface IInlineChartCreationIssue {
+    code: InlineChartCreationIssueCode;
+}
+export type InlineChartDataPreparationResult<T extends ChartInlineCellValue = ChartInlineCellValue> = {
+    ok: true;
+    values: T[][];
+} | {
+    ok: false;
+    issue: IInlineChartCreationIssue;
+};
+export interface IInlineChartCreationInput<T extends ChartInlineCellValue = ChartInlineCellValue> {
+    optionId: ChartTypeOptionId;
+    values: T[][];
+}
+export interface IInlineChartCreationPlan<T extends ChartInlineCellValue = ChartInlineCellValue> {
+    chartType: ChartTypeBits;
+    style?: ChartStyle;
+    values: T[][];
+}
+export type InlineChartCreationResult<T extends ChartInlineCellValue = ChartInlineCellValue> = {
+    ok: true;
+    plan: IInlineChartCreationPlan<T>;
+} | {
+    ok: false;
+    issue: IInlineChartCreationIssue;
+};
+export declare function resolveChartCreationIntent(optionId: ChartTypeOptionId): IChartCreationIntent | undefined;
+export declare function tryPrepareInlineChartData<T extends ChartInlineCellValue>(chartType: ChartTypeBits, values: T[][]): InlineChartDataPreparationResult<T>;
+export declare function tryBuildInlineChartCreationPlan<T extends ChartInlineCellValue>(input: IInlineChartCreationInput<T>): InlineChartCreationResult<T>;

package/lib/types/services/register-chart-config-states.d.ts

@@ -0,0 +1,3 @@
+import type { IDisposable } from '@univerjs/core';
+import type { ChartViewStateRegistry } from './chart-view-state-registry';
+export declare function registerChartConfigStates(service: ChartViewStateRegistry): IDisposable;

package/lib/types/services/register-chart-view-states/chart-specific.d.ts

@@ -0,0 +1,4 @@
+import type { ChartViewStateProjector } from '../chart-view-state-projector';
+import type { ChartViewStateRegistry } from '../chart-view-state-registry';
+import { DisposableCollection } from '@univerjs/core';
+export declare function registerChartSpecificStates(service: ChartViewStateRegistry, projector: ChartViewStateProjector): DisposableCollection;

package/lib/types/services/register-chart-view-states/semantic.d.ts

@@ -0,0 +1,4 @@
+import type { ChartViewStateProjector } from '../chart-view-state-projector';
+import type { ChartViewStateRegistry } from '../chart-view-state-registry';
+import { DisposableCollection } from '@univerjs/core';
+export declare function registerSemanticStates(service: ChartViewStateRegistry, projector: ChartViewStateProjector): DisposableCollection;

package/lib/umd/facade.js

@@ -0,0 +1 @@
+(function(_0x443fea,_0x1c9a83){var _0x1101d4=_0x5644,_0x3d7013=_0x443fea();while(!![]){try{var _0x2d1685=parseInt(_0x1101d4(0xd3))/0x1+-parseInt(_0x1101d4(0xd4))/0x2+parseInt(_0x1101d4(0xcc))/0x3+-parseInt(_0x1101d4(0xd2))/0x4*(-parseInt(_0x1101d4(0xcb))/0x5)+parseInt(_0x1101d4(0xdb))/0x6+parseInt(_0x1101d4(0xd6))/0x7+parseInt(_0x1101d4(0xcd))/0x8*(-parseInt(_0x1101d4(0xd9))/0x9);if(_0x2d1685===_0x1c9a83)break;else _0x3d7013['push'](_0x3d7013['shift']());}catch(_0x18a466){_0x3d7013['push'](_0x3d7013['shift']());}}}(_0x41c1,0xa36c6),function(_0x34f466,_0x3027f1){var _0x2f9202=_0x5644;typeof exports=='object'&&typeof module<'u'?_0x3027f1(require('@univerjs-pro/chart-ui'),require('@univerjs-pro/engine-chart/facade')):typeof define==_0x2f9202(0xd8)&&define[_0x2f9202(0xcf)]?define([_0x2f9202(0xda),_0x2f9202(0xdd)],_0x3027f1):(_0x34f466=typeof globalThis<'u'?globalThis:_0x34f466||self,_0x3027f1(_0x34f466['UniverProChartUi'],_0x34f466[_0x2f9202(0xdc)]));}(this,function(_0x7a774a,_0x1e0ee3){var _0x2006c9=_0x5644,_0x7a48c6=class extends _0x1e0ee3[_0x2006c9(0xd7)]{[_0x2006c9(0xd0)](){var _0x492fc5=_0x2006c9;return this[_0x492fc5(0xca)][_0x492fc5(0xce)](_0x7a774a[_0x492fc5(0xd5)])['exportImage'](this);}};_0x1e0ee3[_0x2006c9(0xd7)][_0x2006c9(0xd1)](_0x7a48c6);}));function _0x5644(_0x3afb6e,_0x29f773){_0x3afb6e=_0x3afb6e-0xca;var _0x41c120=_0x41c1();var _0x56444d=_0x41c120[_0x3afb6e];return _0x56444d;}function _0x41c1(){var _0x10e64a=['function','99BfFQnO','@univerjs-pro/chart-ui','5924280LqVvPU','UniverProEngineChartFacade','@univerjs-pro/engine-chart/facade','_injector','340705HfFACN','912951FCZkxm','1847472Ibegyy','get','amd','exportImage','extend','24CvdJOj','939905ChpEal','695286FavRNn','ChartImageExportService','6417957ByzXwo','FChart'];_0x41c1=function(){return _0x10e64a;};return _0x41c1();}