@odoo/o-spreadsheet 17.0.85 → 17.0.96

package/dist/types/helpers/color.d.ts

@@ -0,0 +1,68 @@
+import { Color, HSLA, RGBA } from "../types";
+export declare const colors: string[];
+export declare function colorNumberString(color: number): Color;
+/**
+ * Converts any CSS color value to a standardized hex6 value.
+ * Accepts: hex3, hex6, hex8, rgb[1] and rgba[1].
+ *
+ * [1] under the form rgb(r, g, b, a?) or rgba(r, g, b, a?)
+ * with r,g,b ∈ [0, 255] and a ∈ [0, 1]
+ *
+ * toHex("#ABC")
+ * >> "#AABBCC"
+ *
+ * toHex("#AAAFFF")
+ * >> "#AAAFFF"
+ *
+ * toHex("rgb(30, 80, 16)")
+ * >> "#1E5010"
+ *
+ *  * toHex("rgb(30, 80, 16, 0.5)")
+ * >> "#1E501080"
+ *
+ */
+export declare function toHex(color: Color): Color;
+export declare function isColorValid(color: Color): boolean;
+export declare function isHSLAValid(color: HSLA): boolean;
+export declare function rgba(r: number, g: number, b: number, a?: number): RGBA;
+/**
+ * The relative brightness of a point in the colorspace, normalized to 0 for
+ * darkest black and 1 for lightest white.
+ * https://www.w3.org/TR/WCAG20/#relativeluminancedef
+ */
+export declare function relativeLuminance(color: Color): number;
+/**
+ * RGBA to HEX representation (#RRGGBBAA).
+ *
+ * https://css-tricks.com/converting-color-spaces-in-javascript/
+ */
+export declare function rgbaToHex(rgba: RGBA): Color;
+/**
+ * Color string to RGBA representation
+ */
+export declare function colorToRGBA(color: Color): RGBA;
+/**
+ * HSLA to RGBA.
+ *
+ * https://css-tricks.com/converting-color-spaces-in-javascript/
+ */
+export declare function hslaToRGBA(hsla: HSLA): RGBA;
+/**
+ * HSLA to RGBA.
+ *
+ * https://css-tricks.com/converting-color-spaces-in-javascript/
+ */
+export declare function rgbaToHSLA(rgba: RGBA): HSLA;
+export declare function hslaToHex(hsla: HSLA): Color;
+export declare function hexToHSLA(hex: Color): HSLA;
+/**
+ * Will compare two color strings
+ * A tolerance can be provided to account for small differences that could
+ * be introduced by non-bijective transformations between color spaces.
+ *
+ * E.g. HSV <-> RGB is not a bijection
+ *
+ * Note that the tolerance is applied on the euclidean distance between
+ * the two **normalized** color values.
+ */
+export declare function isSameColor(color1: Color, color2: Color, tolerance?: number): boolean;

package/dist/types/helpers/coordinates.d.ts

@@ -0,0 +1,40 @@
+import { HeaderIndex, Position, RangePart } from "../types";
+/**
+ * Convert a (col) number to the corresponding letter.
+ *
+ * Examples:
+ *     0 => 'A'
+ *     25 => 'Z'
+ *     26 => 'AA'
+ *     27 => 'AB'
+ */
+export declare function numberToLetters(n: number): string;
+/**
+ * Convert a string (describing a column) to its number value.
+ *
+ * Examples:
+ *     'A' => 0
+ *     'Z' => 25
+ *     'AA' => 26
+ */
+export declare function lettersToNumber(letters: string): number;
+/**
+ * Convert a "XC" coordinate to cartesian coordinates.
+ *
+ * Examples:
+ *   A1 => [0,0]
+ *   B3 => [1,2]
+ *
+ * Note: it also accepts lowercase coordinates, but not fixed references
+ */
+export declare function toCartesian(xc: string): Position;
+/**
+ * Convert from cartesian coordinate to the "XC" coordinate system.
+ *
+ * Examples:
+ *   - 0,0 => A1
+ *   - 1,2 => B3
+ *   - 0,0, {colFixed: false, rowFixed: true} => A$1
+ *   - 1,2, {colFixed: true, rowFixed: false} => $B3
+ */
+export declare function toXC(col: HeaderIndex, row: HeaderIndex, rangePart?: RangePart): string;

