@odoo/o-spreadsheet 18.0.55 → 18.0.67

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

@@ -0,0 +1,92 @@
+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;
+    getQuarter(): number;
+    getDate(): number;
+    getDay(): number;
+    getHours(): number;
+    getMinutes(): number;
+    getSeconds(): number;
+    getIsoWeek(): 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, TitleDesign } 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: TitleDesign;
+    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,32 @@
+import { AddColumnsRowsCommand, ApplyRangeChange, Color, CommandResult, CoreGetters, Getters, Range, RemoveColumnsRowsCommand, UID } from "../../../types";
+import { BarChartDefinition, BarChartRuntime } from "../../../types/chart/bar_chart";
+import { AxesDesign, ChartCreationContext, DataSet, DatasetDesign, ExcelChartDefinition } from "../../../types/chart/chart";
+import { LegendPosition } 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 legendPosition: LegendPosition;
+    readonly stacked: boolean;
+    readonly aggregated?: boolean;
+    readonly type = "bar";
+    readonly dataSetsHaveTitle: boolean;
+    readonly dataSetDesign?: DatasetDesign[];
+    readonly axesDesign?: AxesDesign;
+    readonly horizontal?: boolean;
+    readonly showValues?: 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,122 @@
+import { ChartDataset } from "chart.js";
+import { AddColumnsRowsCommand, ApplyRangeChange, Color, CommandResult, CoreGetters, DOMCoordinates, DOMDimension, Getters, LocaleFormat, Range, RemoveColumnsRowsCommand, UID } from "../../../types";
+import { AxisDesign, ChartWithAxisDefinition, CustomizedDataSet, DataSet, ExcelChartDataset, TrendConfiguration } from "../../../types/chart/chart";
+import { ColorGenerator } from "../../color";
+export declare const TREND_LINE_XAXIS_ID = "x1";
+/**
+ * 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, customizedDataSets: CustomizedDataSet[], 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 ChartWithAxisDefinition>(definition: T, executed: AddColumnsRowsCommand | RemoveColumnsRowsCommand): T;
+/**
+ * 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: ChartWithAxisDefinition): CommandResult;
+export declare function checkLabelRange(definition: ChartWithAxisDefinition): CommandResult;
+export declare function shouldRemoveFirstLabel(labelRange: Range | undefined, dataset: DataSet | undefined, dataSetsHaveTitle: boolean): boolean;
+export declare function getChartPositionAtCenterOfViewport(getters: Getters, chartSize: DOMDimension): DOMCoordinates;
+export declare function getChartAxisTitleRuntime(design?: AxisDesign): {
+    display: boolean;
+    text: string;
+    color?: string;
+    font: {
+        style: "italic" | "normal";
+        weight: "bold" | "normal";
+    };
+    align: "start" | "center" | "end";
+} | undefined;
+export declare function getDefinedAxis(definition: ChartWithAxisDefinition): {
+    useLeftAxis: boolean;
+    useRightAxis: boolean;
+};
+export declare function computeChartPadding({ displayTitle, displayLegend, }: {
+    displayTitle: boolean;
+    displayLegend: boolean;
+}): {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+};
+export declare function getTrendDatasetForBarChart(config: TrendConfiguration, dataset: ChartDataset<"bar" | "line", number[]>): {
+    type: string;
+    xAxisID: string;
+    yAxisID: string | undefined;
+    label: string;
+    data: {
+        x: number;
+        y: number;
+    }[];
+    order: number;
+    showLine: boolean;
+    pointRadius: number;
+    backgroundColor: Color;
+    borderColor: Color;
+    borderDash: number[];
+    borderWidth: undefined;
+    fill: boolean;
+    pointBackgroundColor: Color;
+} | undefined;
+export declare function getFullTrendingLineDataSet(dataset: ChartDataset<"line" | "bar">, config: TrendConfiguration, data: number[], labels: number[]): {
+    type: string;
+    xAxisID: string;
+    yAxisID: string | undefined;
+    label: string;
+    data: {
+        x: number;
+        y: number;
+    }[];
+    order: number;
+    showLine: boolean;
+    pointRadius: number;
+    backgroundColor: Color;
+    borderColor: Color;
+    borderDash: number[];
+    borderWidth: undefined;
+    fill: boolean;
+    pointBackgroundColor: Color;
+};
+export declare function interpolateData(config: TrendConfiguration, values: number[], labels: number[], newLabels: number[]): number[];
+export declare function formatTickValue(localeFormat: LocaleFormat): (value: any) => any;
+export declare function getChartColorsGenerator(definition: ChartWithAxisDefinition, dataSetsSize: number): ColorGenerator;
+export declare const CHART_AXIS_CHOICES: {
+    value: string;
+    label: string;
+}[];

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

@@ -0,0 +1,16 @@
+import { ChartConfiguration } from "chart.js";
+import { Color, Getters, Locale } from "../../../types";
+import { AxisType, DatasetValues, TrendConfiguration } from "../../../types/chart/chart";
+import { LineChart } from "./line_chart";
+import { ScatterChart } from "./scatter_chart";
+export declare function fixEmptyLabelsForDateCharts(labels: string[], dataSetsValues: DatasetValues[]): {
+    labels: string[];
+    dataSetsValues: DatasetValues[];
+};
+export declare function canChartParseLabels(chart: LineChart | ScatterChart, getters: Getters): boolean;
+export declare function getChartAxisType(chart: LineChart | ScatterChart, getters: Getters): AxisType;
+export declare function getTrendDatasetForLineChart(config: TrendConfiguration, dataset: any, axisType: AxisType, locale: Locale): DatasetValues | undefined;
+export declare function createLineOrScatterChartRuntime(chart: LineChart | ScatterChart, getters: Getters): {
+    chartJsConfig: ChartConfiguration;
+    background: Color;
+};

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

@@ -0,0 +1,35 @@
+import { AddColumnsRowsCommand, CommandResult, RemoveColumnsRowsCommand, UID, Zone } from "../../../types";
+import { ChartDefinition, ChartRuntime } 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;
+/**
+ * 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_ui_common.d.ts

@@ -0,0 +1,51 @@
+import type { ChartConfiguration } from "chart.js";
+import { LegendOptions } from "chart.js";
+import { CellValue, Color, DeepPartial, 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): (CellValue | undefined)[];
+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, horizontalChart, }: LocaleFormat & {
+    truncateLabels?: boolean;
+    horizontalChart?: 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[];
+/**
+ * If the chart is a stacked area chart, we want to fill until the next dataset.
+ * If the chart is a simple area chart, we want to fill until the origin (bottom axis).
+ *
+ * See https://www.chartjs.org/docs/latest/charts/area.html#filling-modes
+ */
+export declare function getFillingMode(index: number, stackedChart: boolean): string;
+export declare function chartToImage(runtime: ChartRuntime, figure: Figure, type: string): string | undefined;
+export declare function getChartJsLegend(fontColor: Color, legend?: DeepPartial<LegendOptions<any>>): DeepPartial<LegendOptions<any>>;
+/** Return window.Chart, making sure all our extensions are loaded in ChartJS */
+export declare function getChartJSConstructor(): typeof import("chart.js").Chart;

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

