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

package/lib/types/models/chart-data/builders/hierarchy-chart-data.d.ts

@@ -0,0 +1,5 @@
+import type { IChartContext, IChartData, IUniverDataSet } from '../../../types';
+import type { IChartLocaleTexts } from '../../common/chart-locale-texts';
+import type { IChartFieldConsumption } from '../chart-field-consumption';
+export declare function buildTreemapChartData(dataSet: IUniverDataSet, fieldConsumption: IChartFieldConsumption, chartContext: IChartContext, localeTexts: IChartLocaleTexts): IChartData;
+export declare function buildSunburstChartData(dataSet: IUniverDataSet, fieldConsumption: IChartFieldConsumption, chartContext: IChartContext, localeTexts: IChartLocaleTexts): IChartData;

package/lib/types/models/chart-data/builders/histogram-chart-data.d.ts

@@ -0,0 +1,4 @@
+import type { IChartContext, IChartData, IUniverDataSet } from '../../../types';
+import type { IChartLocaleTexts } from '../../common/chart-locale-texts';
+import type { IChartFieldConsumption } from '../chart-field-consumption';
+export declare function buildHistogramChartData(dataSet: IUniverDataSet, fieldConsumption: IChartFieldConsumption, chartContext: IChartContext, localeTexts: IChartLocaleTexts): IChartData;

package/lib/types/models/chart-data/builders/relation-chart-data.d.ts

@@ -0,0 +1,3 @@
+import type { IChartContext, IChartData, IUniverDataSet } from '../../../types';
+import type { IChartFieldConsumption } from '../chart-field-consumption';
+export declare function buildRelationChartData(dataSet: IUniverDataSet, fieldConsumption: IChartFieldConsumption, _chartContext: IChartContext): IChartData;

package/lib/types/models/chart-data/builders/sankey-chart-data.d.ts

@@ -0,0 +1,3 @@
+import type { IChartContext, IChartData, IUniverDataSet } from '../../../types';
+import type { IChartFieldConsumption } from '../chart-field-consumption';
+export declare function buildSankeyChartData(dataSet: IUniverDataSet, fieldConsumption: IChartFieldConsumption, _chartContext: IChartContext): IChartData;

package/lib/types/models/chart-data/chart-field-consumption-validator.d.ts

@@ -0,0 +1,15 @@
+import type { ChartTypeBits } from '../../enum';
+import type { IUniverDataSet } from '../../types';
+import type { IChartFieldDiagnostic } from '../common/chart-field-diagnostic';
+import type { IChartFieldConsumption } from './chart-field-consumption';
+export type ChartFieldValidationResult = {
+    valid: true;
+} | {
+    valid: false;
+    diagnostic: IChartFieldDiagnostic;
+};
+export declare function validateChartFieldConsumption(input: {
+    chartType: ChartTypeBits;
+    consumption: IChartFieldConsumption;
+    dataSet: IUniverDataSet;
+}): ChartFieldValidationResult;

package/lib/types/models/chart-data/chart-field-consumption.d.ts

@@ -0,0 +1,4 @@
+export interface IChartFieldConsumption {
+    categoryIndexes: readonly number[];
+    seriesIndexes: readonly number[];
+}

package/lib/types/models/chart-data/chart-field-requirements.d.ts

@@ -0,0 +1,7 @@
+import type { IUniverDataSet } from '../../types';
+import { ChartTypeBits } from '../../enum';
+export interface IChartRequiredFieldCounts {
+    categoryRequiredCount: number;
+    seriesRequiredCount: number;
+}
+export declare function getChartRequiredFieldCounts(chartType: ChartTypeBits, dataSet: IUniverDataSet): IChartRequiredFieldCounts | undefined;

package/lib/types/models/chart-data/get-chart-data-builder.d.ts

@@ -0,0 +1,7 @@
+import type { IChartDataAggregation } from '../../chart-data-aggregation';
+import type { IChartContext, IChartData, IUniverDataSet } from '../../types';
+import type { IChartLocaleTexts } from '../common/chart-locale-texts';
+import type { IChartFieldConsumption } from './chart-field-consumption';
+import { ChartTypeBits } from '../../enum';
+export type ChartDataBuilder = (dataSet: IUniverDataSet, fieldConsumption: IChartFieldConsumption, chartContext: IChartContext, localeTexts: IChartLocaleTexts, dataAggregation?: IChartDataAggregation) => IChartData;
+export declare function getChartDataBuilder(chartType: ChartTypeBits): ChartDataBuilder;

package/lib/types/models/chart-data/internal/aggregate-number-format.d.ts

@@ -0,0 +1,8 @@
+import type { IUniverDataSet } from '../../../types';
+/**
+ * Reconstructs the visible number pattern carried by a normalized chart source.
+ * Source datasets currently expose formatted labels rather than number-format codes,
+ * so aggregates reuse the first positive finite sample's prefix, suffix, separators,
+ * scale, and precision instead of copying any input cell's already-formatted value.
+ */
+export declare function createAggregateNumberFormatter(dataSet: IUniverDataSet, fieldIndex: number): (value: number) => string;