package/dist/types/helpers/data_validation_helpers.d.ts

@@ -0,0 +1,5 @@
+import { DataValidationCriterion, Locale } from "../types";
+/** Get all the dates values of a criterion converted to numbers, converting date values such as "today" to actual dates  */
+export declare function getDateNumberCriterionValues(criterion: DataValidationCriterion, locale: Locale): (number | undefined)[];
+/** Convert the criterion values to numbers. Return undefined values if they cannot be converted to numbers. */
+export declare function getCriterionValuesAsNumber(criterion: DataValidationCriterion, locale: Locale): (number | undefined)[];

package/dist/types/helpers/dates.d.ts

@@ -0,0 +1,90 @@
+import { CellValue, Format, Locale } from "../types";
+/**
+ * All Spreadsheet dates are internally stored as an object with two values:
+ * - value (number), which represent the number of day till 30/12/1899
+ * - format (string), which keep the information on how the date was defined
+ */
+export interface InternalDate {
+    readonly value: number;
+    readonly format: Format;
+    readonly jsDate?: ReadonlyDateTime;
+}
+/**
+ * A DateTime object that can be used to manipulate spreadsheet dates.
+ * Conceptually, a spreadsheet date is simply a number with a date format,
+ * and it is timezone-agnostic.
+ * This DateTime object consistently uses UTC time to represent a naive date and time.
+ */
+export declare class DateTime {
+    private jsDate;
+    constructor(year: number, month: number, day: number, hours?: number, minutes?: number, seconds?: number);
+    static fromTimestamp(timestamp: number): DateTime;
+    static now(): DateTime;
+    toString(): string;
+    toLocaleDateString(): string;
+    getTime(): number;
+    getFullYear(): number;
+    getMonth(): number;
+    getDate(): number;
+    getDay(): number;
+    getHours(): number;
+    getMinutes(): number;
+    getSeconds(): number;
+    setFullYear(year: number): number;
+    setMonth(month: number): number;
+    setDate(date: number): number;
+    setHours(hours: number): number;
+    setMinutes(minutes: number): number;
+    setSeconds(seconds: number): number;
+}
+type ReadonlyDateTime = Readonly<Omit<DateTime, "setSeconds" | "setMinutes" | "setHours" | "setDate" | "setMonth" | "setFullYear">>;
+export declare const INITIAL_1900_DAY: DateTime;
+export declare const MS_PER_DAY: number;
+export declare const mdyDateRegexp: RegExp;
+export declare const ymdDateRegexp: RegExp;
+export declare const timeRegexp: RegExp;
+/** Convert a value number representing a date, or return undefined if it isn't possible */
+export declare function valueToDateNumber(value: CellValue, locale: Locale): number | undefined;
+export declare function isDateTime(str: string, locale: Locale): boolean;
+export declare function parseDateTime(str: string, locale: Locale): InternalDate | null;
+export declare function numberToJsDate(value: number): DateTime;
+export declare function jsDateToRoundNumber(date: DateTime): number;
+export declare function jsDateToNumber(date: DateTime): number;
+/** Return the number of days in the current month of the given date */
+export declare function getDaysInMonth(date: DateTime): number;
+export declare function isLastDayOfMonth(date: DateTime): boolean;
+/**
+ * Add a certain number of months to a date. This will adapt the month number, and possibly adapt
+ * the day of the month to keep it in the month.
+ *
+ * For example "31/12/2020" minus one month will be "30/11/2020", and not "31/11/2020"
+ *
+ * @param keepEndOfMonth if true, if the given date was the last day of a month, the returned date will
+ *          also always be the last day of a month.
+ */
+export declare function addMonthsToDate(date: DateTime, months: number, keepEndOfMonth: boolean): DateTime;
+export declare function getYearFrac(startDate: number, endDate: number, _dayCountConvention: number): number;
+/**
+ * Get the number of whole months between two dates.
+ * e.g.
+ *  2002/01/01 -> 2002/02/01 = 1 month,
+ *  2002/01/01 -> 2003/02/01 = 13 months
+ * @param startDate
+ * @param endDate
+ * @returns
+ */
+export declare function getTimeDifferenceInWholeMonths(startDate: DateTime, endDate: DateTime): number;
+export declare function getTimeDifferenceInWholeDays(startDate: DateTime, endDate: DateTime): number;
+export declare function getTimeDifferenceInWholeYears(startDate: DateTime, endDate: DateTime): number;
+export declare function areTwoDatesWithinOneYear(startDate: number, endDate: number): boolean;
+export declare function areDatesSameDay(startDate: number, endDate: number): boolean;
+export declare function isDateBetween(date: number, startDate: number, endDate: number): boolean;
+/** Check if the first date is strictly before the second date */
+export declare function isDateStrictlyBefore(date: number, dateBefore: number): boolean;
+/** Check if the first date is before or equal to the second date */
+export declare function isDateBefore(date: number, dateBefore: number): boolean;
+/** Check if the first date is strictly after the second date */
+export declare function isDateStrictlyAfter(date: number, dateAfter: number): boolean;
+/** Check if the first date is after or equal to the second date */
+export declare function isDateAfter(date: number, dateAfter: number): boolean;
+export {};

