@odoo/o-spreadsheet 19.2.11 → 19.3.2

package/dist/types/stores/client_focus_store.d.ts

@@ -0,0 +1,15 @@
+import { Get } from "../store_engine";
+import { ClientId } from "../types";
+import { SpreadsheetStore } from "./spreadsheet_store";
+export declare class ClientFocusStore extends SpreadsheetStore {
+    mutators: readonly ["focusClient", "unfocusClient", "showClientTag", "hideClientTag", "jumpToClient"];
+    private _showClientTag;
+    private clientFocusTimeout;
+    constructor(get: Get);
+    get focusedClients(): Set<ClientId>;
+    jumpToClient(clientId: ClientId): void;
+    showClientTag(): void;
+    hideClientTag(): void;
+    focusClient(clientId: ClientId): void;
+    unfocusClient(clientId: ClientId): void;
+}

package/dist/types/stores/formula_fingerprints_store.d.ts

@@ -0,0 +1,20 @@
+import { PositionMap } from "../helpers/cells/position_map";
+import { Color, Command } from "../types/index";
+import { SpreadsheetStore } from "./spreadsheet_store";
+export declare class FormulaFingerprintStore extends SpreadsheetStore {
+    mutators: readonly ["enable", "disable"];
+    private isInvalidated;
+    private fingerprintColors;
+    isEnabled: boolean;
+    colors: PositionMap<Color>;
+    handle(cmd: Command): void;
+    finalize(): void;
+    enable(): void;
+    disable(): void;
+    private computeFingerprints;
+    private colorSpreadZone;
+    private assignColors;
+    private computeFingerprint;
+    private computeFormulaFingerprint;
+    private getLiteralFingerprint;
+}

package/dist/types/stores/grid_renderer_store.d.ts

@@ -0,0 +1,41 @@
+import { DisposableStore, Get, Store } from "../store_engine";
+import { Command, GridRenderingContext, LayerName, RenderingGetters } from "../types/index";
+import { RendererStore } from "./renderer_store";
+export declare const CELL_BACKGROUND_GRIDLINE_STROKE_STYLE = "#111";
+export declare const CELL_ANIMATION_DURATION = 200;
+export declare class GridRenderer extends DisposableStore {
+    private renderer;
+    private fingerprints;
+    private hoveredTables;
+    private hoveredIcon;
+    private lastRenderSheetId;
+    private lastRenderBoxes;
+    private preventNewAnimationsInNextFrame;
+    private zonesWithPreventedAnimationsInNextFrame;
+    private animations;
+    protected getters: RenderingGetters;
+    constructor(get: Get, renderer?: Store<RendererStore>);
+    handle(cmd: Command): void;
+    finalize(): void;
+    get renderingLayers(): readonly ["Background", "Headers"];
+    drawLayer(renderingContext: GridRenderingContext, layer: LayerName, timeStamp: number | undefined): void;
+    private drawGlobalBackground;
+    private drawBackground;
+    private drawCellBackground;
+    private drawOverflowingCellBackground;
+    private drawBorders;
+    private drawTexts;
+    private drawIcon;
+    private drawHeaders;
+    private drawFrozenPanesHeaders;
+    private drawFrozenPanes;
+    private findNextEmptyCol;
+    private findPreviousEmptyCol;
+    private computeCellAlignment;
+    private createZoneBox;
+    private getGridBoxes;
+    private getBoxesWithAnimations;
+    private updateBoxesWithAnimations;
+    private updateAnimationsProgress;
+    private addNewAnimations;
+}

package/dist/types/stores/highlight_store.d.ts

@@ -0,0 +1,16 @@
+import { Get } from "../store_engine";
+import { GridRenderingContext, Highlight, LayerName } from "../types";
+import { SpreadsheetStore } from "./spreadsheet_store";
+export interface HighlightProvider {
+    highlights: Highlight[];
+}
+export declare class HighlightStore extends SpreadsheetStore {
+    mutators: readonly ["register", "unRegister"];
+    private providers;
+    constructor(get: Get);
+    get renderingLayers(): readonly ["Highlights"];
+    get highlights(): Highlight[];
+    register(highlightProvider: HighlightProvider): void;
+    unRegister(highlightProvider: HighlightProvider): void;
+    drawLayer(ctx: GridRenderingContext, layer: LayerName): void;
+}

