@univerjs-pro/chart-ui 1.0.0-alpha.7 → 1.0.0-beta.0

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

@@ -0,0 +1,58 @@
+import type { IStaticChartModelRuntime } 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 IStaticChartModelRuntime = IStaticChartModelRuntime> {
+    render(request: TRequest, runtime: TRuntime): Promise<string>;
+}
+export interface IChartSnapshotRuntimeProvider<TRuntime extends IStaticChartModelRuntime> {
+    ensureChartModel(unitId: string, chartId: string): TRuntime | undefined;
+    getChartModel(unitId: string, chartId: string): TRuntime | undefined;
+}
+export declare class ChartSnapshotQueue<TRequest extends IChartSnapshotRequest, TRuntime extends IStaticChartModelRuntime = IStaticChartModelRuntime> 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;
+    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;