package/dist/types/helpers/edge_scrolling.d.ts

@@ -0,0 +1,9 @@
+export declare const MAX_DELAY = 140;
+export declare const MIN_DELAY = 20;
+/**
+ * Decreasing exponential function used to determine the "speed" of edge-scrolling
+ * as the timeout delay.
+ *
+ * Returns a timeout delay in milliseconds.
+ */
+export declare function scrollDelay(value: number): number;

package/dist/types/helpers/event_bus.d.ts

@@ -0,0 +1,45 @@
+/**
+ * This is a generic event bus based on the Owl event bus.
+ * This bus however ensures type safety across events and subscription callbacks.
+ */
+export declare class EventBus<Event extends {
+    type: string;
+}> {
+    subscriptions: {
+        [eventType: string]: Subscription[];
+    };
+    /**
+     * Add a listener for the 'eventType' events.
+     *
+     * Note that the 'owner' of this event can be anything, but will more likely
+     * be a component or a class. The idea is that the callback will be called with
+     * the proper owner bound.
+     *
+     * Also, the owner should be kind of unique. This will be used to remove the
+     * listener.
+     */
+    on<T extends Event["type"], E extends Extract<Event, {
+        type: T;
+    }>>(type: T, owner: any, callback: (r: Omit<E, "type">) => void): void;
+    /**
+     * Emit an event of type 'eventType'.  Any extra arguments will be passed to
+     * the listeners callback.
+     */
+    trigger<T extends Event["type"], E extends Extract<Event, {
+        type: T;
+    }>>(type: T, payload?: Omit<E, "type">): void;
+    /**
+     * Remove a listener
+     */
+    off<T extends Event["type"]>(eventType: T, owner: any): void;
+    /**
+     * Remove all subscriptions.
+     */
+    clear(): void;
+}
+type Callback = (...args: any[]) => void;
+interface Subscription {
+    owner: any;
+    callback: Callback;
+}
+export {};

package/dist/types/helpers/figures/charts/abstract_chart.d.ts

