@univerjs-pro/sheets-chart-ui 1.0.0-alpha.1 → 1.0.0-alpha.3

package/lib/types/services/chart-content-layout.d.ts

@@ -0,0 +1,35 @@
+export interface IChartOuterRect {
+    width: number;
+    height: number;
+    strokeWidth?: number;
+}
+export interface IChartScale {
+    scaleX?: number;
+    scaleY?: number;
+}
+export interface IChartFloatDomLayout {
+    startX: number;
+    endX: number;
+    startY: number;
+    endY: number;
+    width: number;
+    height: number;
+    absolute: {
+        left: boolean;
+        top: boolean;
+    };
+}
+export interface IChartHostPlacement extends IChartOuterRect {
+    left: number;
+    top: number;
+    scaleX: number;
+    scaleY: number;
+}
+export interface IChartOffset {
+    left: number;
+    top: number;
+}
+export declare function getChartContentRect(rect: IChartOuterRect, minSize?: number): IChartOuterRect;
+export declare function getChartHostPlacement(rect: IChartOuterRect, scale?: IChartScale, floatDomLayout?: IChartFloatDomLayout): IChartHostPlacement;
+export declare function getChartContentOffset(_scale?: IChartScale): IChartOffset;
+export declare function getChartFloatDomInnerOffset(layout?: IChartFloatDomLayout): IChartOffset;

package/lib/types/services/chart-element-popup-anchor.d.ts

@@ -0,0 +1,10 @@
+import type { IChartElementEvent } from '@univerjs-pro/engine-chart';
+import type { IDisposable } from '@univerjs/core';
+import type { IBoundRectNoAngle } from '@univerjs/engine-render';
+import type { Observable } from 'rxjs';
+export interface IChartElementPopupAnchorObserver extends IDisposable {
+    initialRect: IBoundRectNoAngle;
+    anchorRect$: Observable<IBoundRectNoAngle>;
+    visible: boolean;
+}
+export declare function createChartElementPopupAnchorObserver(event: IChartElementEvent, update$: Observable<unknown> | undefined, onHidden: () => void): IChartElementPopupAnchorObserver;

package/lib/types/services/chart-element-selection.d.ts

@@ -0,0 +1,9 @@
+import type { ChartElementConfigTarget } from '@univerjs-pro/chart-ui';
+import type { ChartModel, IChartElementHit } from '@univerjs-pro/engine-chart';
+import type { IChartEditPanelRoute } from './chart-panel-route';
+export interface ISheetsChartElementSelection {
+    target: ChartElementConfigTarget;
+    route: IChartEditPanelRoute;
+    showFloatMenu: boolean;
+}
+export declare function resolveSheetsChartElementSelection(chartModel: ChartModel, hit: IChartElementHit): ISheetsChartElementSelection | undefined;

package/lib/types/services/chart-image-rect.d.ts

@@ -0,0 +1,18 @@
+import type { ChartImageSource } from '@univerjs-pro/engine-chart';
+import type { IRectProps, IViewportInfo, UniverRenderingContext, Vector2 } from '@univerjs/engine-render';
+import { Rect } from '@univerjs/engine-render';
+export declare class ChartImageRect extends Rect {
+    private readonly _getImage;
+    private readonly _shouldSuppressSnapshot;
+    private readonly _disposeImage;
+    private _urlImage;
+    private _url;
+    constructor(key: string, config: IRectProps, _getImage: () => ChartImageSource | undefined, _shouldSuppressSnapshot?: () => boolean, _disposeImage?: () => void);
+    dispose(): void;
+    render(mainCtx: UniverRenderingContext, bounds?: IViewportInfo): this;
+    protected _draw(ctx: UniverRenderingContext, _bounds?: IViewportInfo, renderWidth?: number, renderHeight?: number): void;
+    private _drawChartFrame;
+    isHit(coord: Vector2): boolean;
+    private _drawChartImage;
+    private _getDrawable;
+}

package/lib/types/services/chart-panel-route.d.ts