package/dist/types/stores/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./model_store";
+export * from "./spreadsheet_store";

package/dist/types/stores/model_store.d.ts

@@ -0,0 +1,2 @@
+import { Model } from "../model";
+export declare const ModelStore: import("..").StoreConstructor<Model, any[]>;

package/dist/types/stores/notification_store.d.ts

@@ -0,0 +1,8 @@
+import { NotificationStoreMethods } from "../types/stores/notification_store_methods";
+export declare class NotificationStore {
+    mutators: readonly ["notifyUser", "raiseError", "askConfirmation", "updateNotificationCallbacks"];
+    notifyUser: NotificationStoreMethods["notifyUser"];
+    askConfirmation: NotificationStoreMethods["askConfirmation"];
+    raiseError: NotificationStoreMethods["raiseError"];
+    updateNotificationCallbacks(methods: Partial<NotificationStoreMethods>): void;
+}

package/dist/types/stores/renderer_store.d.ts

@@ -0,0 +1,23 @@
+import { Get } from "../store_engine";
+import { GridRenderingContext, LayerName } from "../types/rendering";
+export interface Renderer {
+    drawLayer(ctx: GridRenderingContext, layer: LayerName, timestamp: number | undefined): void;
+    renderingLayers: Readonly<LayerName[]>;
+}
+export declare class RendererStore {
+    private layers;
+    mutators: readonly ["register", "unRegister", "draw", "startAnimation", "stopAnimation"];
+    private renderers;
+    private model;
+    private context;
+    private animationFrameId;
+    private registeredAnimations;
+    constructor(get: Get, layers?: ("Background" | "Highlights" | "Clipboard" | "Chart" | "Autofill" | "Selection" | "Headers")[]);
+    register(renderer: Renderer): void;
+    unRegister(renderer: Renderer): void;
+    private drawLayer;
+    draw(context?: GridRenderingContext, timestamp?: number): string;
+    startAnimation(animationId: string): string;
+    stopAnimation(animationId: string): string;
+    dispose(): void;
+}

package/dist/types/stores/screen_width_store.d.ts

@@ -0,0 +1,6 @@
+export declare class ScreenWidthStore {
+    mutators: readonly ["setSmallThreshhold"];
+    private _isSmallCallback;
+    get isSmall(): boolean;
+    setSmallThreshhold(isSmall: () => boolean): void;
+}

package/dist/types/stores/spreadsheet_store.d.ts

@@ -0,0 +1,14 @@
+import { Model } from "../model";
+import { DisposableStore, Get } from "../store_engine";
+import { Command, GridRenderingContext, LayerName } from "../types";
+import { RendererStore } from "./renderer_store";
+export declare class SpreadsheetStore extends DisposableStore {
+    protected model: Model;
+    protected getters: import("..").Getters;
+    protected renderer: import("../store_engine").CQS<Pick<RendererStore, "register" | "unRegister" | "draw" | "startAnimation" | "stopAnimation"> & import("../store_engine").OmitFunctions<RendererStore>>;
+    constructor(get: Get);
+    get renderingLayers(): Readonly<LayerName[]>;
+    protected handle(cmd: Command): void;
+    protected finalize(): void;
+    drawLayer(ctx: GridRenderingContext, layer: LayerName, timestamp: number | undefined): void;
+}

package/dist/types/translation.d.ts