@@ -0,0 +1,56 @@
+import { AddColumnsRowsCommand, ApplyRangeChange, CommandResult, CoreGetters, RemoveColumnsRowsCommand, UID } from "../../../types";
+import { ChartCreationContext, ChartDefinition, ChartType, ExcelChartDefinition } from "../../../types/chart/chart";
+import { Validator } from "../../../types/validator";
+/**
+ * AbstractChart is the class from which every Chart should inherit.
+ * The role of this class is to maintain the state of each chart.
+ */
+export declare abstract class AbstractChart {
+    readonly sheetId: UID;
+    readonly title: string;
+    abstract readonly type: ChartType;
+    protected readonly getters: CoreGetters;
+    constructor(definition: ChartDefinition, sheetId: UID, getters: CoreGetters);
+    /**
+     * Validate the chart definition given as arguments. This function will be
+     * called from allowDispatch function
+     */
+    static validateChartDefinition(validator: Validator, definition: ChartDefinition): CommandResult | CommandResult[];
+    /**
+     * Get a new chart definition transformed with the executed command. This
+     * functions will be called during operational transform process
+     */
+    static transformDefinition(definition: ChartDefinition, executed: AddColumnsRowsCommand | RemoveColumnsRowsCommand): ChartDefinition;
+    /**
+     * Get an empty definition based on the given context
+     */
+    static getDefinitionFromContextCreation(context: ChartCreationContext): ChartDefinition;
+    /**
+     * Get the definition of the chart
+     */
+    abstract getDefinition(): ChartDefinition;
+    /**
+     * Get the definition of the chart that will be used for excel export.
+     * If the chart is not supported by Excel, this function returns undefined.
+     */
+    abstract getDefinitionForExcel(): ExcelChartDefinition | undefined;
+    /**
+     * This function should be used to update all the ranges of the chart after
+     * a grid change (add/remove col/row, rename sheet, ...)
+     */
+    abstract updateRanges(applyChange: ApplyRangeChange): AbstractChart;
+    /**
+     * Get a copy a the chart adapted to the given sheetId.
+     * The ranges that are in the same sheet as the chart will be adapted to the given sheetId.
+     */
+    abstract copyForSheetId(sheetId: UID): AbstractChart;
+    /**
+     * Get a copy a the chart in the given sheetId.
+     * The ranges of the chart will stay the same as the copied chart.
+     */
+    abstract copyInSheetId(sheetId: UID): AbstractChart;
+    /**
+     * Extract the ChartCreationContext of the chart
+     */
+    abstract getContextCreation(): ChartCreationContext;
+}

package/dist/types/helpers/figures/charts/bar_chart.d.ts

@@ -0,0 +1,29 @@
+import { AddColumnsRowsCommand, ApplyRangeChange, Color, CommandResult, CoreGetters, Getters, Range, RemoveColumnsRowsCommand, UID } from "../../../types";
+import { BarChartDefinition, BarChartRuntime } from "../../../types/chart/bar_chart";
+import { ChartCreationContext, DataSet, ExcelChartDefinition } from "../../../types/chart/chart";
+import { LegendPosition, VerticalAxisPosition } from "../../../types/chart/common_chart";
+import { Validator } from "../../../types/validator";
+import { AbstractChart } from "./abstract_chart";
+export declare class BarChart extends AbstractChart {
+    readonly dataSets: DataSet[];
+    readonly labelRange?: Range | undefined;
+    readonly background?: Color;
+    readonly verticalAxisPosition: VerticalAxisPosition;
+    readonly legendPosition: LegendPosition;
+    readonly stacked: boolean;
+    readonly aggregated?: boolean;
+    readonly type = "bar";
+    readonly dataSetsHaveTitle: boolean;
+    constructor(definition: BarChartDefinition, sheetId: UID, getters: CoreGetters);
+    static transformDefinition(definition: BarChartDefinition, executed: AddColumnsRowsCommand | RemoveColumnsRowsCommand): BarChartDefinition;
+    static validateChartDefinition(validator: Validator, definition: BarChartDefinition): CommandResult | CommandResult[];
+    static getDefinitionFromContextCreation(context: ChartCreationContext): BarChartDefinition;
+    getContextCreation(): ChartCreationContext;
+    copyForSheetId(sheetId: UID): BarChart;
+    copyInSheetId(sheetId: UID): BarChart;
+    getDefinition(): BarChartDefinition;
+    private getDefinitionWithSpecificDataSets;
+    getDefinitionForExcel(): ExcelChartDefinition | undefined;
+    updateRanges(applyChange: ApplyRangeChange): BarChart;
+}
+export declare function createBarChartRuntime(chart: BarChart, getters: Getters): BarChartRuntime;

package/dist/types/helpers/figures/charts/chart_common.d.ts