@@ -0,0 +1,20 @@
+import type { ChartElementConfigTarget } from '@univerjs-pro/chart-ui';
+import type { IChartElementHit } from '@univerjs-pro/engine-chart';
+export interface IChartEditPanelRoute {
+    tab: 'style' | 'data';
+    section?: 'chartStyle' | 'chartAndAxisTitles' | 'legend' | 'horizontalAxis' | 'verticalAxis' | 'rightVerticalAxis' | 'series' | 'pieStyle' | 'paretoBarSeries' | 'paretoLineSeries' | 'waterfallSeries' | 'relation' | 'wordCloud';
+    titleKey?: 'title' | 'subtitle' | 'xAxisTitle' | 'yAxisTitle' | 'rightYAxisTitle';
+    axisId?: 'xAxis' | 'yAxis' | 'rightYAxis';
+    seriesId?: string;
+}
+export interface IChartSelectedElementState {
+    chartId: string;
+    element: IChartElementHit;
+    target: ChartElementConfigTarget;
+    route: IChartEditPanelRoute;
+}
+export interface IChartPanelRouteState {
+    chartId: string;
+    route: IChartEditPanelRoute | null;
+}
+export declare function resolveChartEditPanelRoute(target: ChartElementConfigTarget): IChartEditPanelRoute | undefined;

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

@@ -1,10 +1,13 @@
-import type { ChartDirection, ChartStyle, IChartConfig, IChartRenderModel } from '@univerjs-pro/engine-chart';
-import { ChartThemeService } from '@univerjs-pro/engine-chart';
+import type { ChartDirection, ChartElementEventHandler, ChartElementEventType, ChartImageSource, ChartStyle, IChartConfig, IChartRenderModel } from '@univerjs-pro/engine-chart';
+import type { IDisposable } from '@univerjs/core';
+import type { Scene } from '@univerjs/engine-render';
+import { ChartThemeService, IChartRenderModelManagerService } from '@univerjs-pro/engine-chart';
 import { ChartModelService } from '@univerjs-pro/sheets-chart';
 import { Disposable, IConfigService, Injector, IUniverInstanceService, LocaleService, ThemeService } from '@univerjs/core';
 import { IDrawingManagerService } from '@univerjs/drawing';
 import { IRenderManagerService } from '@univerjs/engine-render';
 import { SheetCanvasFloatDomManagerService } from '@univerjs/sheets-drawing-ui';
