@odoo/o-spreadsheet 19.2.0-alpha.4 → 19.3.2

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

@@ -0,0 +1,127 @@
+import { Color, HSLA, RGBA } from "../types/misc";
+export declare const colors: string[];
+export declare function colorNumberToHex(color: number, alpha?: number): Color;
+export declare function colorToNumber(color: Color | number): number;
+/**
+ * Converts any CSS color value to a standardized hex6 value.
+ * Accepts: hex3, hex6, hex8, rgb[1] and rgba[1].
+ *
+ * In the case of `light-dark(...)` colors, it will convert both light and dark colors to hex.
+ *
+ * [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"
+ *
+ * toHex("light-dark(#aaa, #bbb)")
+ * >> "light-dark(#AAAAAA, #BBBBBB)"
+ */
+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;
+/**
+ * Blend color2 on top of color1, with alpha blending.
+ */
+export declare function blendColors(color1: Color, color2: Color): Color;
+/**
+ * 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;
+/**
+ * Set the alpha of a color.
+ *
+ * Accepts `light-dark(...)` color strings and will apply the alpha to both light and dark colors.
+ */
+export declare function setColorAlpha(color: Color, alpha: number): string;
+export declare function lightenColor(color: Color, percentage: number): Color;
+export declare function darkenColor(color: Color, percentage: number): Color;
+export declare function chipTextColor(chipBackgroundColor: Color): Color;
+export declare const FIRST_CHART_COLOR = "#4EA7F2";
+export declare function getNthColor(index: number, palette: Color[]): Color;
+export declare function getColorsPalette(quantity: number): string[];
+export declare function getAlternatingColorsPalette(quantity: number): string[];
+export declare class ColorGenerator {
+    private preferredColors;
+    private currentColorIndex;
+    protected palette: Color[];
+    constructor(paletteSize: number, preferredColors?: (Color | undefined | null)[]);
+    next(): string;
+}
+export declare class AlternatingColorGenerator extends ColorGenerator {
+    constructor(paletteSize: number, preferredColors?: (string | undefined)[]);
+}
+export declare class AlternatingColorMap {
+    private availableColors;
+    private colors;
+    constructor(paletteSize?: number);
+    get(id: string): Color;
+}
+export declare const COLORSCHEMES: {
+    readonly greys: readonly ["#ffffff", "#808080", "#000000"];
+    readonly blues: readonly ["#f7fbff", "#6aaed6", "#08306b"];
+    readonly reds: readonly ["#fff5f0", "#fb694a", "#67000d"];
+    readonly greens: readonly ["#f7fcf5", "#73c476", "#00441b"];
+    readonly oranges: readonly ["#fff5eb", "#fd8c3b", "#7f2704"];
+    readonly purples: readonly ["#fcfbfd", "#9e9ac8", "#3f007d"];
+    readonly viridis: readonly ["#440154", "#21918c", "#fde725"];
+    readonly cividis: readonly ["#00224e", "#7d7c78", "#fee838"];
+    readonly rainbow: readonly ["#B41DB4", "#FFFF00", "#00FFFF"];
+};
+export declare const COLORSCALES: string[];
+export type ColorScale = keyof typeof COLORSCHEMES;
+/**
+ * Returns a function that maps a value to a color using a color scale defined by the given
+ * color/threshold values pairs.
+ */
+export declare function getColorScale(colorScalePoints: {
+    value: number;
+    color: number | Color;
+}[]): (value: number) => Color;

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

@@ -0,0 +1,12 @@
+/**
+ * KeepLast is a concurrency primitive that manages a list of tasks, and only
+ * keeps the last task active.
+ *
+ */
+export declare class KeepLast<T> {
+    private lastId;
+    /**
+     * Register a new task
+     */
+    add(promise: Promise<T>): Promise<T>;
+}

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

@@ -0,0 +1,39 @@
+import { HeaderIndex, Position } from "../types/misc";
+import { RangePart } from "../types/range";
+import { TokenizingChars } from "./misc";
+/**
+ * Convert a (col) number to the corresponding letter.
+ *
+ * Examples:
+ *     0 => 'A'
+ *     25 => 'Z'
+ *     26 => 'AA'
+ *     27 => 'AB'
+ */
+export declare function numberToLetters(n: number): string;
+export declare function lettersToNumber(letters: string): number;
+export declare const MAX_COL: number;
+export declare const MAX_ROW = 9999998;
+export declare function consumeSpaces(chars: TokenizingChars): void;
+export declare function consumeLetters(chars: TokenizingChars): number;
+export declare function consumeDigits(chars: TokenizingChars): 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/criterion_helpers.d.ts