@@ -0,0 +1,62 @@
+import { AddColumnsRowsCommand, ApplyRangeChange, Color, CommandResult, CoreGetters, DOMCoordinates, DOMDimension, EvaluatedCell, Getters, Locale, Range, RemoveColumnsRowsCommand, UID } from "../../../types";
+import { BarChartDefinition } from "../../../types/chart/bar_chart";
+import { DataSet, ExcelChartDataset } from "../../../types/chart/chart";
+import { LineChartDefinition } from "../../../types/chart/line_chart";
+import { PieChartDefinition } from "../../../types/chart/pie_chart";
+import { BaselineArrowDirection, BaselineMode } from "../../../types/chart/scorecard_chart";
+/**
+ * This file contains helpers that are common to different charts (mainly
+ * line, bar and pie charts)
+ */
+/**
+ * Adapt ranges of a chart which support DataSet (dataSets and LabelRange).
+ */
+export declare function updateChartRangesWithDataSets(getters: CoreGetters, applyChange: ApplyRangeChange, chartDataSets: DataSet[], chartLabelRange?: Range): {
+    isStale: boolean;
+    dataSets: DataSet[];
+    labelRange: Range | undefined;
+};
+/**
+ * Copy the dataSets given. All the ranges which are on sheetIdFrom will target
+ * sheetIdTo.
+ */
+export declare function copyDataSetsWithNewSheetId(sheetIdFrom: UID, sheetIdTo: UID, dataSets: DataSet[]): DataSet[];
+/**
+ * Copy a range. If the range is on the sheetIdFrom, the range will target
+ * sheetIdTo.
+ */
+export declare function copyLabelRangeWithNewSheetId(sheetIdFrom: UID, sheetIdTo: UID, range?: Range): Range | undefined;
+/**
+ * Adapt a single range of a chart
+ */
+export declare function adaptChartRange(range: Range | undefined, applyChange: ApplyRangeChange): Range | undefined;
+/**
+ * Create the dataSet objects from xcs
+ */
+export declare function createDataSets(getters: CoreGetters, dataSetsString: string[], sheetId: UID, dataSetsHaveTitle: boolean): DataSet[];
+/**
+ * Transform a dataSet to a ExcelDataSet
+ */
+export declare function toExcelDataset(getters: CoreGetters, ds: DataSet): ExcelChartDataset;
+export declare function toExcelLabelRange(getters: CoreGetters, labelRange: Range | undefined, shouldRemoveFirstLabel?: boolean): string | undefined;
+/**
+ * Transform a chart definition which supports dataSets (dataSets and LabelRange)
+ * with an executed command
+ */
+export declare function transformChartDefinitionWithDataSetsWithZone<T extends LineChartDefinition | BarChartDefinition | PieChartDefinition>(definition: T, executed: AddColumnsRowsCommand | RemoveColumnsRowsCommand): T;
+export declare class ChartColors {
+    private graphColorIndex;
+    next(): string;
+}
+/**
+ * Choose a font color based on a background color.
+ * The font is white with a dark background.
+ */
+export declare function chartFontColor(backgroundColor: Color | undefined): Color;
+export declare function checkDataset(definition: LineChartDefinition | BarChartDefinition | PieChartDefinition): CommandResult;
+export declare function checkLabelRange(definition: LineChartDefinition | BarChartDefinition | PieChartDefinition): CommandResult;
+export declare function shouldRemoveFirstLabel(labelRange: Range | undefined, dataset: DataSet | undefined, dataSetsHaveTitle: boolean): boolean;
+export declare function getBaselineText(baseline: EvaluatedCell | undefined, keyValue: EvaluatedCell | undefined, baselineMode: BaselineMode, locale: Locale): string;
+export declare function getBaselineColor(baseline: EvaluatedCell | undefined, baselineMode: BaselineMode, keyValue: EvaluatedCell | undefined, colorUp: Color, colorDown: Color): Color | undefined;
+export declare function getBaselineArrowDirection(baseline: EvaluatedCell | undefined, keyValue: EvaluatedCell | undefined, baselineMode: BaselineMode): BaselineArrowDirection;
+export declare function getChartPositionAtCenterOfViewport(getters: Getters, chartSize: DOMDimension): DOMCoordinates;

package/dist/types/helpers/figures/charts/chart_factory.d.ts