+import { ChartSnapshotStoreService } from './chart-snapshot-store.service';
 import { IChartHostProviderService } from './sheets-chart-host-provider.service';
 interface IRuntimeChartModel {
     id?: string;
@@ -25,30 +28,64 @@ export declare class ChartRenderService extends Disposable {
     private readonly _chartThemeService;
     private readonly _themeService;
     private readonly _configService;
-    private _renderModelMap;
+    private readonly _chartSnapshotStoreService;
     private _chartInstanceMap;
-    private _currentModel;
+    private _chartEventHandlers;
+    private _chartEventSubscriptions;
+    private _chartElementEditMode;
+    private readonly _renderModelManager;
+    private readonly _ownsRenderModelManager;
     private _renderDebounceMap;
     private _debounceHandleMap;
-    constructor(_chartHostProvider: IChartHostProviderService, _sheetCanvasFloatDomManagerService: SheetCanvasFloatDomManagerService, _chartModelService: ChartModelService, _drawingManagerService: IDrawingManagerService, _univerInstanceService: IUniverInstanceService, _renderManagerService: IRenderManagerService, _localeService: LocaleService, _injector: Injector, _chartThemeService: ChartThemeService, _themeService: ThemeService, _configService: IConfigService);
+    private readonly _chartRenderMode;
+    private readonly _lastRenderInputMap;
+    private _activeChartId;
+    private _lastActiveSheet;
+    constructor(_chartHostProvider: IChartHostProviderService, _sheetCanvasFloatDomManagerService: SheetCanvasFloatDomManagerService, _chartModelService: ChartModelService, _drawingManagerService: IDrawingManagerService, _univerInstanceService: IUniverInstanceService, _renderManagerService: IRenderManagerService, _localeService: LocaleService, _injector: Injector, _chartThemeService: ChartThemeService, _themeService: ThemeService, _configService: IConfigService, _chartSnapshotStoreService: ChartSnapshotStoreService, renderModelManager?: IChartRenderModelManagerService);
     private _getWatermark;
     registerRenderModel(name: string, renderModel: IChartRenderModel): void;
     setRenderModel(name: string): void;
+    getChartSnapshotImage(id: string): ChartImageSource | undefined;
+    private _resolveChartRenderMode;
+    private _getChartSnapshotKey;
+    private _registerChartImageRenderObjectFactory;
+    private _initActiveChartModelListener;
+    private _initDrawingDeactivationListener;
+    private _initActiveRuntimeLayerListener;
+    private _rerenderLatest;
+    private _disposeChartDomInstance;
+    private _disposeChartRenderInstance;
+    private _clearChartRuntimeCache;
+    private _clearSheetChartRuntimeCaches;
+    private _getChartRenderObject;
+    private _getChartRenderObjectContext;
+    private _setChartRuntimeZIndex;
+    private _applyActiveChartRuntimeZIndex;
+    private _resetChartRuntimeZIndex;
     _resizeChart(id: string, value: {
         width: number | undefined;
         height: number | undefined;
     }): void;
     private _debounceHandle;
     handleActiveSubUnitChange(): void;
+    setElementEditMode(chartId: string, enabled: boolean): void;
+    exportImage(chartId: string): Promise<string | undefined>;
+    on(chartId: string, type: ChartElementEventType, handler: ChartElementEventHandler): IDisposable;
+    private _getCurrentSnapshotImage;
+    private _bindChartEventHandlers;
+    private _bindChartEventHandler;
+    private _disposeChartEventSubscription;
+    private _disposeChartEventSubscriptions;
     getRenderModel(name: string): IChartRenderModel<Record<string, any>> | undefined;
-    private _ensureChartInstance;
     checkChartCanRender(id: string): boolean;
     private _getChartRenderSkipReason;
     render(id: string, config: IChartConfig, style: ChartStyle): Promise<void>;
-    printChart(id: string, chartHost: HTMLDivElement, rect: {
-        width: number;
-        height: number;
-    }): Promise<void>;
+    /** Render static chart snapshots into the print scene so drawing z-order is preserved. */
+    renderChartsForPrinting(unitId: string, subUnitId: string, scene: Scene): Promise<void>;
+    private _createPrintingChartObject;
+    private _getOrCreateChartRenderInstance;
+    private _createChartRenderInstanceContext;
+    private _cancelDebouncedCallbacks;
     dispose(): void;
 }
 export {};

package/lib/types/services/chart-snapshot-store.service.d.ts

@@ -0,0 +1,18 @@
+import type { ChartImageSource } from '@univerjs-pro/engine-chart';
+import { Disposable } from '@univerjs/core';
+export interface IChartSnapshotKey {
+    unitId: string;
+    subUnitId: string;
+    chartId: string;
+}
+export declare function disposeChartImageSource(image?: ChartImageSource): void;
+export declare class ChartSnapshotStoreService extends Disposable {
+    private readonly _entries;
+    nextVersion(key: IChartSnapshotKey): number;
+    isLatest(key: IChartSnapshotKey, version: number): boolean;
+    setImage(key: IChartSnapshotKey, image: ChartImageSource, version: number): boolean;
+    getImage(key: IChartSnapshotKey): ChartImageSource | undefined;
+    clearImage(key: IChartSnapshotKey): void;
+    clearChart(chartId: string): void;
+    dispose(): void;
+}

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

@@ -0,0 +1,56 @@
+import type { IChartHostRect, IChartHostStyle, IDomChartHost } from '@univerjs-pro/engine-chart';
+import type { SheetCanvasFloatDomManagerService } from '@univerjs/sheets-drawing-ui';
+import { ChartHostRenderMode } from '@univerjs-pro/engine-chart';
+import { Disposable } from '@univerjs/core';
+export interface IChartHostHandle {
+    mountNode: HTMLElement;
+    dispose: () => void;
+}
+export type ChartHostHandle = IChartHostHandle;
+export interface ISheetChartHostPlacement {
+    width: number;
+    height: number;
+    left: number;
+    top: number;
+    scaleX: number;
+    scaleY: number;
+}
+export type SheetChartHostPlacement = ISheetChartHostPlacement;
+export declare function createHostElement(width: number, height: number): HTMLDivElement;
+export declare class SheetChartHost extends Disposable implements IDomChartHost {
+    readonly chartId: string;
+    private readonly _getFloatDomInfo;
+    private readonly _getPlacement;
+    private readonly _setHostStyle;
+    private readonly _isProviderDisposed;
+    private readonly _markReady;
+    private readonly _markNotReady;
+    readonly mode = ChartHostRenderMode.Dom;
+    private _frameNode;
+    private _mountNode;
+    private _borderNode;
+    private _managed;
+    private _pendingToken;
+    private _pendingHost;
+    private _waiter;
+    private _hostStyle;
+    private _savedWrapperStyle;
+    constructor(chartId: string, _getFloatDomInfo: () => ReturnType<SheetCanvasFloatDomManagerService['getFloatDomInfo']>, _getPlacement: () => SheetChartHostPlacement | null, _setHostStyle: (style: IChartHostStyle) => void, _isProviderDisposed: () => boolean, _markReady: () => void, _markNotReady: () => void);
+    isManaged(): boolean;
+    markUnmanaged(): void;
+    getRect(): IChartHostRect | null;
+    setStyle(style: IChartHostStyle): void;
+    ensureHandle(): Promise<ChartHostHandle>;
+    ensureMount(): Promise<HTMLElement | null>;
+    checkMounted(): boolean;
+    syncLayout(): void;
+    markReady(): void;
+    markNotReady(): void;
+    dispose(): void;
+    private _createHost;
+    private _cancelHostWait;
+    private _applyHostPlacement;
+    private _applyHostStyle;
+    private _activateHostWrapper;
+    private _restoreHostWrapper;
+}

package/lib/types/services/sheet-image-chart-host.d.ts

@@ -0,0 +1,24 @@
+import type { ChartImageSource, IChartHostRect, IChartHostStyle } from '@univerjs-pro/engine-chart';
+import type { IChartOuterRect } from './chart-content-layout';
+import type { ChartSnapshotStoreService } from './chart-snapshot-store.service';
+import { ImageChartHost } from '@univerjs-pro/engine-chart';
+interface ChartSnapshotKey {
+    unitId: string;
+    subUnitId: string;
+    chartId: string;
+}
+export declare class SheetImageChartHost extends ImageChartHost {
+    private readonly _getOuterRect;
+    private readonly _setHostStyle;
+    private readonly _snapshotKey;
+    private readonly _snapshotStore;
+    private readonly _requestPaint;
+    constructor(chartId: string, _getOuterRect: () => IChartOuterRect | null, _setHostStyle: (style: IChartHostStyle) => void, _snapshotKey: ChartSnapshotKey, _snapshotStore: ChartSnapshotStoreService, _requestPaint: () => void);
+    getRect(): IChartHostRect | null;
+    setStyle(style: IChartHostStyle): void;
+    nextVersion(): number;
+    commitSnapshot(image: ChartImageSource, version: number): boolean;
+    requestPaint(): void;
+    invalidateSnapshot(): void;
+}
+export {};

package/lib/types/services/sheets-chart-host-provider.service.d.ts

@@ -1,35 +1,59 @@
-import type { Rect } from '@univerjs/engine-render';
+import type { IDomChartHost, IImageChartHost } from '@univerjs-pro/engine-chart';
 import type { Observable } from 'rxjs';
+import type { IChartOuterRect } from './chart-content-layout';
+import type { ChartHostHandle } from './sheet-chart-host';
+import { ChartHostRenderMode } from '@univerjs-pro/engine-chart';
 import { Disposable } from '@univerjs/core';
 import { IRenderManagerService } from '@univerjs/engine-render';
 import { SheetCanvasFloatDomManagerService } from '@univerjs/sheets-drawing-ui';
+import { ChartSnapshotStoreService } from './chart-snapshot-store.service';
 export interface IChartHostProviderService {
-    ensureHost: (chartId: string) => Promise<{
+    ensureHost(chartId: string, mode: 'image'): Promise<IImageChartHost | null>;
+    ensureHost(chartId: string, mode: 'dom'): Promise<IDomChartHost | null>;
+    ensureHost(chartId: string, mode: ChartHostRenderMode): Promise<IImageChartHost | IDomChartHost | null>;
+    ensureHost(chartId: string): Promise<{
         mountNode: string | HTMLElement;
-        dispose?: () => void;
+        dispose: () => void;
     }>;
     setHostStyle: (chartId: string, style: Record<string, any>) => void;
-    getHostSize: (chartId: string) => Rect | null;
+    getHostSize: (chartId: string) => IChartOuterRect | null;
     removeHost$: Observable<string>;
+    removeHost: (chartId: string) => void;
     checkHost: (chartId: string) => boolean;
+    syncHostLayout: (chartId: string) => void;
+    isDomReady: (chartId: string) => boolean;
+    markHostNotReady: (chartId: string) => void;
+    invalidateSnapshot: (chartId: string) => void;
 }
-export declare function createHostElement(width: number, height: number): HTMLDivElement;
 export declare class SheetsChartHostProviderService extends Disposable implements IChartHostProviderService {
     private readonly _sheetCanvasFloatDomManagerService;
     private _renderManagerService;
-    private _mountNodes;
+    private readonly _chartSnapshotStoreService;
+    private _chartHostMap;
+    private _activeDomReadyChartIds;
     private _removeHost$;
     readonly removeHost$: Observable<string>;
-    constructor(_sheetCanvasFloatDomManagerService: SheetCanvasFloatDomManagerService, _renderManagerService: IRenderManagerService);
+    constructor(_sheetCanvasFloatDomManagerService: SheetCanvasFloatDomManagerService, _renderManagerService: IRenderManagerService, _chartSnapshotStoreService: ChartSnapshotStoreService);
     private _getSceneAndTransformerByDrawingSearch;
     setBorder(id: string, color: string): void;
     setHostStyle(id: string, style: Record<string, any>): void;
-    getHostSize(id: string): Rect | null;
+    getHostSize(id: string): IChartOuterRect | null;
     checkHost(id: string): boolean;
-    ensureHost(id: string): Promise<{
-        mountNode: HTMLElement;
-        dispose: () => void;
-    }>;
-    private _createHost;
+    syncHostLayout(id: string): void;
+    removeHost(id: string): void;
+    ensureHost(id: string): Promise<ChartHostHandle>;
+    ensureHost(id: string, mode: ChartHostRenderMode.Image | 'image'): Promise<IImageChartHost | null>;
+    ensureHost(id: string, mode: ChartHostRenderMode.Dom | 'dom'): Promise<IDomChartHost | null>;
+    ensureHost(id: string, mode: ChartHostRenderMode | 'image' | 'dom'): Promise<IImageChartHost | IDomChartHost | null>;
+    isDomReady(id: string): boolean;
+    markHostNotReady(id: string): void;
+    invalidateSnapshot(id: string): void;
+    private _createImageChartHost;
+    private _getOrCreateSheetChartHost;
+    private _markHostReady;
+    private _getChartSnapshotKey;
+    private _requestChartCanvasRender;
+    private _getHostPlacement;
+    dispose(): void;
 }
 export declare const IChartHostProviderService: import("@wendellhu/redi").IdentifierDecorator<IChartHostProviderService>;

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

@@ -1,12 +1,13 @@
 import type { AreaLineStyle, ChartModel, ChartStyle, DeepPartial, IAllSeriesStyle, IAxisOptions, IChartContext, IChartStyle, ILegendStyle, InvalidValueType, IPieLabelStyle, IRelationForceOptions, IRuntimeAxis, ITrendLine, LinePointShape, RadarShape, RelationChartLayoutEnum, RightYAxisOptions, TitlePositionEnum, WaterfallStackTypeEnum, WordCloudShapeEnum } from '@univerjs-pro/engine-chart';
-import type { IChartSourceMultiRangeItem, IChartUpdateConfigCommandParams, IChartUpdateSourceCommandParams, ISheetChartSourceSingleRange } from '@univerjs-pro/sheets-chart';
+import type { IChartSourceMultiRangeItem, IChartUpdateConfigCommandParams, IChartUpdateSourceCommandParams, ISheetChartSourceSingleRange, SheetChartModel } from '@univerjs-pro/sheets-chart';
 import type { Nullable } from '@univerjs/core';
 import type { Observable } from 'rxjs';
+import type { IChartEditPanelRoute, IChartPanelRouteState, IChartSelectedElementState } from './chart-panel-route';
 import { CategoryType, ChartTypeBits, DataOrientation } from '@univerjs-pro/engine-chart';
 import { ChartModelService, SheetsChartService } from '@univerjs-pro/sheets-chart';
 import { Disposable, ICommandService, IUniverInstanceService, LocaleService } from '@univerjs/core';
 import { IChartHostProviderService } from './sheets-chart-host-provider.service';
-export declare function registryChartConfigState(service: SheetsChartUIService): void;
+export declare function registryChartConfigState(service: ISheetsChartUIService): void;
 export interface IChartOptionType {
     label: string;
     value: string;
@@ -61,11 +62,11 @@ export interface IChartConfigStateMap {
     dataPointsOptions: IChartConfigState<Nullable<IChartOptionType[]>>;
     chartThemeColorType: IChartConfigState<Nullable<string>>;
     titlePosition: IChartConfigState<Nullable<TitlePositionEnum>, TitlePositionEnum>;
-    bubbleSizeSeriesId: IChartConfigState<Nullable<number>, number | undefined>;
-    bubbleXAxis: IChartConfigState<Nullable<number>, number>;
-    bubbleYAxis: IChartConfigState<Nullable<number>, number>;
-    bubbleLabel: IChartConfigState<Nullable<number>, number>;
-    bubbleSeries: IChartConfigState<Nullable<number>, number>;
+    bubbleSizeIndex: IChartConfigState<Nullable<number>, number | undefined>;
+    scatterXIndex: IChartConfigState<Nullable<number>, number>;
+    scatterYIndex: IChartConfigState<Nullable<number>, number>;
+    scatterLabelIndex: IChartConfigState<Nullable<number>, number>;
+    bubbleSeriesIndex: IChartConfigState<Nullable<number>, number>;
     relationLayout: IChartConfigState<Nullable<RelationChartLayoutEnum>, RelationChartLayoutEnum>;
     useValueAsSymbolSize: IChartConfigState<Nullable<boolean>, boolean>;
     forceOption: IChartConfigState<Nullable<IRelationForceOptions>, IRelationForceOptions | undefined>;
@@ -91,7 +92,32 @@ export type IChartConfigState<GetValue, SetValue = GetValue> = {
     set?(value: SetValue): void;
     get(): Observable<GetValue> | undefined;
 } | Observable<GetValue>;
-export declare class SheetsChartUIService extends Disposable {
+export interface ISheetsChartUIService {
+    readonly activeChartModel: Nullable<SheetChartModel>;
+    readonly activeChartModel$: Observable<Nullable<SheetChartModel>>;
+    readonly activeEditChart: string | null;
+    readonly activeEditChart$: Observable<string | null>;
+    readonly direction$: LocaleService['direction$'];
+    readonly panelRoute$: Observable<IChartPanelRouteState | null>;
+    readonly rangeSelectMode: boolean;
+    readonly selectedElement$: Observable<IChartSelectedElementState | null>;
+    setActiveEditChart(chartId: string | null): void;
+    setRangeSelectMode(on: boolean): void;
+    isElementEditModeActive(chartId: string): boolean;
+    setSelectedElement(state: IChartSelectedElementState | null): void;
+    setPanelRoute(chartId: string, route: IChartEditPanelRoute | null): void;
+    clearPanelRoute(): void;
+    getDataSource(id: string): ReturnType<SheetsChartService['getChartDataSource']>;
+    registerViewState<T extends ChartConfigStateKey = ChartConfigStateKey>(id: T, state: (chartModel: ChartModel) => IChartConfigStateMap[T]): void;
+    getViewState<V extends ChartConfigStateValue = ChartConfigStateValue>(id: ChartConfigStateKey, activeChartModel?: Nullable<SheetChartModel>): IChartConfigState<V> | undefined;
+    executeChartUpdateConfig(params: Omit<IChartUpdateConfigCommandParams, 'unitId'>): void;
+    executeChartUpdateSourceConfig(params: Omit<IChartUpdateSourceCommandParams, 'unitId'>): void;
+    removeViewState(id: ChartConfigStateKey): void;
+    setBorder(id: string, color: string): void;
+    t(...args: Parameters<LocaleService['t']>): string;
+}
+export declare const ISheetsChartUIService: import("@wendellhu/redi").IdentifierDecorator<ISheetsChartUIService>;
+export declare class SheetsChartUIService extends Disposable implements ISheetsChartUIService {
     private readonly _chartModelService;
     private readonly _sheetsChartService;
     private readonly _commandService;
@@ -100,14 +126,27 @@ export declare class SheetsChartUIService extends Disposable {
     private _univerInstanceService;
     private _viewState;
     private _rangeSelectMode;
+    private readonly _activeEditChart$;
+    private readonly _selectedElement$;
+    private readonly _panelRoute$;
+    readonly activeEditChart$: Observable<string | null>;
+    readonly selectedElement$: Observable<IChartSelectedElementState | null>;
+    readonly panelRoute$: Observable<IChartPanelRouteState | null>;
     constructor(_chartModelService: ChartModelService, _sheetsChartService: SheetsChartService, _commandService: ICommandService, _localeService: LocaleService, _chartHostProviderService: IChartHostProviderService, _univerInstanceService: IUniverInstanceService);
-    get activeChartModel(): Nullable<import("@univerjs-pro/sheets-chart").SheetChartModel>;
+    get activeChartModel(): Nullable<SheetChartModel>;
+    get activeChartModel$(): Observable<Nullable<SheetChartModel>>;
     get rangeSelectMode(): boolean;
+    get activeEditChart(): string | null;
     get direction$(): Observable<"ltr" | "rtl">;
-    set rangeSelectMode(on: boolean);
+    setRangeSelectMode(on: boolean): void;
+    setActiveEditChart(chartId: string | null): void;
+    isElementEditModeActive(chartId: string): boolean;
+    setSelectedElement(state: IChartSelectedElementState | null): void;
+    setPanelRoute(chartId: string, route: IChartEditPanelRoute | null): void;
+    clearPanelRoute(): void;
     getDataSource(id: string): import("@univerjs-pro/sheets-chart/models/types.js").ISheetChartDataSource | undefined;
     registerViewState<T extends ChartConfigStateKey = ChartConfigStateKey>(id: T, state: (chartModel: ChartModel) => IChartConfigStateMap[T]): void;
-    getViewState<V extends ChartConfigStateValue = ChartConfigStateValue>(id: ChartConfigStateKey): IChartConfigState<V> | undefined;
+    getViewState<V extends ChartConfigStateValue = ChartConfigStateValue>(id: ChartConfigStateKey, activeChartModel?: Nullable<SheetChartModel>): IChartConfigState<V> | undefined;
     executeChartUpdateConfig(params: Omit<IChartUpdateConfigCommandParams, 'unitId'>): void;
     executeChartUpdateSourceConfig(params: Omit<IChartUpdateSourceCommandParams, 'unitId'>): void;
     removeViewState(id: ChartConfigStateKey): void;