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

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/{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-resource-serializer.d.ts → chart-host/resource/chart-resource-serializer.d.ts}

@@ -1,4 +1,4 @@
-import type { ChartStyle } from '../types';
+import type { ChartStyle } from '../../../types';
 interface IChartResourceSnapshot {
     style?: ChartStyle;
 }

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

@@ -0,0 +1,4 @@
+import type { IUniverDataSet } from '../../../types';
+export type InlineChartCellValue = string | number | boolean | null;
+export declare function parseInlineChartTable(text: string): InlineChartCellValue[][];
+export declare function buildInlineChartTableDataSet(values: readonly (readonly InlineChartCellValue[])[]): IUniverDataSet;

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

@@ -0,0 +1,75 @@
+import type { ChartTypeBits } from '../../../enum';
+import type { IChartDataAggregation } from '../../../chart-data-aggregation';
+import type { ChartStyle, IChartContext } from '../../../types';
+import type { InlineChartCellValue } from './inline-chart-table';
+import { Disposable } from '@univerjs/core';
+export declare const STATIC_CHART_RESOURCE_VERSION = 1;
+export interface IStaticChartInlineDataSource<TCell extends InlineChartCellValue = InlineChartCellValue> {
+    id: string;
+    name?: string;
+    values: TCell[][];
+}
+export interface IStaticChartContext {
+    orient?: 'row' | 'column';
+    firstRowAsHeader?: boolean;
+    firstColumnAsCategory?: boolean;
+    chartContext?: Partial<IChartContext>;
+}
+export interface IStaticChartState {
+    legendSelected?: Record<string, boolean>;
+    activePage?: number;
+    relationNodePositions?: Record<string, {
+        x: number;
+        y: number;
+    }>;
+}
+export interface IStaticChartSnapshot<TContext = IStaticChartContext, TState = IStaticChartState> {
+    id: string;
+    dataSourceId: string;
+    chartType: ChartTypeBits;
+    style?: ChartStyle;
+    context?: TContext;
+    state?: TState;
+    dataAggregation?: IChartDataAggregation;
+}
+export interface IStaticChartResource<TDataSource extends IStaticChartInlineDataSource = IStaticChartInlineDataSource, TChart extends IStaticChartSnapshot<unknown, unknown> = IStaticChartSnapshot> {
+    version: typeof STATIC_CHART_RESOURCE_VERSION;
+    dataSources: Record<string, TDataSource>;
+    charts: Record<string, TChart>;
+}
+export interface ICreateStaticChartDataSourceOptions<TCell extends InlineChartCellValue> {
+    id?: string;
+    name?: string;
+    values: TCell[][];
+}
+export type ICreateStaticChartSnapshotOptions<TChart extends IStaticChartSnapshot<unknown, unknown>> = Omit<TChart, 'id'> & {
+    id?: string;
+};
+export type IUpdateStaticChartSnapshotPatch<TChart extends IStaticChartSnapshot<unknown, unknown>> = Partial<Omit<TChart, 'id'>>;
+export declare class StaticChartResourceRepository<TCell extends InlineChartCellValue, TDataSource extends IStaticChartInlineDataSource<TCell>, TChart extends IStaticChartSnapshot<unknown, unknown>, TResource extends IStaticChartResource<TDataSource, TChart>> extends Disposable {
+    private readonly _resources;
+    ensureUnitResource(unitId: string): TResource;
+    loadUnit(unitId: string, resource: TResource | string | null | undefined): 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: ICreateStaticChartDataSourceOptions<TCell>): TDataSource;
+    setDataSource(unitId: string, dataSource: TDataSource): TDataSource;
+    updateDataSource(unitId: string, dataSourceId: string, values: TCell[][], patch?: Partial<Pick<TDataSource, 'name'>>): TDataSource | undefined;
+    removeDataSource(unitId: string, dataSourceId: string): boolean;
+    createChart(unitId: string, options: ICreateStaticChartSnapshotOptions<TChart>): TChart;
+    setChart(unitId: string, chart: TChart): TChart;
+    updateChart(unitId: string, chartId: string, patch: IUpdateStaticChartSnapshotPatch<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;
+    duplicateDataSourceForChart(unitId: string, chartId: string, duplicateDataSourceId?: string): TDataSource | undefined;
+    cleanupOrphanedResources(unitId: string): void;
+    dispose(): void;
+    private _cloneValues;
+    private _deleteUndefinedFields;
+}

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