@@ -0,0 +1,29 @@
+import { AddColumnsRowsCommand, ApplyRangeChange, ChartCreationContext, Color, CommandResult, CoreGetters, DataSet, ExcelChartDefinition, Getters, Range, RemoveColumnsRowsCommand, UID } from "../../../types";
+import { AxesDesign, LegendPosition } from "../../../types/chart";
+import { ComboChartDataSet, ComboChartDefinition, ComboChartRuntime } from "../../../types/chart/combo_chart";
+import { Validator } from "../../../types/validator";
+import { AbstractChart } from "./abstract_chart";
+export declare class ComboChart extends AbstractChart {
+    readonly dataSets: DataSet[];
+    readonly labelRange?: Range;
+    readonly background?: Color;
+    readonly legendPosition: LegendPosition;
+    readonly aggregated?: boolean;
+    readonly dataSetsHaveTitle: boolean;
+    readonly dataSetDesign?: ComboChartDataSet[];
+    readonly axesDesign?: AxesDesign;
+    readonly type = "combo";
+    readonly showValues?: boolean;
+    constructor(definition: ComboChartDefinition, sheetId: UID, getters: CoreGetters);
+    static transformDefinition(definition: ComboChartDefinition, executed: AddColumnsRowsCommand | RemoveColumnsRowsCommand): ComboChartDefinition;
+    static validateChartDefinition(validator: Validator, definition: ComboChartDefinition): CommandResult | CommandResult[];
+    getContextCreation(): ChartCreationContext;
+    getDefinition(): ComboChartDefinition;
+    getDefinitionWithSpecificDataSets(dataSets: DataSet[], labelRange: Range | undefined, targetSheetId?: UID): ComboChartDefinition;
+    getDefinitionForExcel(): ExcelChartDefinition | undefined;
+    updateRanges(applyChange: ApplyRangeChange): ComboChart;
+    static getDefinitionFromContextCreation(context: ChartCreationContext): ComboChartDefinition;
+    copyForSheetId(sheetId: UID): ComboChart;
+    copyInSheetId(sheetId: UID): ComboChart;
+}
+export declare function createComboChartRuntime(chart: ComboChart, getters: Getters): ComboChartRuntime;

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/gauge_chart_rendering.d.ts