@@ -0,0 +1,21 @@
+type SprintfValues = (string | String | number)[] | [{
+    [key: string]: string | number;
+}];
+export type TranslationFunction = (string: string, ...values: SprintfValues) => string;
+/***
+ * Allow to inject a translation function from outside o-spreadsheet. This should be called before instantiating
+ * a model.
+ * @param tfn the function that will do the translation
+ * @param loaded a function that returns true when the translation is loaded
+ */
+export declare function setTranslationMethod(tfn: TranslationFunction, loaded?: () => boolean): void;
+/**
+ * If no translation function has been set, this will mark the translation are loaded.
+ *
+ * By default, the translations should not be set as loaded, otherwise top-level translated constants will never be
+ * translated. But if by the time the model is instantiated no custom translation function has been set, we can set
+ * the default translation function as loaded so o-spreadsheet can be run in standalone with no translations.
+ */
+export declare function setDefaultTranslationMethod(): void;
+export declare const _t: TranslationFunction;
+export {};

package/dist/types/types/autofill.d.ts

@@ -0,0 +1,71 @@
+/**
+ * An AutofillModifier describe the possible operations to apply to the
+ * content of a cell when we autofill this cell.
+ *
+ * It could be:
+ *  - Increment: increment the content by a given step
+ *  - Copy: simply copy the content
+ *  - Formula: update the formula, with the same behavior than paste
+ */
+import { Cell } from "./cells";
+import { Getters } from "./getters";
+import { Border, DIRECTION, UID, UpdateCellData } from "./misc";
+export interface IncrementModifier {
+    type: "INCREMENT_MODIFIER";
+    increment: number;
+    current: number;
+}
+export interface AlphanumericIncrementModifier {
+    type: "ALPHANUMERIC_INCREMENT_MODIFIER";
+    increment: number;
+    current: number;
+    prefix: string;
+    numberPostfixLength: number;
+}
+export interface DateIncrementModifier {
+    type: "DATE_INCREMENT_MODIFIER";
+    current: number;
+    increment: {
+        years: number;
+        months: number;
+        days: number;
+    };
+}
+export interface CopyModifier {
+    type: "COPY_MODIFIER";
+}
+export interface FormulaModifier {
+    type: "FORMULA_MODIFIER";
+    increment: number;
+    current: number;
+}
+export type AutofillModifier = IncrementModifier | AlphanumericIncrementModifier | CopyModifier | FormulaModifier | DateIncrementModifier;
+export interface Tooltip {
+    props: any;
+    component?: any;
+}
+export interface AutofillCellData extends UpdateCellData {
+    border?: Border;
+}
+export interface AutofillData {
+    cell?: Cell;
+    col: number;
+    row: number;
+    sheetId: UID;
+    border?: Border;
+}
+export interface AutofillResult {
+    cellData: AutofillCellData;
+    tooltip?: Tooltip;
+    origin: {
+        col: number;
+        row: number;
+    };
+}
+export interface GeneratorCell {
+    data: AutofillData;
+    rule: AutofillModifier;
+}
+export interface AutofillModifierImplementation {
+    apply: (rule: AutofillModifier, data: AutofillData, getters: Getters, direction: DIRECTION) => Omit<AutofillResult, "origin">;
+}

package/dist/types/types/canvas.d.ts

@@ -0,0 +1,2 @@
+export type CanvasSurface = HTMLCanvasElement | OffscreenCanvas;
+export type Canvas2DContext = CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D;

package/dist/types/types/cell_popovers.d.ts