@@ -0,0 +1,5 @@
+import { EvaluatedDateCriterion } from "../types/generic_criterion";
+import { Locale } from "../types/locale";
+/** 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: EvaluatedDateCriterion, locale: Locale): (number | undefined)[];
+export declare function getDateCriterionFormattedValues(values: string[], locale: Locale): string[];

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

@@ -0,0 +1,19 @@
+import { Position, UID } from "../types/misc";
+type ItemsDic<T> = {
+    [id: number]: T;
+};
+/**
+ * Get the id of the given item (its key in the given dictionary).
+ * If the given item does not exist in the dictionary, it creates one with a new id.
+ */
+export declare function getItemId<T>(item: T, itemsDic: ItemsDic<T>): number;
+export declare function groupItemIdsByZones(positionsByItemId: {
+    [id: number]: Position[];
+}): Record<string, number>;
+export declare function iterateItemIdsPositions(sheetId: UID, itemIdsByZones: Record<string, number>): Generator<readonly [{
+    sheetId: UID;
+    col: import("..").HeaderIndex;
+    row: import("..").HeaderIndex;
+}, number], void, unknown>;
+export declare function getCanonicalRepresentation(item: any): string;
+export {};

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

@@ -0,0 +1,94 @@
+import { CellValue } from "../types/cells";
+import { Format } from "../types/format";
+import { Locale } from "../types/locale";
+/**
+ * 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/expand_range.d.ts

@@ -0,0 +1,8 @@
+import { Position } from "../types/misc";
+export declare function expandXc(xc: string): Iterable<Position>;
+/**
+ * Helper to expand a range string like A1:B3 into all cell references in the range
+ * @param start
+ * @param end
+ */
+export declare function expandRange(start: string, end: string): Generator<Position>;

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

@@ -0,0 +1,30 @@
+import { RangeAdapterFunctions, UID } from "../..";
+import { ChartCreationContext, ChartData, ChartDefinition, ChartType } from "../../types/chart";
+import { CoreGetters } from "../../types/core_getters";
+import { Getters } from "../../types/getters";
+import { Range } from "../../types/range";
+import { Validator } from "../../types/validator";
+export declare class SpreadsheetChart {
+    private readonly getters;
+    readonly sheetId: UID;
+    private readonly definition;
+    private readonly chartTypeBuilder;
+    private readonly dataSourceBuilder;
+    private readonly dataSource;
+    private constructor();
+    static fromStrDefinition(getters: CoreGetters, sheetId: UID, definition: ChartDefinition<string>): SpreadsheetChart;
+    static fromDefinition(getters: CoreGetters, sheetId: UID, definition: ChartDefinition<Range>): SpreadsheetChart;
+    static validate(validator: Validator, definition: ChartDefinition<string>): import("../..").CommandResult | import("../..").CommandResult[];
+    static transformDefinition(chartSheetId: UID, definition: ChartDefinition<string>, rangeAdapters: RangeAdapterFunctions): import("../../types/chart").LineChartDefinition<string> | import("../../types/chart").PieChartDefinition<string> | import("../../types/chart").BarChartDefinition<string> | import("../../types/chart").ScatterChartDefinition<string> | import("../../types/chart/combo_chart").ComboChartDefinition<string> | import("../../types/chart").WaterfallChartDefinition<string> | import("../../types/chart").PyramidChartDefinition<string> | import("../../types/chart/radar_chart").RadarChartDefinition<string> | import("../../types/chart/geo_chart").GeoChartDefinition<string> | import("../../types/chart").FunnelChartDefinition<string> | import("../../types/chart").SunburstChartDefinition<string> | import("../../types/chart/tree_map_chart").TreeMapChartDefinition<string> | import("../../types/chart/calendar_chart").CalendarChartDefinition<string> | import("../../types/chart").ScorecardChartDefinition<string> | import("../../types/chart").GaugeChartDefinition<string>;
+    getSupportedChartTypes(): Set<ChartType>;
+    getRangeDefinition(): ChartDefinition<Range>;
+    getDefinition(): ChartDefinition<string>;
+    updateRanges(rangeAdapters: RangeAdapterFunctions): ChartDefinition<Range>;
+    duplicateInDuplicatedSheet(sheetIdFrom: UID, sheetIdTo: UID): ChartDefinition<string>;
+    copyInSheetId(sheetIdTo: UID): ChartDefinition<Range>;
+    getContextCreation(): ChartCreationContext;
+    getDefinitionForExcel(getters: Getters): import("../..").ExcelChartDefinition | undefined;
+    getData(getters: Getters, chartId: UID): ChartData;
+    getRuntime(getters: Getters, chartId: UID): import("../..").ChartRuntime;
+    static deleteInvalidKeys(definition: ChartDefinition<any>): ChartDefinition<any>;
+}

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