@@ -0,0 +1,48 @@
+import { Color, PixelPosition, Rect } from "../../../types";
+import { GaugeChartRuntime } from "../../../types/chart";
+export declare const GAUGE_PADDING_SIDE = 30;
+export declare const GAUGE_PADDING_TOP = 10;
+export declare const GAUGE_PADDING_BOTTOM = 20;
+export declare const GAUGE_LABELS_FONT_SIZE = 12;
+export declare const GAUGE_DEFAULT_VALUE_FONT_SIZE = 80;
+export declare const GAUGE_TEXT_COLOR = "#666666";
+export declare const GAUGE_TEXT_COLOR_HIGH_CONTRAST = "#C8C8C8";
+export declare const GAUGE_TITLE_SECTION_HEIGHT = 25;
+export declare const GAUGE_TITLE_FONT_SIZE = 14;
+export declare const GAUGE_TITLE_PADDING_LEFT = 10;
+export declare const GAUGE_TITLE_PADDING_TOP = 10;
+interface RenderingParams {
+    width: number;
+    height: number;
+    title: TextProperties & {
+        bold?: boolean;
+        italic?: boolean;
+    };
+    backgroundColor: Color;
+    gauge: {
+        rect: Rect;
+        arcWidth: number;
+        percentage: number;
+        color: Color;
+    };
+    inflectionValues: InflectionValue[];
+    gaugeValue: TextProperties;
+    minLabel: TextProperties;
+    maxLabel: TextProperties;
+}
+interface TextProperties {
+    label: string;
+    textPosition: PixelPosition;
+    fontSize: number;
+    color: Color;
+}
+interface InflectionValue {
+    rotation: number;
+    label: string;
+    fontSize: number;
+    color: Color;
+    offset: number;
+}
+export declare function drawGaugeChart(canvas: HTMLCanvasElement, runtime: GaugeChartRuntime): void;
+export declare function getGaugeRenderingConfig(boundingRect: Rect, runtime: GaugeChartRuntime, ctx: CanvasRenderingContext2D): RenderingParams;
+export {};

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";
+export * from "./waterfall_chart";

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

@@ -0,0 +1,33 @@
+import { AddColumnsRowsCommand, ApplyRangeChange, Color, CommandResult, CoreGetters, Range, RemoveColumnsRowsCommand, UID } from "../../../types";
+import { AxesDesign, ChartCreationContext, DataSet, DatasetDesign, ExcelChartDefinition } from "../../../types/chart/chart";
+import { LegendPosition } from "../../../types/chart/common_chart";
+import { LineChartDefinition } 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 legendPosition: LegendPosition;
+    readonly labelsAsText: boolean;
+    readonly stacked: boolean;
+    readonly aggregated?: boolean;
+    readonly type = "line";
+    readonly dataSetsHaveTitle: boolean;
+    readonly cumulative: boolean;
+    readonly dataSetDesign?: DatasetDesign[];
+    readonly axesDesign?: AxesDesign;
+    readonly fillArea?: boolean;
+    readonly showValues?: 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;
+}

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

@@ -0,0 +1,29 @@
+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;
+    readonly isDoughnut?: boolean;
+    readonly showValues?: 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;