@@ -0,0 +1,51 @@
+import { ComponentConstructor } from "@odoo/owl";
+import { Getters } from "./index";
+import { CellPosition } from "./misc";
+import { PropsOf } from "./props_of";
+import { Rect } from "./rendering";
+export type CellPopoverType = "ErrorToolTip" | "LinkDisplay" | "FilterMenu" | "LinkEditor";
+export type PopoverPropsPosition = "top-right" | "bottom-left";
+type MaxSizedComponentConstructor = ComponentConstructor & {
+    maxSize?: {
+        maxWidth?: number;
+        maxHeight?: number;
+    };
+};
+/**
+ * If the cell at the given position have an associated component (linkDisplay, errorTooltip, ...),
+ * returns the parameters to display the component
+ */
+type CellPopoverBuilder = (position: CellPosition, getters: Getters) => CellPopoverComponent<MaxSizedComponentConstructor>;
+export interface PopoverBuilders {
+    onOpen?: CellPopoverBuilder;
+    onHover?: CellPopoverBuilder;
+}
+export interface ClosedCellPopover {
+    isOpen: false;
+}
+export interface OpenCellPopover {
+    isOpen: true;
+    type: CellPopoverType;
+    col: number;
+    row: number;
+}
+/**
+ * Description of a cell component.
+ * i.e. which component class, which props and where to
+ * display it relative to the cell
+ */
+type OpenCellPopoverComponent<C extends ComponentConstructor> = {
+    isOpen: true;
+    Component: C;
+    props: PropsOf<C>;
+    cellCorner: PopoverPropsPosition;
+};
+export type CellPopoverComponent<C extends MaxSizedComponentConstructor = MaxSizedComponentConstructor> = ClosedCellPopover | OpenCellPopoverComponent<C>;
+export type PositionedCellPopoverComponent<C extends MaxSizedComponentConstructor = MaxSizedComponentConstructor> = {
+    isOpen: true;
+    Component: C;
+    props: PropsOf<C>;
+    anchorRect: Rect;
+    cellCorner: PopoverPropsPosition;
+};
+export {};

package/dist/types/types/cells.d.ts

@@ -0,0 +1,66 @@
+import { CompiledFormula } from "../formulas/compiler";
+import { Format, FormattedValue } from "./format";
+import { CellPosition, FunctionResultObject, Link, Style } from "./misc";
+interface CellAttributes {
+    readonly id: number;
+    readonly style?: Style;
+    readonly format?: Format;
+}
+export interface LiteralCell extends CellAttributes {
+    /**
+     * Raw cell content
+     */
+    readonly content: string;
+    readonly isFormula: false;
+    readonly parsedValue: CellValue;
+}
+export interface FormulaCell extends CellAttributes {
+    readonly isFormula: true;
+    readonly compiledFormula: CompiledFormula;
+}
+export type Cell = LiteralCell | FormulaCell;
+interface EvaluatedCellProperties extends FunctionResultObject {
+    readonly format?: Format;
+    /**
+     * Cell value formatted based on the format
+     */
+    readonly formattedValue: FormattedValue;
+    readonly defaultAlign: "right" | "center" | "left";
+    /**
+     * Can the cell appear in an automatic sum zone.
+     */
+    readonly isAutoSummable: boolean;
+    readonly link?: Link;
+    readonly position?: CellPosition;
+}
+export type CellValue = string | number | boolean | null;
+export type EvaluatedCell = NumberCell | TextCell | BooleanCell | EmptyCell | ErrorCell;
+export interface NumberCell extends EvaluatedCellProperties {
+    readonly type: CellValueType.number;
+    readonly value: number;
+}
+export interface TextCell extends EvaluatedCellProperties {
+    readonly type: CellValueType.text;
+    readonly value: string;
+}
+export interface BooleanCell extends EvaluatedCellProperties {
+    readonly type: CellValueType.boolean;
+    readonly value: boolean;
+}
+export interface EmptyCell extends EvaluatedCellProperties {
+    readonly type: CellValueType.empty;
+    readonly value: null;
+}
+export interface ErrorCell extends EvaluatedCellProperties {
+    readonly type: CellValueType.error;
+    readonly value: string;
+    readonly message?: string;
+}
+export declare enum CellValueType {
+    boolean = "boolean",
+    number = "number",
+    text = "text",
+    empty = "empty",
+    error = "error"
+}
+export {};

package/dist/types/types/chart/bar_chart.d.ts

@@ -0,0 +1,17 @@
+import { ChartConfiguration } from "chart.js";
+import { Range } from "../range";
+import { CommonChartDefinition } from "./index";
+export interface BarChartDefinition<T extends string | Range = Range> extends CommonChartDefinition<T> {
+    readonly type: "bar";
+    readonly stacked: boolean;
+    readonly horizontal?: boolean;
+    readonly zoomable?: boolean;
+}
+export type BarChartRuntime = {
+    chartJsConfig: ChartConfiguration<"bar" | "line">;
+    masterChartConfig?: ChartConfiguration<"bar">;
+    customizableSeries: {
+        dataSetId: string;
+        label: string;
+    }[];
+};