@@ -0,0 +1,4 @@
+import { ChartDefinition } from "../../../types/chart";
+export declare abstract class AbstractChart {
+    static commonKeys: readonly (keyof ChartDefinition)[];
+}

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

@@ -0,0 +1,2 @@
+import { ChartTypeBuilder } from "../../../registries/chart_registry";
+export declare const BarChart: ChartTypeBuilder<"bar">;

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

@@ -0,0 +1,2 @@
+import { ChartTypeBuilder } from "../../../registries/chart_registry";
+export declare const CalendarChart: ChartTypeBuilder<"calendar">;

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

@@ -0,0 +1,63 @@
+import { ChartAxisFormats, ChartDefinitionWithDataSource, ChartRangeDataSource, DataSet, DataSetStyle, DatasetValues, ExcelChartDataset } from "../../../types/chart";
+import { CommandResult } from "../../../types/commands";
+import { CoreGetters } from "../../../types/core_getters";
+import { LocaleFormat } from "../../../types/format";
+import { Getters } from "../../../types/getters";
+import { Locale } from "../../../types/locale";
+import { Color, RangeAdapterFunctions, UID } from "../../../types/misc";
+import { Range } from "../../../types/range";
+import { DOMCoordinates, DOMDimension } from "../../../types/rendering";
+import { ColorGenerator } from "../../color";
+export declare const TREND_LINE_XAXIS_ID = "x1";
+export declare const MOVING_AVERAGE_TREND_LINE_XAXIS_ID = "xMovingAverage";
+export declare const SPREADSHEET_TO_EXCEL_TRENDLINE_TYPE_MAPPING: {
+    readonly exponential: "exp";
+    readonly logarithmic: "log";
+    readonly polynomial: "poly";
+    readonly trailingMovingAverage: "movingAvg";
+};
+/**
+ * This file contains helpers that are common to different charts (mainly
+ * line, bar and pie charts)
+ */
+/**
+ * Duplicate a range. If the range is on the sheetIdFrom, the range will target
+ * sheetIdTo.
+ */
+export declare function duplicateLabelRangeInDuplicatedSheet(sheetIdFrom: UID, sheetIdTo: UID, range?: Range): Range | undefined;
+/**
+ * Adapt a single range of a chart
+ */
+export declare function adaptChartRange(range: Range | undefined, { applyChange }: RangeAdapterFunctions): Range | undefined;
+/**
+ * Create the dataSet objects from xcs
+ */
+export declare function createDataSets(getters: CoreGetters, sheetId: UID, dataSource: ChartRangeDataSource<string>): DataSet[];
+/**
+ * Transform a dataSet to a ExcelDataSet
+ */
+export declare function toExcelDataset(getters: CoreGetters, dataSetStyles: DataSetStyle, ds: DataSet): ExcelChartDataset;
+export declare function toExcelLabelRange(getters: CoreGetters, labelRange: Range | undefined, shouldRemoveFirstLabel?: boolean): string | undefined;
+/**
+ * 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 chartMutedFontColor(backgroundColor: Color | undefined): Color;
+export declare function checkDataset(dataSource: ChartRangeDataSource<string>): CommandResult;
+export declare function checkLabelRange(dataSource: ChartRangeDataSource<string>): CommandResult;
+export declare function shouldRemoveFirstLabel(numberOfLabels: number, numberOfDataPoints: number | undefined, dataSetsHaveTitle: boolean): boolean;
+export declare function getChartPositionAtCenterOfViewport(getters: Getters, chartSize: DOMDimension): DOMCoordinates;
+export declare function getDefinedAxis(definition: Partial<ChartDefinitionWithDataSource<string | Range>>): {
+    useLeftAxis: boolean;
+    useRightAxis: boolean;
+};
+export declare function formatChartDatasetValue(axisFormats: ChartAxisFormats, locale: Locale, humanizeNumbers?: boolean): (value: any, axisId: string) => any;
+export declare function formatTickValue(localeFormat: LocaleFormat, humanizeNumbers?: boolean): (value: any) => any;
+export declare const CHART_AXIS_CHOICES: {
+    value: string;
+    label: string;
+}[];
+export declare function getPieColors(colors: ColorGenerator, dataSetsValues: DatasetValues[]): Color[];
+export declare function truncateLabel(label: string | undefined, maxLen?: number): string;
+export declare function isTrendLineAxis(axisID: string): axisID is "x1" | "xMovingAverage";

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

@@ -0,0 +1,11 @@
+import { ChartDataSourceBuilder } from "../../../registries/chart_data_source_registry";
+import { ChartData, ChartRangeDataSource, DataSet } from "../../../types/chart";
+import { Getters } from "../../../types/getters";
+import { FunctionResultObject } from "../../../types/misc";
+import { Range } from "../../../types/range";
+export declare const ChartRangeDataSourceHandler: ChartDataSourceBuilder<ChartRangeDataSource<string>, ChartRangeDataSource<Range>>;
+export declare function getChartData(getters: Getters, dataSource: ChartRangeDataSource): ChartData;
+/**
+ * Get the data from a dataSet
+ */
+export declare function getData(getters: Getters, ds: DataSet): FunctionResultObject[];

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