@@ -0,0 +1,40 @@
+import { AddColumnsRowsCommand, CommandResult, RemoveColumnsRowsCommand, UID, Zone } from "../../../types";
+import { ChartCreationContext, ChartDefinition, ChartRuntime, ChartType } from "../../../types/chart/chart";
+import { CoreGetters, Getters } from "../../../types/getters";
+import { Validator } from "../../../types/validator";
+import { AbstractChart } from "./abstract_chart";
+/**
+ * Create a function used to create a Chart based on the definition
+ */
+export declare function chartFactory(getters: CoreGetters): (id: UID, definition: ChartDefinition, sheetId: UID) => AbstractChart;
+/**
+ * Create a function used to create a Chart Runtime based on the chart class
+ * instance
+ */
+export declare function chartRuntimeFactory(getters: Getters): (chart: AbstractChart) => ChartRuntime;
+/**
+ * Validate the chart definition given in arguments
+ */
+export declare function validateChartDefinition(validator: Validator, definition: ChartDefinition): CommandResult | CommandResult[];
+/**
+ * Get a new chart definition transformed with the executed command. This
+ * functions will be called during operational transform process
+ */
+export declare function transformDefinition(definition: ChartDefinition, executed: AddColumnsRowsCommand | RemoveColumnsRowsCommand): ChartDefinition;
+/**
+ * Get an empty definition based on the given context and the given type
+ */
+export declare function getChartDefinitionFromContextCreation(context: ChartCreationContext, type: ChartType): ChartDefinition;
+export declare function getChartTypes(): Record<string, string>;
+/**
+ * Return a "smart" chart definition in the given zone. The definition is "smart" because it will
+ * use the best type of chart to display the data of the zone.
+ *
+ * It will also try to find labels and datasets in the range, and try to find title for the datasets.
+ *
+ * The type of chart will be :
+ * - If the zone is a single non-empty cell, returns a scorecard
+ * - If the all the labels are numbers/date, returns a line chart
+ * - Else returns a bar chart
+ */
+export declare function getSmartChartDefinition(zone: Zone, getters: Getters): ChartDefinition;

package/dist/types/helpers/figures/charts/chart_js_gauge_controller.d.ts

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

package/dist/types/helpers/figures/charts/chart_ui_common.d.ts

@@ -0,0 +1,41 @@
+import type { ChartConfiguration } from "chart.js";
+import { Color, Figure, Format, Getters, LocaleFormat, Range } from "../../../types";
+import { ChartRuntime, DataSet, DatasetValues, LabelValues } from "../../../types/chart/chart";
+import { AbstractChart } from "./abstract_chart";
+/**
+ * This file contains helpers that are common to different runtime charts (mainly
+ * line, bar and pie charts)
+ */
+/**
+ * Get the data from a dataSet
+ */
+export declare function getData(getters: Getters, ds: DataSet): any[];
+export declare function filterEmptyDataPoints(labels: string[], datasets: DatasetValues[]): {
+    labels: string[];
+    dataSetsValues: DatasetValues[];
+};
+/**
+ * Aggregates data based on labels
+ */
+export declare function aggregateDataForLabels(labels: string[], datasets: DatasetValues[]): {
+    labels: string[];
+    dataSetsValues: DatasetValues[];
+};
+export declare function truncateLabel(label: string | undefined): string;
+/**
+ * Get a default chart js configuration
+ */
+export declare function getDefaultChartJsRuntime(chart: AbstractChart, labels: string[], fontColor: Color, { format, locale, truncateLabels }: LocaleFormat & {
+    truncateLabels?: boolean;
+}): Required<ChartConfiguration>;
+export declare function getChartLabelFormat(getters: Getters, range: Range | undefined, shouldRemoveFirstLabel: boolean): Format | undefined;
+export declare function getChartLabelValues(getters: Getters, dataSets: DataSet[], labelRange?: Range): LabelValues;
+/**
+ * Get the format to apply to the the dataset values. This format is defined as the first format
+ * found in the dataset ranges that isn't a date format.
+ */
+export declare function getChartDatasetFormat(getters: Getters, dataSets: DataSet[]): Format | undefined;
+export declare function getChartDatasetValues(getters: Getters, dataSets: DataSet[]): DatasetValues[];
+/** See https://www.chartjs.org/docs/latest/charts/area.html#filling-modes */
+export declare function getFillingMode(index: number): "origin" | number;
+export declare function chartToImage(runtime: ChartRuntime, figure: Figure, type: string): any;

package/dist/types/helpers/figures/charts/gauge_chart.d.ts

