@univerjs-pro/engine-chart 1.0.0-alpha.2 → 1.0.0-alpha.4

package/lib/types/models/chart-data-operators/build-chart-data.d.ts

@@ -1,4 +1,9 @@
 import type { IChartContext, IChartData, IUniverDataSet } from '../../types';
 import type { IChartLocaleTexts } from '../chart-locale-texts';
 import { ChartTypeBits } from '../../enum';
-export declare function buildChartData(dataSource: IUniverDataSet, chartContext: IChartContext, chartType: ChartTypeBits, isRowDirection: boolean, localeTexts: IChartLocaleTexts): IChartData;
+export declare enum RelationColumnIndex {
+    Source = 0,
+    Target = 1,
+    Weight = 2
+}
+export declare function buildChartData(dataSource: IUniverDataSet, chartContext: IChartContext, chartType: ChartTypeBits, _isRowDirection: boolean, localeTexts: IChartLocaleTexts): IChartData;

package/lib/types/models/chart-data-operators/cartesian-point-data.d.ts

@@ -0,0 +1,43 @@
+import type { IUniverDataSet } from '../../types';
+import type { IChartLocaleTexts } from '../chart-locale-texts';
+export declare enum CartesianPointRoleIndex {
+    X = 0,
+    Y = 1,
+    Size = 2
+}
+export declare enum CartesianPointValueIndex {
+    X = 0,
+    Y = 1,
+    Size = 2,
+    Label = 3
+}
+export interface ICartesianPointRecord {
+    sourceIndex: number;
+    x: number;
+    y: number;
+    label?: string;
+    size?: number;
+    group?: string;
+}
+export interface ICartesianPointData {
+    isValid: boolean;
+    xIndex: number;
+    yIndex: number;
+    xName: string;
+    yName: string;
+    labelName?: string;
+    sizeName?: string;
+    groupName?: string;
+    records: ICartesianPointRecord[];
+}
+interface ICartesianPointRoleIndexes {
+    xIndex: number;
+    yIndex: number;
+    labelIndex?: number;
+    sizeIndex?: number;
+    seriesIndex?: number;
+    headers?: string[];
+}
+/** Builds normalized Cartesian point records consumed by coordinate-chart converters. */
+export declare function buildCartesianPointData(dataSource: IUniverDataSet, roles: ICartesianPointRoleIndexes, localeTexts: IChartLocaleTexts): ICartesianPointData;
+export {};

package/lib/types/models/chart-data-operators/operators.d.ts

@@ -1,8 +1,7 @@
-import type { ChartDataSource } from '../../source/chart-source';
-import type { IChartContext, OptionDataValue } from '../../types';
+import type { IChartContext, IChartDataSource, OptionDataValue } from '../../types';
 import type { ChartModel } from '../chart-model';
 import { ChartSourceDataTypeEnum } from '../../enum';