@@ -0,0 +1,9 @@
+import { Registry } from "../../../registry";
+import { GlobalChart } from "../../../types/chart/chartjs";
+export declare const chartJsExtensionRegistry: Registry<{
+    register: (chart: GlobalChart) => void;
+    unregister: (chart: GlobalChart) => void;
+}>;
+export declare function areChartJSExtensionsLoaded(): boolean;
+export declare function registerChartJSExtensions(): void;
+export declare function unregisterChartJsExtensions(): void;

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

@@ -0,0 +1,25 @@
+import { DOMDimension } from "../../..";
+import { ChartRuntime, ChartType } from "../../../types/chart";
+import { Figure } from "../../../types/figure";
+export declare const CHART_COMMON_OPTIONS: {
+    responsive: true;
+    maintainAspectRatio: false;
+    elements: {
+        line: {
+            fill: false;
+        };
+        point: {
+            hitRadius: number;
+        };
+    };
+    animation: false;
+    events: ("click" | "mousemove" | "mouseout" | "mouseup" | "touchmove" | "touchstart")[];
+};
+export declare function chartToImageUrl(runtime: ChartRuntime, figure: Figure, type: ChartType): Promise<string | undefined>;
+export declare function chartToImageFile(runtime: ChartRuntime, figure: Figure, type: ChartType): Promise<Blob | null>;
+/**
+ * Draw the given chart on the canvas.
+ *
+ * @returns a cleanup function to be called after the drawing is no longer needed (to free Chart.js resources)
+ */
+export declare function drawChartOnCanvas(canvas: HTMLCanvasElement | OffscreenCanvas, runtime: ChartRuntime, size: DOMDimension, type: ChartType): () => void;

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

@@ -0,0 +1,2 @@
+import { ChartTypeBuilder } from "../../../registries/chart_registry";
+export declare const ComboChart: ChartTypeBuilder<"combo">;

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

@@ -0,0 +1,2 @@
+import { ChartTypeBuilder } from "../../../registries/chart_registry";
+export declare const FunnelChart: ChartTypeBuilder<"funnel">;

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

@@ -0,0 +1,2 @@
+import { ChartTypeBuilder } from "../../../registries/chart_registry";
+export declare const GaugeChart: ChartTypeBuilder<"gauge">;

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

@@ -0,0 +1,45 @@
+import { CanvasSurface } from "../../../types/canvas";
+import { GaugeAnimatedRuntime } from "../../../types/chart";
+import { Color, PixelPosition } from "../../../types/misc";
+import { DOMDimension, Rect } from "../../../types/rendering";
+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_TITLE_SECTION_HEIGHT = 25;
+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: CanvasSurface, runtime: GaugeAnimatedRuntime, zoom?: number, dimensions?: DOMDimension): void;
+export declare function getGaugeRenderingConfig(boundingRect: Rect, runtime: GaugeAnimatedRuntime, ctx: CanvasRenderingContext2D): RenderingParams;
+export {};

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

@@ -0,0 +1,2 @@
+import { ChartTypeBuilder } from "../../../registries/chart_registry";
+export declare const GeoChart: ChartTypeBuilder<"geo">;

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

@@ -0,0 +1,9 @@
+export * from "./abstract_chart";
+export * from "./bar_chart";
+export * from "./chart_common";
+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,2 @@
+import { ChartTypeBuilder } from "../../../registries/chart_registry";
+export declare const LineChart: ChartTypeBuilder<"line">;

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

@@ -0,0 +1,2 @@
+import { ChartTypeBuilder } from "../../../registries/chart_registry";
+export declare const PieChart: ChartTypeBuilder<"pie">;

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

@@ -0,0 +1,2 @@
+import { ChartTypeBuilder } from "../../../registries/chart_registry";
+export declare const PyramidChart: ChartTypeBuilder<"pyramid">;

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

@@ -0,0 +1,2 @@
+import { ChartTypeBuilder } from "../../../registries/chart_registry";
+export declare const RadarChart: ChartTypeBuilder<"radar">;

package/dist/types/helpers/figures/charts/runtime/chart_custom_tooltip.d.ts

@@ -0,0 +1 @@
+export declare function renderToString(templateName: string, context?: any): string;