package/lib/types/models/{chart-data-operators → chart-data/internal}/cartesian-point-data.d.ts

@@ -1,10 +1,5 @@
-import type { IUniverDataSet } from '../../types';
-import type { IChartLocaleTexts } from '../chart-locale-texts';
-export declare enum CartesianPointRoleIndex {
-    X = 0,
-    Y = 1,
-    Size = 2
-}
+import type { IUniverDataSet } from '../../../types';
+import type { IChartLocaleTexts } from '../../common/chart-locale-texts';
 export declare enum CartesianPointValueIndex {
     X = 0,
     Y = 1,
@@ -39,5 +34,5 @@ interface ICartesianPointRoleIndexes {
     headers?: string[];
 }
 /** Builds normalized Cartesian point records consumed by coordinate-chart converters. */
-export declare function buildCartesianPointData(dataSource: IUniverDataSet, roles: ICartesianPointRoleIndexes, localeTexts: IChartLocaleTexts): ICartesianPointData;
+export declare function buildCartesianPointData(dataSet: IUniverDataSet, roles: ICartesianPointRoleIndexes, localeTexts: IChartLocaleTexts, visitRecord?: (record: ICartesianPointRecord) => void): ICartesianPointData;
 export {};

package/lib/types/models/chart-data/internal/category-data.d.ts

@@ -0,0 +1,3 @@
+import type { IChartContext, IChartData, IUniverDataSet } from '../../../types';
+import type { IChartLocaleTexts } from '../../common/chart-locale-texts';
+export declare function buildChartCategory(dataSet: IUniverDataSet, categoryIndex: number | undefined, chartContext: IChartContext, localeTexts: IChartLocaleTexts): IChartData['category'];

package/lib/types/models/chart-data/internal/category-series-aggregation.d.ts

@@ -0,0 +1,10 @@
+import type { IChartDataAggregation } from '../../../chart-data-aggregation';
+import type { IUniverDataSet } from '../../../types';
+import type { IChartFieldConsumption } from '../chart-field-consumption';
+/**
+ * Projects category/value rows while preserving source-field indexes.
+ *
+ * This runs after field-consumption validation, so callers continue to own chart-specific
+ * mapping rules and this module owns only ordinary category/value aggregation and ranking.
+ */
+export declare function projectCategorySeriesData(dataSet: IUniverDataSet, fieldConsumption: IChartFieldConsumption, dataAggregation: IChartDataAggregation | undefined): IUniverDataSet;

package/lib/types/models/chart-data/internal/chart-data-result.d.ts

@@ -0,0 +1,5 @@
+import type { IChartData } from '../../../types';
+import type { IChartFieldDiagnostic } from '../../common/chart-field-diagnostic';
+export declare function createEmptyChartData(headers?: string[]): IChartData;
+export declare function createInvalidChartData(headers: string[] | undefined, fieldDiagnostic: IChartFieldDiagnostic): IChartData;
+export declare function calculateNumericExtent<T>(items: readonly T[], getValue: (item: T) => number): Pick<IChartData, 'maxValue' | 'minValue'>;

package/lib/types/models/chart-data/internal/chart-hierarchy-data.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/types/models/chart-data/internal/chord-data.d.ts

@@ -0,0 +1,7 @@
+import type { IChartChordData, IUniverDataSet } from '../../../types';
+import type { IChartLocaleTexts } from '../../common/chart-locale-texts';
+import type { IChartFieldConsumption } from '../chart-field-consumption';
+export declare const CHORD_NODE_ID_PREFIX = "chord-node:";
+export declare const CHORD_LINK_ID_PREFIX = "chord-link:";
+/** Resolves a normalized spreadsheet edge list into one undirected semantic graph. */
+export declare function buildChordData(dataSet: IUniverDataSet, fields: IChartFieldConsumption, localeTexts: IChartLocaleTexts): IChartChordData;

package/lib/types/models/chart-data/internal/data-set-accessors.d.ts

@@ -0,0 +1,7 @@
+import type { DimensionDefinitionLoose, IUniverDataSet, OptionDataValue } from '../../../types';
+export declare function getRawDataValue(dataSet: IUniverDataSet, fieldIndex: number, itemIndex: number): OptionDataValue;
+export declare function getDataValue(dataSet: IUniverDataSet, fieldIndex: number, itemIndex: number): OptionDataValue;
+export declare function getDataLabel(dataSet: IUniverDataSet, fieldIndex: number, itemIndex: number): string;
+export declare function getDimensionLabel(value: DimensionDefinitionLoose | undefined): string;
+export declare function getDataSetItemCount(dataSet: IUniverDataSet, fieldIndex: number, categoryIndex?: number): number;
+export declare function getDataSetRowCount(dataSet: IUniverDataSet): number;

package/lib/types/models/chart-data/internal/gauge-data.d.ts

@@ -0,0 +1,5 @@
+import type { IChartGaugeData, IUniverDataSet } from '../../../types';
+import type { IChartLocaleTexts } from '../../common/chart-locale-texts';
+import type { IChartFieldConsumption } from '../chart-field-consumption';
+export declare const GAUGE_ITEM_ID_PREFIX = "gauge-item:";
+export declare function buildGaugeData(dataSet: IUniverDataSet, fields: IChartFieldConsumption, localeTexts: IChartLocaleTexts): IChartGaugeData;

package/lib/types/models/{chart-data-operators/histogram-data.d.ts → chart-data/internal/histogram-bins.d.ts}

@@ -1,4 +1,4 @@
-import type { IChartHistogramBin, IChartHistogramDataSpec } from '../../types';
+import type { IChartHistogramBin, IChartHistogramDataSpec } from '../../../types';
 export declare const MAX_HISTOGRAM_BIN_COUNT = 1000;
 export interface IBuildHistogramBinsResult {
     bins: IChartHistogramBin[];

package/lib/types/models/chart-data/internal/relation-data-shape.d.ts

@@ -0,0 +1,2 @@
+import type { IUniverDataSet } from '../../../types';
+export declare function isRelationMatrixDataSet(dataSet: IUniverDataSet): boolean;

package/lib/types/models/chart-data/internal/source-cell-label.d.ts

@@ -0,0 +1,3 @@
+import type { IUniverDataSet } from '../../../types';
+/** Uses source-owned display formatting and falls back to the shared general scalar label. */
+export declare function getSourceCellLabel(dataSet: IUniverDataSet, fieldIndex: number, itemIndex: number): string;

package/lib/types/models/chart-data/internal/sunburst-data.d.ts

@@ -0,0 +1,4 @@
+import type { IChartSunburstData, IUniverDataSet } from '../../../types';
+import type { IChartFieldConsumption } from '../chart-field-consumption';
+/** Builds runtime-only Sunburst data through the shared hierarchy policy. */
+export declare function buildSunburstData(dataSet: IUniverDataSet, fields: IChartFieldConsumption, diagnostic?: string): IChartSunburstData;

package/lib/types/models/chart-data/internal/treemap-data.d.ts

@@ -0,0 +1,4 @@
+import type { IChartTreemapData, IUniverDataSet } from '../../../types';
+import type { IChartFieldConsumption } from '../chart-field-consumption';
+/** Builds Treemap runtime data through the shared renderer-independent hierarchy policy. */
+export declare function buildTreemapData(dataSet: IUniverDataSet, fields: IChartFieldConsumption, diagnostic?: string): IChartTreemapData;

package/lib/types/models/chart-data/pie-composite/pie-composite-projection.d.ts

@@ -0,0 +1,36 @@
+import type { IChartPieCompositeSpec, PieSecondaryPlotType } from '../../../chart-builder/chart-types';
+import { PieCompositeMarkRole, PieCompositePlot } from '../../../chart-builder/chart-types';
+export declare const PieCompositeDiagnosticCode: {
+    readonly InsufficientSourcePoints: "insufficientSourcePoints";
+    readonly InvalidSecondaryPlot: "invalidSecondaryPlot";
+    readonly InvalidPositionCount: "invalidPositionCount";
+    readonly EmptySecondarySelection: "emptySecondarySelection";
+    readonly AllPointsSelected: "allPointsSelected";
+};
+export type PieCompositeDiagnosticCode = typeof PieCompositeDiagnosticCode[keyof typeof PieCompositeDiagnosticCode];
+export type PieCompositeDatum = {
+    plot: typeof PieCompositePlot.Primary | typeof PieCompositePlot.Secondary;
+    role: typeof PieCompositeMarkRole.Source;
+    sourcePointIndex: number;
+} | {
+    plot: typeof PieCompositePlot.Primary;
+    role: typeof PieCompositeMarkRole.Aggregate;
+    memberSourcePointIndexes: readonly number[];
+    value: number;
+};
+export interface IPieCompositeDiagnostic {
+    code: PieCompositeDiagnosticCode;
+    sourcePointCount: number;
+    selectedPointCount: number;
+}
+export interface IPieCompositeProjection {
+    active: boolean;
+    primary: readonly PieCompositeDatum[];
+    secondary: readonly PieCompositeDatum[];
+    secondaryPlotType?: PieSecondaryPlotType;
+    diagnostics: readonly IPieCompositeDiagnostic[];
+}
+export declare function projectCompositePie(values: readonly number[], composite?: IChartPieCompositeSpec | {
+    enabled?: boolean;
+    secondaryPlot?: Partial<IChartPieCompositeSpec['secondaryPlot']>;
+}): IPieCompositeProjection;

package/lib/types/models/chart-data/pie-composite/pie-composite-render-metadata.d.ts

@@ -0,0 +1,15 @@
+import type { PieCompositeDatum } from './pie-composite-projection';
+export declare const PIE_COMPOSITE_METADATA_FIELD = "pieComposite";
+export declare const PIE_COMPOSITE_PERCENT_FIELD = "pieCompositePercent";
+export declare const PIE_COMPOSITE_SERIES_PLOT_FIELD = "pieCompositePlot";
+export declare const PIE_COMPOSITE_PRIMARY_SERIES_ID = "pie-composite-primary";
+export declare const PIE_COMPOSITE_SECONDARY_SERIES_ID = "pie-composite-secondary";
+export declare const PIE_COMPOSITE_SECONDARY_STACK_ID = "pie-composite-secondary";
+export declare const PIE_COMPOSITE_CONNECTOR_GRAPHIC_ID = "pie-composite-connector";
+export interface IPieCompositeMarkMetadata {
+    plot: PieCompositeDatum['plot'];
+    role: PieCompositeDatum['role'];
+    sourcePointIndex?: number;
+    memberSourcePointIndexes?: readonly number[];
+}
+export declare function toPieCompositeMarkMetadata(datum: PieCompositeDatum): IPieCompositeMarkMetadata;

package/lib/types/models/chart-data/pie-composite/pie-composite-spec.d.ts

@@ -0,0 +1,38 @@
+import type { IChartPieCompositeSpec, PieSecondaryPlotType } from '../../../chart-builder/chart-types';
+import type { DeepNullish } from '../../../types';
+import { ChartBorderDashType } from '../../../enum';
+export declare const PIE_COMPOSITE_MIN_SOURCE_POINT_COUNT = 2;
+export declare const PIE_AUTO_SPLIT_DIVISOR = 3;
+export declare const PIE_PERCENTAGE_WHOLE = 100;
+export declare const PIE_SECONDARY_SIZE_MIN = 5;
+export declare const PIE_SECONDARY_SIZE_MAX = 200;
+export declare const PIE_SECONDARY_SIZE_DEFAULT = 75;
+export declare const PIE_SECONDARY_GAP_WIDTH_MIN = 0;
+export declare const PIE_SECONDARY_GAP_WIDTH_MAX = 500;
+export declare const PIE_SECONDARY_GAP_WIDTH_DEFAULT = 150;
+export declare const PIE_POSITION_SPLIT_COUNT_MIN = 1;
+export declare const PIE_POSITION_SPLIT_COUNT_DEFAULT = 2;
+export declare const PIE_VALUE_SPLIT_LESS_THAN_DEFAULT = 0;
+export declare const PIE_PERCENTAGE_SPLIT_LESS_THAN_DEFAULT = 10;
+export declare const PIE_AGGREGATE_COLOR_DEFAULT = "#D9D9D9";
+export declare const PIE_CONNECTOR_VISIBLE_DEFAULT = true;
+export declare const PIE_CONNECTOR_COLOR_DEFAULT = "#8C8C8C";
+export declare const PIE_CONNECTOR_WIDTH_DEFAULT = 1;
+export declare const PIE_CONNECTOR_OPACITY_DEFAULT = 1;
+export declare const PIE_CONNECTOR_DASH_TYPE_DEFAULT = ChartBorderDashType.Solid;
+export declare const PIE_COMPOSITE_SECONDARY_PLOT_REQUIRED_ERROR = "Active Pie composite requires a secondary plot with type \"pie\" or \"bar\".";
+export declare const PIE_COMPOSITE_INVALID_VALUE_ERROR_PREFIX = "Invalid Pie composite value";
+export declare function assertPieCompositePatch(current: DeepNullish<IChartPieCompositeSpec> | null | undefined, patch: DeepNullish<IChartPieCompositeSpec> | null | undefined): void;
+/**
+ * Composite Pie fields were added to the persisted Pie style additively.
+ * Historical snapshots omit `composite`, and an abandoned transition shape can
+ * omit `enabled`; both remain disabled without materializing persisted defaults.
+ */
+export declare function resolveActivePieComposite(pie: {
+    composite?: {
+        enabled?: boolean | null;
+        secondaryPlot?: {
+            type?: PieSecondaryPlotType | null;
+        } | null;
+    } | null;
+} | null | undefined): IChartPieCompositeSpec | undefined;

package/lib/types/models/{chart-host-style.d.ts → chart-host/chart-host-style.d.ts}

@@ -1,4 +1,4 @@
-import type { ChartImageSource, ChartStyle, IChartHostBorderStyle, IChartHostRect, IChartHostStyle } from '../types';
+import type { ChartImageSource, ChartStyle, IChartHostBorderStyle, IChartHostRect, IChartHostStyle } from '../../types';
 export interface IResolveChartHostFrameStyleInput {
     style?: ChartStyle | null;
     getRenderColor?: (color: string) => string;

package/lib/types/models/chart-host/config/chart-config-interpreter.d.ts

@@ -0,0 +1,13 @@
+import type { IChartDataAggregation } from '../../../chart-data-aggregation';
+import type { ChartStyle, IChartContext } from '../../../types';
+import type { IChartResourceSnapshot } from '../resource/chart-resource-repository';
+export interface IChartConfigUpdate {
+    chartType?: IChartResourceSnapshot['chartType'];
+    style?: ChartStyle;
+    context?: IChartContext;
+    dataAggregation?: Partial<IChartDataAggregation>;
+    patch?: Partial<Omit<IChartResourceSnapshot, 'id'>>;
+}
+export declare const chartConfigInterpreter: {
+    apply(previous: IChartResourceSnapshot, update: IChartConfigUpdate, replaceConfig: boolean): IChartResourceSnapshot | null;
+};

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

@@ -1,6 +1,6 @@
-import type { ChartImageSource, IChartHostLease, IChartHostRect, IChartHostStyle, IImageChartHost } from '../types';
+import type { ChartImageSource, IChartHostLease, IChartHostRect, IChartHostStyle, IImageChartHost } from '../../types';
 import { Disposable } from '@univerjs/core';
-import { ChartHostRenderMode } from '../types';
+import { ChartHostRenderMode } from '../../types';
 export declare function chartImageSourceToDataUrl(image: ChartImageSource): string;
 export declare abstract class ImageChartHost extends Disposable implements IImageChartHost {
     readonly chartId: string;
@@ -16,3 +16,15 @@ export declare abstract class ImageChartHost extends Disposable implements IImag
     acquireOffscreenHost(rect: IChartHostRect): IChartHostLease;
     dispose(): void;
 }
+export declare class DataUrlImageChartHost extends ImageChartHost {
+    private readonly _rect;
+    private _dataUrl;
+    constructor(chartId: string, _rect: IChartHostRect);
+    getRect(): IChartHostRect;
+    setStyle(_style: IChartHostStyle): void;
+    nextVersion(): number;
+    commitSnapshot(image: ChartImageSource, _version: number): boolean;
+    requestPaint(): void;
+    invalidateSnapshot(): void;
+    getDataUrl(): string | undefined;
+}

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

@@ -1,4 +1,4 @@
-import type { IChartHostLease, IChartHostRect } from '../types';
+import type { IChartHostLease, IChartHostRect } from '../../types';
 import { Disposable } from '@univerjs/core';
 export declare class OffscreenChartHost extends Disposable {
     private readonly _leases;

package/lib/types/models/chart-host/resource/chart-data-source-resolver.d.ts

@@ -0,0 +1,58 @@
+import type { IDisposable } from '@univerjs/core';
+import type { Observable } from 'rxjs';
+import type { ChartDataSourceValue } from './inline-chart-table';
+import type { IResourceRefChartDataSourceReference } from './resource-ref-chart-data-source.adapter';
+import { Disposable } from '@univerjs/core';
+export declare enum ChartDataSourceRuntimeStatus {
+    LOADING = "loading",
+    READY = "ready",
+    UNAVAILABLE = "unavailable",
+    REFRESH_ERROR = "refresh-error"
+}
+export interface IChartDataSourceResolveResult {
+    values: ReadonlyArray<ReadonlyArray<ChartDataSourceValue>>;
+}
+export interface IChartDataSourceProvider {
+    readonly kind: IResourceRefChartDataSourceReference['kind'];
+    getCacheKey(source: Readonly<IResourceRefChartDataSourceReference>): string;
+    resolve(source: Readonly<IResourceRefChartDataSourceReference>, options: {
+        signal: AbortSignal;
+    }): Promise<IChartDataSourceResolveResult>;
+}
+export interface IChartDataSourceRuntimeState {
+    status: ChartDataSourceRuntimeStatus;
+    values?: ReadonlyArray<ReadonlyArray<ChartDataSourceValue>>;
+    error?: unknown;
+}
+export interface IChartDataSourceHandle extends IDisposable {
+    readonly state$: Observable<IChartDataSourceRuntimeState>;
+    refresh(): Promise<void>;
+}
+export interface IChartDataSourceResolver {
+    registerProvider(provider: IChartDataSourceProvider): IDisposable;
+    acquire(source: Readonly<IResourceRefChartDataSourceReference>): IChartDataSourceHandle;
+}
+export declare const IChartDataSourceResolver: import("@wendellhu/redi").IdentifierDecorator<IChartDataSourceResolver>;
+export declare class ChartDataSourceResolver extends Disposable implements IChartDataSourceResolver {
+    private readonly _providers;
+    private readonly _entries;
+    private readonly _handles;
+    private _isDisposed;
+    registerProvider(provider: IChartDataSourceProvider): IDisposable;
+    acquire(source: Readonly<IResourceRefChartDataSourceReference>): IChartDataSourceHandle;
+    dispose(): void;
+    private _getOrCreateEntry;
+    private _attachHandle;
+    private _detachHandle;
+    private _releaseHandle;
+    private _refreshHandle;
+    private _startResolve;
+    private _resolveEntry;
+    private _isCurrentGeneration;
+    private _clearPending;
+    private _publishEntry;
+    private _invalidateProviderEntry;
+    private _cancelEntry;
+    private _snapshotState;
+    private _unavailableState;
+}

package/lib/types/models/chart-host/resource/chart-resource-repository.d.ts

@@ -0,0 +1,111 @@
+import type { Observable } from 'rxjs';
+import type { IChartDataAggregation } from '../../../chart-data-aggregation';
+import type { ChartTypeBits } from '../../../enum';
+import type { ChartStyle, IChartContext } from '../../../types';
+import type { ChartDataSourceValue } from './inline-chart-table';
+import type { IResourceRefChartDataSourceReference } from './resource-ref-chart-data-source.adapter';
+import { Disposable } from '@univerjs/core';
+export declare const CHART_RESOURCE_VERSION = 2;
+export interface IInlineChartDataSource<TCell extends ChartDataSourceValue = ChartDataSourceValue> {
+    id: string;
+    name?: string;
+    values: TCell[][];
+}
+export interface IReferencedChartDataSource {
+    id: string;
+    name?: string;
+    source: IResourceRefChartDataSourceReference;
+}
+export type IChartResourceDataSource = IInlineChartDataSource | IReferencedChartDataSource;
+export type IChartDataSourceInput = {
+    values: ChartDataSourceValue[][];
+    source?: never;
+} | {
+    source: IResourceRefChartDataSourceReference;
+    values?: never;
+};
+interface IChartDataSourceCandidate {
+    values?: ChartDataSourceValue[][];
+    source?: IResourceRefChartDataSourceReference;
+}
+export declare function isInlineChartDataSource<T extends IChartDataSourceCandidate>(dataSource: T | null | undefined): dataSource is T & {
+    values: ChartDataSourceValue[][];
+    source?: never;
+};
+export declare function isReferencedChartDataSource<T extends IChartDataSourceCandidate>(dataSource: T | null | undefined): dataSource is T & {
+    source: IResourceRefChartDataSourceReference;
+    values?: never;
+};
+export interface IChartResourceContext {
+    orient?: 'row' | 'column';
+    chartContext?: Partial<IChartContext>;
+}
+export interface IChartResourceState {
+    legendSelected?: Record<string, boolean>;
+    activePage?: number;
+    relationNodePositions?: Record<string, {
+        x: number;
+        y: number;
+    }>;
+}
+export interface IChartResourceSnapshot<TContext = IChartResourceContext, TState = IChartResourceState> {
+    id: string;
+    dataSourceId: string;
+    chartType: ChartTypeBits;
+    style?: ChartStyle;
+    context?: TContext;
+    state?: TState;
+    dataAggregation?: IChartDataAggregation;
+}
+export interface IChartResource<TDataSource extends IChartResourceDataSource = IChartResourceDataSource, TChart extends IChartResourceSnapshot<unknown, unknown> = IChartResourceSnapshot> {
+    version: typeof CHART_RESOURCE_VERSION;
+    dataSources: Record<string, TDataSource>;
+    charts: Record<string, TChart>;
+}
+export type ICreateChartDataSourceOptions<TDataSource extends IChartResourceDataSource = IChartResourceDataSource> = TDataSource extends IChartResourceDataSource ? Omit<TDataSource, 'id'> & {
+    id?: string;
+} : never;
+export type ICreateChartSnapshotOptions<TChart extends IChartResourceSnapshot<unknown, unknown>> = Omit<TChart, 'id'> & {
+    id?: string;
+};
+export type IUpdateChartSnapshotPatch<TChart extends IChartResourceSnapshot<unknown, unknown>> = Partial<Omit<TChart, 'id'>>;
+interface IChartDataSourceRemovedEvent {
+    unitId: string;
+    dataSourceId: string;
+}
+export declare class ChartResourceRepository<TDataSource extends IChartResourceDataSource = IChartResourceDataSource, TChart extends IChartResourceSnapshot<unknown, unknown> = IChartResourceSnapshot, TResource extends IChartResource<TDataSource, TChart> = IChartResource<TDataSource, TChart>> extends Disposable {
+    private readonly _resources;
+    private readonly _dataSourceRemoved$;
+    readonly dataSourceRemoved$: Observable<IChartDataSourceRemovedEvent>;
+    ensureUnitResource(unitId: string): TResource;
+    loadUnit(unitId: string, resource: unknown): TResource;
+    unloadUnit(unitId: string): void;
+    serializeUnit(unitId: string): string;
+    getResource(unitId: string): TResource;
+    getDataSource(unitId: string, dataSourceId: string): TDataSource | undefined;
+    getChart(unitId: string, chartId: string): TChart | undefined;
+    createDataSource(unitId: string, options: ICreateChartDataSourceOptions<TDataSource>): TDataSource;
+    setDataSource(unitId: string, dataSource: TDataSource): TDataSource;
+    updateDataSource(unitId: string, dataSourceId: string, values: ChartDataSourceValue[][], patch?: Partial<Pick<TDataSource, 'name'>>): TDataSource | undefined;
+    removeDataSource(unitId: string, dataSourceId: string): boolean;
+    createChart(unitId: string, options: ICreateChartSnapshotOptions<TChart>): TChart;
+    setChart(unitId: string, chart: TChart): TChart;
+    updateChart(unitId: string, chartId: string, patch: IUpdateChartSnapshotPatch<TChart>): TChart | undefined;
+    removeChart(unitId: string, chartId: string, options?: {
+        cleanupDataSource?: boolean;
+    }): TChart | undefined;
+    getChartIdsByDataSource(unitId: string, dataSourceId: string): string[];
+    getDataSourceSharingCount(unitId: string, dataSourceId: string): number;
+    isDataSourceShared(unitId: string, dataSourceId: string): boolean;
+    duplicateDataSourceForChart(unitId: string, chartId: string, duplicateDataSourceId?: string): TDataSource | undefined;
+    cleanupOrphanedResources(unitId: string): void;
+    dispose(): void;
+    private _decodeResource;
+    private _decodeDataSource;
+    private _cloneDataSource;
+    private _isResourceEnvelope;
+    private _isValues;
+    private _normalizeReference;
+    private _invalidDataSource;
+}
+export {};

package/lib/types/models/{chart-resource-serializer.d.ts → chart-host/resource/chart-resource-serializer.d.ts}

@@ -1,10 +1,11 @@
-import type { ChartStyle } from '../types';
+import type { ChartStyle } from '../../../types';
 interface IChartResourceSnapshot {
     style?: ChartStyle;
+    context?: unknown;
 }
 interface IChartResourceEnvelope<TChart extends IChartResourceSnapshot> {
     charts: Record<string, TChart>;
 }
-/** Serializes a host chart resource while omitting non-canonical empty chart palettes. */
+/** Serializes a host chart resource with authored-only persisted chart styles. */
 export declare function serializeChartResource<TChart extends IChartResourceSnapshot, TResource extends IChartResourceEnvelope<TChart>>(resource: TResource): string;
 export {};

package/lib/types/models/chart-host/resource/inline-chart-table.d.ts

@@ -0,0 +1,5 @@
+import type { CellValue } from '@univerjs/core';
+import type { IUniverDataSet } from '../../../types';
+export type ChartDataSourceValue = CellValue | null;
+export declare function parseInlineChartTable(text: string): ChartDataSourceValue[][];
+export declare function buildChartDataSetFromValues(values: readonly (readonly ChartDataSourceValue[])[]): IUniverDataSet;

package/lib/types/models/chart-host/resource/persisted-chart-style.d.ts

@@ -0,0 +1,3 @@
+import type { ChartStyle } from '../../../types';
+/** Projects authored style at the persistence boundary while accepting historical runtime fields. */
+export declare function projectPersistedChartStyle(style: ChartStyle | undefined): ChartStyle | undefined;

package/lib/types/models/chart-host/resource/resource-ref-chart-data-source.adapter.d.ts

@@ -0,0 +1,22 @@
+import type { IResourceRef } from '@univerjs-pro/embed';
+export declare const RESOURCE_REF_CHART_DATA_SOURCE_KIND = "resource-ref";
+export interface IResourceRefChartDataSourceReference {
+    readonly kind: typeof RESOURCE_REF_CHART_DATA_SOURCE_KIND;
+    readonly ref: IResourceRef;
+}
+export interface IResourceRefChartDataSourceInput extends Omit<IResourceRef, 'file'> {
+    readonly file?: IResourceRef['file'];
+}
+interface ICompatibleResourceRefChartDataSourceReference {
+    readonly kind: typeof RESOURCE_REF_CHART_DATA_SOURCE_KIND;
+    readonly ref: IResourceRefChartDataSourceInput;
+}
+export declare class ResourceRefChartDataSourceAdapter {
+    static toReference(ref: IResourceRefChartDataSourceInput): IResourceRefChartDataSourceReference;
+    static isReference(reference: unknown): reference is Readonly<IResourceRefChartDataSourceReference>;
+    static assertReference(reference: unknown): asserts reference is Readonly<ICompatibleResourceRefChartDataSourceReference>;
+    static fromReference(reference: Readonly<ICompatibleResourceRefChartDataSourceReference>): IResourceRef;
+    private static _normalizeInput;
+    private static _isCompatibleReference;
+}
+export {};

package/lib/types/models/chart-host/resource/resource-ref-chart-data-source.provider.d.ts

@@ -0,0 +1,12 @@
+import type { IChartDataSourceProvider, IChartDataSourceResolveResult } from './chart-data-source-resolver';
+import type { IResourceRefChartDataSourceReference } from './resource-ref-chart-data-source.adapter';
+import { Injector } from '@univerjs/core';
+export declare class ResourceRefChartDataSourceProvider implements IChartDataSourceProvider {
+    private readonly _injector;
+    readonly kind = "resource-ref";
+    constructor(_injector: Injector);
+    getCacheKey(source: IResourceRefChartDataSourceReference): string;
+    resolve(source: IResourceRefChartDataSourceReference, options: {
+        signal: AbortSignal;
+    }): Promise<IChartDataSourceResolveResult>;
+}

package/lib/types/models/chart-host/static/chart-model-store.d.ts

@@ -0,0 +1,56 @@
+import type { Injector } from '@univerjs/core';
+import type { Observable } from 'rxjs';
+import type { IChartContext, IUniverDataSet } from '../../../types';
+import type { ChartModel } from '../../chart-model/chart-model';
+import type { IChartDataSourceResolver, IChartDataSourceRuntimeState } from '../resource/chart-data-source-resolver';
+import type { ChartResourceRepository, IChartResource, IChartResourceContext, IChartResourceDataSource, IChartResourceSnapshot } from '../resource/chart-resource-repository';
+import type { ChartDataSourceValue } from '../resource/inline-chart-table';
+import type { IChartRuntime } from './chart-runtime';
+import { Disposable } from '@univerjs/core';
+export interface IChartModelRuntime extends IChartRuntime {
+    unitId: string;
+    chartId: string;
+    dataSourceId: string;
+}
+export declare class ChartModelStore<TDataSource extends IChartResourceDataSource, TChart extends IChartResourceSnapshot<IChartResourceContext, unknown>, TResource extends IChartResource<TDataSource, TChart>, TRuntime extends IChartModelRuntime = IChartModelRuntime> extends Disposable {
+    private readonly _resourceRepository;
+    private readonly _injector;
+    private readonly _buildDataSet;
+    private readonly _dataSourceResolver;
+    private readonly _activeRuntimeModel$;
+    readonly activeRuntimeModel$: Observable<TRuntime | null>;
+    get activeRuntimeModel(): TRuntime | null;
+    private readonly _activeChartModel$;
+    readonly activeChartModel$: Observable<ChartModel<import("../../..").IChartDataSource> | null>;
+    get activeChartModel(): ChartModel | null;
+    private readonly _runtimeModels;
+    private readonly _dataSourceBindings;
+    private readonly _chartModelAdded$;
+    readonly chartModelAdded$: Observable<TRuntime>;
+    private readonly _chartModelRemoved$;
+    readonly chartModelRemoved$: Observable<TRuntime>;
+    constructor(_resourceRepository: ChartResourceRepository<TDataSource, TChart, TResource>, _injector: Injector, _buildDataSet: (values: ReadonlyArray<ReadonlyArray<ChartDataSourceValue>>) => IUniverDataSet, _dataSourceResolver: IChartDataSourceResolver);
+    ensureChartModel(unitId: string, chartId: string): TRuntime | undefined;
+    getChartModel(unitId: string, chartId: string): TRuntime | undefined;
+    getDataSourceRuntimeState$(unitId: string, chartId: string): Observable<IChartDataSourceRuntimeState> | undefined;
+    getDataSourceRuntimeState(unitId: string, chartId: string): IChartDataSourceRuntimeState | undefined;
+    refreshChartDataSource(unitId: string, chartId: string): Promise<void>;
+    setActiveChartRuntime(runtime: TRuntime | null): void;
+    setActiveChartModel(chartModel: ChartModel | null): void;
+    setActiveChartById(unitId: string, chartId: string): TRuntime | null;
+    generateChartModelContext(unitId: string, chartId: string): IChartContext | undefined;
+    refreshChartModel(unitId: string, chartId: string): TRuntime | undefined;
+    refreshChartsByDataSource(unitId: string, dataSourceId: string): TRuntime[];
+    removeChartModel(unitId: string, chartId: string): boolean;
+    removeUnit(unitId: string): void;
+    dispose(): void;
+    protected _createStoredRuntime(runtime: IChartModelRuntime): TRuntime;
+    protected _beforeRuntimeRefresh(_runtime: TRuntime): void;
+    private _bindDataSource;
+    private _releaseBindingsByDataSource;
+    private _releaseHandle;
+    private _disposeBinding;
+    private _disposeUnitBindings;
+    private _disposeRuntime;
+    private _getOrCreateUnitMap;
+}