-export type IChartContextOperator = (dataSource: ChartDataSource, context: IChartContext, model: ChartModel) => IChartContext;
+export type IChartContextOperator = (dataSource: IChartDataSource, context: IChartContext, model: ChartModel) => IChartContext;
 type Nil = null | undefined;
 export declare function isNil(value: any): value is Nil;
 export declare function countTypesFromArray(arrayData: Array<OptionDataValue | undefined>, sourceTypes?: Array<ChartSourceDataTypeEnum | undefined>): {
@@ -11,10 +10,11 @@ export declare function countTypesFromArray(arrayData: Array<OptionDataValue | u
     total: number;
 };
 export declare function toColumnOrient<T = any>(dataSource: T[][]): T[][];
-export declare function findCategoryIndexes(dataSource: ChartDataSource): number[];
-export declare const inferChartContextOperator: IChartContextOperator;
+export declare function findCategoryIndexes(dataSource: IChartDataSource): number[];
+export declare const findHeaderOperator: IChartContextOperator;
+export declare const findCategoryOperator: IChartContextOperator;
 export declare const findSeriesOperator: IChartContextOperator;
 export declare const pieSeriesFilterOperator: IChartContextOperator;
 export declare const defaultChartContextOperators: IChartContextOperator[];
-export declare function generateChartModelContextByOperators(chartModel: ChartModel, dataSource: ChartDataSource, operators?: IChartContextOperator[]): IChartContext;
+export declare function generateChartModelContextByOperators(chartModel: ChartModel, dataSource: IChartDataSource, operators?: IChartContextOperator[]): IChartContext;
 export {};

package/lib/types/models/chart-element-axis-id.d.ts

@@ -0,0 +1,9 @@
+import type { ChartDirection, IChartElementHit, IRuntimeAxis } from '../types';
+export declare const CHART_ELEMENT_AXIS_ID_META = "__univerChartElementAxisId";
+export type ChartElementAxisId = NonNullable<IChartElementHit['axisId']>;
+type ChartElementAxisTarget = 'title' | 'label' | 'line';
+export declare function getChartElementAxisId(axisOption: unknown): ChartElementAxisId | undefined;
+export declare function setChartElementAxisId(axisOption: Record<string, unknown>, axisId: ChartElementAxisId): void;
+export declare function resolveChartElementAxisId(axisPosition: IChartElementHit['axisPosition'] | undefined, direction: ChartDirection | undefined, runtimeAxes: IRuntimeAxis[] | undefined): ChartElementAxisId;
+export declare function getChartElementAxisKind(axisId: ChartElementAxisId, target: ChartElementAxisTarget): IChartElementHit['kind'];
+export {};

package/lib/types/models/chart-element-edit-overlay/chart-element-edit-overlay.d.ts

@@ -0,0 +1,38 @@
+import type { IChartElementBounds, IChartElementHit } from '../../types';
+import type { ChartElementEditBorderType, IChartElementEditOverlayPalette } from './types';
+export declare class ChartElementEditOverlay {
+    private readonly _getInstance;
+    private readonly _getContainer;
+    private readonly _paletteOverride?;
+    private _group;
+    private _hoverBorder;
+    private _hoverHit;
+    private _hoverBorderBounds;
+    private _hoverBorderHitKey;
+    private _fixedBorder;
+    private _fixedBorderBounds;
+    constructor(_getInstance: () => echarts.ECharts | null, _getContainer?: () => HTMLElement | null | undefined, _paletteOverride?: Partial<IChartElementEditOverlayPalette> | undefined);
+    ensure(): any;
+    remove(): void;
+    clearAll(): void;
+    clearHover(): void;
+    clearFixed(): void;
+    isFixed(bounds: IChartElementBounds | undefined): boolean;
+    containsHoverPoint(point: {
+        x: number;
+        y: number;
+    }): boolean;
+    getHoverHitAt(point: {
+        x: number;
+        y: number;
+    }): IChartElementHit | null;
+    setBorder(type: ChartElementEditBorderType, hit: IChartElementHit): void;
+    withHidden<T>(callback: () => T): T;
+    private _removeBorder;
+    private _createEditBorderElement;
+    private _createLineBorderElement;
+    private _createPolygonBorderElement;
+    private _createStrokeStyle;
+    private _resolvePalette;
+    private _refresh;
+}

package/lib/types/models/chart-element-edit-overlay/index.d.ts

@@ -0,0 +1,4 @@
+export { ChartElementEditOverlay } from './chart-element-edit-overlay';
+export { resolveChartElementEditOverlayPalette } from './palette';
+export { createRectOverlay, getChartElementComponentInfo, getChartElementPropertyInChain, getChartElementTarget, getChartElementTargetSeriesIndex, isSeriesLabelTarget, resolveChartElementHitLayout, toChartElementFiniteNumber, } from './resolve-chart-element-hit-layout';
+export type { ChartElementEditBorderType, IChartElementEditOverlayPalette, IChartElementHitLayout, IResolvedChartElementOverlay, } from './types';

package/lib/types/models/chart-element-edit-overlay/palette.d.ts

@@ -0,0 +1,2 @@
+import type { IChartElementEditOverlayPalette } from './types';
+export declare function resolveChartElementEditOverlayPalette(container?: HTMLElement | null): IChartElementEditOverlayPalette;

package/lib/types/models/chart-element-edit-overlay/resolve-chart-element-hit-layout.d.ts

@@ -0,0 +1,16 @@
+import type { IChartElementBounds, IChartElementHit } from '../../types';
+import type { ECharts } from '../../utils/echarts';
+import type { IChartElementHitLayout, IResolvedChartElementOverlay } from './types';
+export declare function toChartElementFiniteNumber(value: unknown): number | undefined;
+export declare function getChartElementTarget(params: any): any;
+export declare function getChartElementComponentInfo(element: any): {
+    mainType?: string;
+    index?: number;
+} | undefined;
+export declare function getChartElementPropertyInChain(element: any, propertyName: string): unknown;
+export declare function isSeriesLabelTarget(element: any): boolean;
+export declare function getChartElementTargetSeriesIndex(instance: any, target: any): number | undefined;
+export declare function getAxisComponentMainType(hit: IChartElementHit): 'xAxis' | 'yAxis' | undefined;
+export declare function createRectOverlay(bounds: IChartElementBounds, padding?: number, shape?: Record<string, any>): IResolvedChartElementOverlay;
+export declare function isSameBounds(left: IChartElementBounds | null | undefined, right: IChartElementBounds | undefined): boolean;
+export declare function resolveChartElementHitLayout(hit: IChartElementHit, params: any, instance?: ECharts | null): IChartElementHitLayout;

package/lib/types/models/chart-element-edit-overlay/types.d.ts

@@ -0,0 +1,20 @@
+import type { IChartElementBounds, IChartElementOverlay } from '../../types';
+export type ChartElementEditBorderType = 'hover' | 'fixed';
+export interface IChartElementEditOverlayPalette {
+    hoverStroke: string;
+    fixedStroke: string;
+}
+export interface IChartElementOverlaySourceStyle {
+    stroke?: string;
+    lineWidth?: number;
+    opacity?: number;
+}
+export interface IResolvedChartElementOverlay extends IChartElementOverlay {
+    items?: IResolvedChartElementOverlay[];
+    sourceCtor?: new (options: any) => any;
+    sourceStyle?: IChartElementOverlaySourceStyle;
+}
+export interface IChartElementHitLayout {
+    bounds?: IChartElementBounds;
+    overlay?: IResolvedChartElementOverlay;
+}

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

@@ -0,0 +1,40 @@
+import type { ChartImageSource, ChartStyle, IChartHostBorderStyle, IChartHostRect, IChartHostStyle } from '../types';
+export interface IResolveChartHostFrameStyleInput {
+    style?: ChartStyle | null;
+    getRenderColor?: (color: string) => string;
+    fallbackStroke?: string | null;
+    defaultStrokeWidth?: number;
+    defaultRadius?: number;
+    enableFallbackStroke?: boolean;
+}
+/**
+ * Shared visual defaults for chart containers across Sheet, Doc, Slide, and Board.
+ * Consumers should still prefer a chart's explicit border color.
+ */
+export declare const CHART_HOST_DEFAULT_BORDER_COLOR = "#D1D5DB";
+export declare const CHART_HOST_DEFAULT_BORDER_RADIUS = 8;
+export declare const CHART_HOST_DEFAULT_BORDER_WIDTH = 1;
+export interface IResolveDefaultChartHostFrameStyleInput {
+    style?: ChartStyle | null;
+    getRenderColor?: (color: string) => string;
+    fallbackStroke?: string | null;
+}
+interface IChartHostContentRect extends IChartHostRect {
+    left: number;
+    top: number;
+}
+export declare function resolveChartHostFrameStyle(input: IResolveChartHostFrameStyleInput): IChartHostStyle;
+/**
+ * Resolves the standard chart frame used when an author has not chosen a custom border.
+ * `getRenderColor` keeps the fallback frame in sync with the active light or dark theme.
+ */
+export declare function resolveDefaultChartHostFrameStyle(input: IResolveDefaultChartHostFrameStyleInput): IChartHostStyle;
+export declare function getChartHostFrameContentRect(outer: IChartHostRect, hostStyle: IChartHostStyle): IChartHostContentRect;
+export declare function shouldComposeChartHostFrame(hostStyle: IChartHostStyle): boolean;
+export declare function composeChartHostFrameImage(image: ChartImageSource, outer: IChartHostRect, hostStyle: IChartHostStyle): ChartImageSource;
+/**
+ * Resolves the canonical border consumed by every chart host frame renderer.
+ * Missing or empty colors and non-positive or non-finite widths disable the border.
+ */
+export declare function resolveChartHostFrameBorder(hostStyle: IChartHostStyle): Required<IChartHostBorderStyle> | undefined;
+export {};