package/dist/types/types/chart/calendar_chart.d.ts

@@ -0,0 +1,16 @@
+import { ChartConfiguration } from "chart.js";
+import { Color } from "../misc";
+import { Range } from "../range";
+import { ChartColorScale, CommonChartDefinition } from "./index";
+export declare const CALENDAR_CHART_GRANULARITIES: ("year" | "second_number" | "minute_number" | "hour_number" | "day_of_week" | "day_of_month" | "iso_week_number" | "month_number" | "quarter_number")[];
+export type CalendarChartGranularity = (typeof CALENDAR_CHART_GRANULARITIES)[number];
+export interface CalendarChartDefinition<T extends string | Range = Range> extends CommonChartDefinition<T> {
+    readonly type: "calendar";
+    readonly horizontalGroupBy: CalendarChartGranularity;
+    readonly verticalGroupBy: CalendarChartGranularity;
+    readonly colorScale?: ChartColorScale;
+    readonly missingValueColor?: Color;
+}
+export type CalendarChartRuntime = {
+    chartJsConfig: ChartConfiguration;
+};

package/dist/types/types/chart/chart.d.ts

@@ -0,0 +1,222 @@
+import { Point } from "chart.js";
+import { XlsxHexColor } from "../xlsx";
+import { BarChartDefinition, BarChartRuntime } from "./bar_chart";
+import { CalendarChartDefinition } from "./calendar_chart";
+import { ComboChartDefinition, ComboChartRuntime } from "./combo_chart";
+import { LegendPosition } from "./common_chart";
+import { FunnelChartColors, FunnelChartDefinition, FunnelChartRuntime } from "./funnel_chart";
+import { GaugeChartDefinition, GaugeChartRuntime } from "./gauge_chart";
+import { GeoChartDefinition, GeoChartRuntime } from "./geo_chart";
+import { LineChartDefinition, LineChartRuntime } from "./line_chart";
+import { PieChartDefinition, PieChartRuntime } from "./pie_chart";
+import { PyramidChartDefinition, PyramidChartRuntime } from "./pyramid_chart";
+import { RadarChartDefinition, RadarChartRuntime } from "./radar_chart";
+import { ScatterChartDefinition, ScatterChartRuntime } from "./scatter_chart";
+import { ScorecardChartDefinition, ScorecardChartRuntime } from "./scorecard_chart";
+import { SunburstChartDefinition, SunburstChartRuntime } from "./sunburst_chart";
+import { TreeMapChartDefinition, TreeMapChartRuntime, TreeMapColoringOptions } from "./tree_map_chart";
+import { WaterfallChartDefinition, WaterfallChartRuntime } from "./waterfall_chart";
+import { Format } from "../format";
+import { Locale } from "../locale";
+import { Align, Color, FunctionResultObject, UID, VerticalAlign } from "../misc";
+import { Range } from "../range";
+export declare const CHART_TYPES: readonly ["line", "bar", "pie", "scorecard", "gauge", "scatter", "combo", "waterfall", "pyramid", "radar", "geo", "funnel", "sunburst", "treemap", "calendar"];
+export type ChartType = (typeof CHART_TYPES)[number];
+export type ChartDefinitionWithDataSource<T extends string | Range = Range> = LineChartDefinition<T> | PieChartDefinition<T> | BarChartDefinition<T> | ScatterChartDefinition<T> | ComboChartDefinition<T> | WaterfallChartDefinition<T> | PyramidChartDefinition<T> | RadarChartDefinition<T> | GeoChartDefinition<T> | FunnelChartDefinition<T> | SunburstChartDefinition<T> | TreeMapChartDefinition<T> | CalendarChartDefinition<T>;
+export type ChartDefinition<T extends string | Range = string> = ChartDefinitionWithDataSource<T> | ScorecardChartDefinition<T> | GaugeChartDefinition<T>;
+/**
+ * `ChartTypeDefinition<"bar", Range>`
+ * `ChartTypeDefinition<"bar", string>`
+ * `ChartTypeDefinition<"pie", Range>`
+ *  ... for each chart type and for Range or string data source.
+ */
+export type ChartTypeDefinition<T extends ChartType, R extends string | Range> = Extract<ChartDefinition<R>, {
+    type: T;
+}>;
+export type ChartWithColorScaleDefinition = Extract<ChartDefinition, {
+    colorScale?: ChartColorScale;
+}>;
+export type ChartWithTitleDefinition = Extract<ChartDefinition, {
+    title?: TitleDesign;
+}>;
+export type ChartWithAxisDefinition = Extract<ChartDefinition<Range>, {
+    axesDesign?: AxesDesign;
+}>;
+export type ChartJSRuntime = LineChartRuntime | PieChartRuntime | BarChartRuntime | ComboChartRuntime | ScatterChartRuntime | WaterfallChartRuntime | PyramidChartRuntime | RadarChartRuntime | GeoChartRuntime | FunnelChartRuntime | SunburstChartRuntime | TreeMapChartRuntime;
+export type ChartRuntime = ChartJSRuntime | ScorecardChartRuntime | GaugeChartRuntime;
+export type CustomizableSeriesChartRuntime = Extract<ChartRuntime, {
+    customizableSeries: {
+        dataSetId: string;
+        label: string;
+    }[];
+}>;
+export type LabelValues = FunctionResultObject[];
+export interface DatasetValues {
+    readonly dataSetId: UID;
+    readonly label: string;
+    readonly data: FunctionResultObject[];
+    readonly hidden?: boolean;
+}
+export interface DatasetDesign {
+    readonly backgroundColor?: string;
+    readonly yAxisId?: string;
+    readonly label?: string;
+}
+export type AxisGridType = "major" | "minor" | "none" | "both";
+export interface AxisDesign {
+    readonly title?: TitleDesign;
+    readonly min?: number;
+    readonly max?: number;
+    readonly gridLines?: AxisGridType;
+}
+export type AxisId = "x" | "y" | "y1";
+export type AxesDesign = {
+    [K in AxisId]?: AxisDesign;
+};
+export interface ChartStyle {
+    readonly bold?: boolean;
+    readonly italic?: boolean;
+    readonly align?: Align;
+    readonly verticalAlign?: VerticalAlign;
+    readonly color?: Color;
+    readonly fontSize?: number;
+    readonly fillColor?: Color;
+}
+export interface TitleDesign extends ChartStyle {
+    readonly text?: string;
+}
+export type TrendType = "polynomial" | "exponential" | "logarithmic" | "trailingMovingAverage";
+export interface TrendConfiguration {
+    type?: TrendType;
+    order?: number;
+    color?: Color;
+    display?: boolean;
+    window?: number;
+}
+export type DataSetStyle = Record<UID, CustomizedDataSet>;
+export type CustomizedDataSet = {
+    readonly trend?: TrendConfiguration;
+} & DatasetDesign;
+export interface ChartRangeDataSource<T extends string | Range = Range> {
+    readonly type: "range";
+    readonly dataSets: {
+        dataSetId: UID;
+        dataRange: T;
+    }[];
+    readonly dataSetsHaveTitle: boolean;
+    readonly labelRange?: T;
+}
+export interface ChartPivotDataSource {
+    readonly type: "pivot";
+    readonly pivotId: UID;
+}
+export type ChartDataSource<T extends string | Range = Range> = ChartRangeDataSource<T> | {
+    type: "none";
+};
+export type ChartDataSourceType = ChartDataSource["type"];
+export type AxisType = "category" | "linear" | "time";
+export type ChartDatasetOrientation = "rows" | "columns";
+export interface DataSet {
+    readonly dataSetId: UID;
+    readonly labelCell?: Range;
+    readonly dataRange: Range;
+}
+export interface ExcelChartDataset {
+    readonly label?: {
+        text?: string;
+    } | {
+        reference?: string;
+    };
+    readonly range: string;
+    readonly backgroundColor?: Color;
+    readonly rightYAxis?: boolean;
+    readonly trend?: ExcelChartTrendConfiguration;
+}
+export interface ExcelChartTrendConfiguration {
+    readonly type?: ExcelTrendlineType;
+    readonly order?: number;
+    readonly color?: Color;
+    readonly window?: number;
+}
+export type ExcelTrendlineType = "poly" | "exp" | "log" | "movingAvg" | "linear";
+export type ExcelChartType = "line" | "bar" | "pie" | "combo" | "scatter" | "radar" | "pyramid";
+export interface ExcelChartDefinition {
+    readonly title?: TitleDesign;
+    readonly type: ExcelChartType;
+    readonly dataSets: ExcelChartDataset[];
+    readonly labelRange?: string;
+    readonly backgroundColor: XlsxHexColor;
+    readonly fontColor: XlsxHexColor;
+    readonly legendPosition: LegendPosition;
+    readonly stacked?: boolean;
+    readonly cumulative?: boolean;
+    readonly verticalAxis?: {
+        useLeftAxis?: boolean;
+        useRightAxis?: boolean;
+    };
+    readonly axesDesign?: AxesDesign;
+    readonly showValues?: boolean;
+    readonly horizontal?: boolean;
+    readonly isDoughnut?: boolean;
+    readonly pieHolePercentage?: number;
+    readonly maxValue?: number;
+}
+export interface ChartCreationContext {
+    readonly dataSetStyles?: DataSetStyle;
+    readonly hierarchicalDataSource?: ChartDataSource<string>;
+    readonly dataSource?: Partial<ChartDataSource<string>> & {
+        type: ChartDataSource["type"];
+    };
+    readonly title?: TitleDesign;
+    readonly background?: Color;
+    readonly auxiliaryRange?: string;
+    readonly aggregated?: boolean;
+    readonly stacked?: boolean;
+    readonly cumulative?: boolean;
+    readonly labelsAsText?: boolean;
+    readonly showSubTotals?: boolean;
+    readonly showConnectorLines?: boolean;
+    readonly firstValueAsSubtotal?: boolean;
+    readonly legendPosition?: LegendPosition;
+    readonly axesDesign?: AxesDesign;
+    readonly fillArea?: boolean;
+    readonly showValues?: boolean;
+    readonly funnelColors?: FunnelChartColors;
+    readonly showLabels?: boolean;
+    readonly hideDataMarkers?: boolean;
+    readonly valuesDesign?: ChartStyle;
+    readonly groupColors?: (Color | undefined | null)[];
+    readonly horizontal?: boolean;
+    readonly isDoughnut?: boolean;
+    readonly pieHolePercentage?: number;
+    readonly showHeaders?: boolean;
+    readonly headerDesign?: TitleDesign;
+    readonly treemapColoringOptions?: TreeMapColoringOptions;
+    readonly zoomable?: boolean;
+    readonly humanize?: boolean;
+    readonly slicesColors?: Color[];
+}
+export type ChartAxisFormats = {
+    [axisId: string]: Format | undefined;
+} | undefined;
+export interface ChartData {
+    dataSetsValues: DatasetValues[];
+    labelValues: LabelValues;
+}
+export interface ChartRuntimeGenerationArgs {
+    dataSetsValues: DatasetValues[];
+    axisFormats: ChartAxisFormats;
+    labels: string[];
+    locale: Locale;
+    trendDataSetsValues?: (Point[] | undefined)[];
+    axisType?: AxisType;
+    topPadding?: number;
+}
+/** Generic definition of chart to create a runtime: omit the chart type*/
+export type GenericDefinition<T extends ChartDefinitionWithDataSource> = Partial<Omit<T, "type">>;
+export interface ChartColorScale {
+    minColor: Color;
+    midColor?: Color;
+    maxColor: Color;
+}
+export declare function schemeToColorScale(scheme: string): ChartColorScale | undefined;

package/dist/types/types/chart/chartjs.d.ts

@@ -0,0 +1,2 @@
+import * as ChartJs from "chart.js";
+export type GlobalChart = typeof ChartJs & typeof ChartJs.Chart;