@@ -0,0 +1,23 @@
+import { AddColumnsRowsCommand, ApplyRangeChange, Color, CommandResult, CoreGetters, Getters, Range, RemoveColumnsRowsCommand, UID } from "../../../types";
+import { ChartCreationContext } from "../../../types/chart/chart";
+import { GaugeChartDefinition, GaugeChartRuntime, SectionRule } from "../../../types/chart/gauge_chart";
+import { Validator } from "../../../types/validator";
+import { AbstractChart } from "./abstract_chart";
+export declare class GaugeChart extends AbstractChart {
+    readonly dataRange?: Range;
+    readonly sectionRule: SectionRule;
+    readonly background?: Color;
+    readonly type = "gauge";
+    constructor(definition: GaugeChartDefinition, sheetId: UID, getters: CoreGetters);
+    static validateChartDefinition(validator: Validator, definition: GaugeChartDefinition): CommandResult | CommandResult[];
+    static transformDefinition(definition: GaugeChartDefinition, executed: AddColumnsRowsCommand | RemoveColumnsRowsCommand): GaugeChartDefinition;
+    static getDefinitionFromContextCreation(context: ChartCreationContext): GaugeChartDefinition;
+    copyForSheetId(sheetId: UID): GaugeChart;
+    copyInSheetId(sheetId: UID): GaugeChart;
+    getDefinition(): GaugeChartDefinition;
+    private getDefinitionWithSpecificRanges;
+    getDefinitionForExcel(): undefined;
+    getContextCreation(): ChartCreationContext;
+    updateRanges(applyChange: ApplyRangeChange): GaugeChart;
+}
+export declare function createGaugeChartRuntime(chart: GaugeChart, getters: Getters): GaugeChartRuntime;

package/dist/types/helpers/figures/charts/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./abstract_chart";
+export * from "./bar_chart";
+export * from "./chart_common";
+export * from "./chart_factory";
+export * from "./chart_ui_common";
+export * from "./gauge_chart";
+export * from "./line_chart";
+export * from "./pie_chart";
+export * from "./scorecard_chart";
+import "./chart_js_gauge_controller";

package/dist/types/helpers/figures/charts/line_chart.d.ts

@@ -0,0 +1,32 @@
+import { AddColumnsRowsCommand, ApplyRangeChange, Color, CommandResult, CoreGetters, Getters, Range, RemoveColumnsRowsCommand, UID } from "../../../types";
+import { ChartCreationContext, DataSet, ExcelChartDefinition } from "../../../types/chart/chart";
+import { LegendPosition, VerticalAxisPosition } from "../../../types/chart/common_chart";
+import { LineChartDefinition, LineChartRuntime } from "../../../types/chart/line_chart";
+import { Validator } from "../../../types/validator";
+import { AbstractChart } from "./abstract_chart";
+export declare class LineChart extends AbstractChart {
+    readonly dataSets: DataSet[];
+    readonly labelRange?: Range | undefined;
+    readonly background?: Color;
+    readonly verticalAxisPosition: VerticalAxisPosition;
+    readonly legendPosition: LegendPosition;
+    readonly labelsAsText: boolean;
+    readonly stacked: boolean;
+    readonly aggregated?: boolean;
+    readonly type = "line";
+    readonly dataSetsHaveTitle: boolean;
+    readonly cumulative: boolean;
+    constructor(definition: LineChartDefinition, sheetId: UID, getters: CoreGetters);
+    static validateChartDefinition(validator: Validator, definition: LineChartDefinition): CommandResult | CommandResult[];
+    static transformDefinition(definition: LineChartDefinition, executed: AddColumnsRowsCommand | RemoveColumnsRowsCommand): LineChartDefinition;
+    static getDefinitionFromContextCreation(context: ChartCreationContext): LineChartDefinition;
+    getDefinition(): LineChartDefinition;
+    private getDefinitionWithSpecificDataSets;
+    getContextCreation(): ChartCreationContext;
+    updateRanges(applyChange: ApplyRangeChange): LineChart;
+    getDefinitionForExcel(): ExcelChartDefinition | undefined;
+    copyForSheetId(sheetId: UID): LineChart;
+    copyInSheetId(sheetId: UID): LineChart;
+}
+export declare function canChartParseLabels(chart: LineChart, getters: Getters): boolean;
+export declare function createLineChartRuntime(chart: LineChart, getters: Getters): LineChartRuntime;