@@ -0,0 +1,43 @@
+import type { Injector } from '@univerjs/core';
+import type { IChartContext, IUniverDataSet } from '../../../types';
+import type { ChartModel } from '../../chart-model/chart-model';
+import type { InlineChartCellValue } from '../resource/inline-chart-table';
+import type { IStaticChartContext, IStaticChartInlineDataSource, IStaticChartResource, IStaticChartSnapshot, StaticChartResourceRepository } from '../resource/static-chart-resource-repository';
+import type { IStaticChartRuntime } from './static-chart-runtime';
+import { Disposable } from '@univerjs/core';
+export interface IStaticChartModelRuntime extends IStaticChartRuntime {
+    unitId: string;
+    chartId: string;
+    dataSourceId: string;
+}
+export declare class StaticChartModelStore<TCell extends InlineChartCellValue, TDataSource extends IStaticChartInlineDataSource<TCell>, TChart extends IStaticChartSnapshot<IStaticChartContext, unknown>, TResource extends IStaticChartResource<TDataSource, TChart>, TRuntime extends IStaticChartModelRuntime = IStaticChartModelRuntime> extends Disposable {
+    private readonly _resourceRepository;
+    private readonly _injector;
+    private readonly _buildDataSet;
+    private readonly _activeRuntimeModel$;
+    readonly activeRuntimeModel$: import("rxjs").Observable<TRuntime | null>;
+    get activeRuntimeModel(): TRuntime | null;
+    private readonly _activeChartModel$;
+    readonly activeChartModel$: import("rxjs").Observable<ChartModel<import("../../..").IChartDataSource> | null>;
+    get activeChartModel(): ChartModel | null;
+    private readonly _runtimeModels;
+    private readonly _chartModelAdded$;
+    readonly chartModelAdded$: import("rxjs").Observable<TRuntime>;
+    private readonly _chartModelRemoved$;
+    readonly chartModelRemoved$: import("rxjs").Observable<TRuntime>;
+    constructor(_resourceRepository: StaticChartResourceRepository<TCell, TDataSource, TChart, TResource>, _injector: Injector, _buildDataSet: (values: TCell[][]) => IUniverDataSet);
+    ensureChartModel(unitId: string, chartId: string): TRuntime | undefined;
+    getChartModel(unitId: string, chartId: string): TRuntime | undefined;
+    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: IStaticChartModelRuntime): TRuntime;
+    protected _beforeRuntimeRefresh(_runtime: TRuntime): void;
+    private _disposeRuntime;
+}

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

@@ -0,0 +1,26 @@
+import type { Injector } from '@univerjs/core';
+import type { IChartDataAggregation } from '../../../chart-data-aggregation';
+import type { ChartTypeBits } from '../../../enum';
+import type { ChartStyle, IChartContext, IUniverDataSet } from '../../../types';
+import { StaticChartSource } from '../../../source/static-chart-source';
+import { ChartModel } from '../../chart-model/chart-model';
+export interface IStaticChartRuntime {
+    model: ChartModel;
+    source: StaticChartSource;
+}
+export interface IStaticChartRuntimeConfig {
+    chartType: ChartTypeBits;
+    dataSet: IUniverDataSet;
+    isRowDirection: boolean;
+    style?: ChartStyle;
+    context?: Partial<IChartContext>;
+    dataAggregation?: IChartDataAggregation;
+}
+export interface ICreateStaticChartRuntimeOptions extends IStaticChartRuntimeConfig {
+    id: string;
+    injector: Injector;
+}
+/** Creates the canonical runtime pair used by hosts backed by an inline table. */
+export declare function createStaticChartRuntime(options: ICreateStaticChartRuntimeOptions): IStaticChartRuntime;
+/** Applies a persisted inline-table snapshot without duplicating chart semantics in each host. */
+export declare function refreshStaticChartRuntime(runtime: IStaticChartRuntime, config: IStaticChartRuntimeConfig): void;