package/dist/types/helpers/figures/charts/pie_chart.d.ts

@@ -0,0 +1,27 @@
+import { AddColumnsRowsCommand, ApplyRangeChange, Color, CommandResult, CoreGetters, Getters, Range, RemoveColumnsRowsCommand, UID } from "../../../types";
+import { ChartCreationContext, DataSet, ExcelChartDefinition } from "../../../types/chart/chart";
+import { LegendPosition } from "../../../types/chart/common_chart";
+import { PieChartDefinition, PieChartRuntime } from "../../../types/chart/pie_chart";
+import { Validator } from "../../../types/validator";
+import { AbstractChart } from "./abstract_chart";
+export declare class PieChart extends AbstractChart {
+    readonly dataSets: DataSet[];
+    readonly labelRange?: Range | undefined;
+    readonly background?: Color;
+    readonly legendPosition: LegendPosition;
+    readonly type = "pie";
+    readonly aggregated?: boolean;
+    readonly dataSetsHaveTitle: boolean;
+    constructor(definition: PieChartDefinition, sheetId: UID, getters: CoreGetters);
+    static transformDefinition(definition: PieChartDefinition, executed: AddColumnsRowsCommand | RemoveColumnsRowsCommand): PieChartDefinition;
+    static validateChartDefinition(validator: Validator, definition: PieChartDefinition): CommandResult | CommandResult[];
+    static getDefinitionFromContextCreation(context: ChartCreationContext): PieChartDefinition;
+    getDefinition(): PieChartDefinition;
+    getContextCreation(): ChartCreationContext;
+    private getDefinitionWithSpecificDataSets;
+    copyForSheetId(sheetId: UID): PieChart;
+    copyInSheetId(sheetId: UID): PieChart;
+    getDefinitionForExcel(): ExcelChartDefinition | undefined;
+    updateRanges(applyChange: ApplyRangeChange): PieChart;
+}
+export declare function createPieChartRuntime(chart: PieChart, getters: Getters): PieChartRuntime;

package/dist/types/helpers/figures/charts/scorecard_chart.d.ts

@@ -0,0 +1,30 @@
+import { AddColumnsRowsCommand, ApplyRangeChange, Color, CommandResult, CoreGetters, Getters, Range, RemoveColumnsRowsCommand, UID } from "../../../types";
+import { ChartCreationContext } from "../../../types/chart/chart";
+import { BaselineMode, ScorecardChartDefinition, ScorecardChartRuntime } from "../../../types/chart/scorecard_chart";
+import { Validator } from "../../../types/validator";
+import { AbstractChart } from "./abstract_chart";
+import { ScorecardChartConfig } from "./scorecard_chart_config_builder";
+export declare class ScorecardChart extends AbstractChart {
+    readonly keyValue?: Range;
+    readonly baseline?: Range;
+    readonly baselineMode: BaselineMode;
+    readonly baselineDescr?: string;
+    readonly background?: Color;
+    readonly baselineColorUp: Color;
+    readonly baselineColorDown: Color;
+    readonly fontColor?: Color;
+    readonly type = "scorecard";
+    constructor(definition: ScorecardChartDefinition, sheetId: UID, getters: CoreGetters);
+    static validateChartDefinition(validator: Validator, definition: ScorecardChartDefinition): CommandResult | CommandResult[];
+    static getDefinitionFromContextCreation(context: ChartCreationContext): ScorecardChartDefinition;
+    static transformDefinition(definition: ScorecardChartDefinition, executed: AddColumnsRowsCommand | RemoveColumnsRowsCommand): ScorecardChartDefinition;
+    copyForSheetId(sheetId: UID): ScorecardChart;
+    copyInSheetId(sheetId: UID): ScorecardChart;
+    getDefinition(): ScorecardChartDefinition;
+    getContextCreation(): ChartCreationContext;
+    private getDefinitionWithSpecificRanges;
+    getDefinitionForExcel(): undefined;
+    updateRanges(applyChange: ApplyRangeChange): ScorecardChart;
+}
+export declare function drawScoreChart(structure: ScorecardChartConfig, canvas: HTMLCanvasElement): void;
+export declare function createScorecardChartRuntime(chart: ScorecardChart, getters: Getters): ScorecardChartRuntime;