@odoo/o-spreadsheet 19.2.11 → 19.4.0-alpha.4

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

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

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

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

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

@@ -0,0 +1,131 @@
+/*!
+ * chartjs-chart-treemap v3.1.0
+ * https://chartjs-chart-treemap.pages.dev/
+ * (c) 2024 Jukka Kurkela
+ * Released under the MIT license
+ */
+import { Color, CoreChartOptions, DatasetController, Element, FontSpec, Scriptable, ScriptableContext, VisualElement } from "chart.js";
+import { TreeMapGroupColor } from "./tree_map_chart";
+type AnyObject = Record<string, unknown>;
+type TreemapScriptableContext = ScriptableContext<"treemap"> & {
+    raw: TreemapDataPoint;
+};
+type TreemapControllerDatasetCaptionsOptions = {
+    align?: Scriptable<LabelAlign, TreemapScriptableContext>;
+    color?: Scriptable<Color, TreemapScriptableContext>;
+    display?: boolean;
+    formatter?: Scriptable<string, TreemapScriptableContext>;
+    font?: FontSpec;
+    hoverColor?: Scriptable<Color, TreemapScriptableContext>;
+    hoverFont?: FontSpec;
+    padding?: number;
+};
+type TreemapControllerDatasetLabelsOptions = {
+    align?: Scriptable<LabelAlign, TreemapScriptableContext>;
+    color?: Scriptable<Color | Color[], TreemapScriptableContext>;
+    display?: boolean;
+    formatter?: Scriptable<string | Array<string>, TreemapScriptableContext>;
+    font?: Scriptable<FontSpec | FontSpec[], TreemapScriptableContext>;
+    hoverColor?: Scriptable<Color | Color[], TreemapScriptableContext>;
+    hoverFont?: Scriptable<FontSpec | FontSpec[], TreemapScriptableContext>;
+    overflow?: Scriptable<LabelOverflow, TreemapScriptableContext>;
+    padding?: number;
+    position?: Scriptable<LabelPosition, TreemapScriptableContext>;
+};
+export type LabelPosition = "top" | "middle" | "bottom";
+export type LabelAlign = "left" | "center" | "right";
+export type LabelOverflow = "cut" | "hidden" | "fit";
+type TreemapControllerDatasetDividersOptions = {
+    display?: boolean;
+    lineCapStyle?: string;
+    lineColor?: string;
+    lineDash?: number[];
+    lineDashOffset?: number;
+    lineWidth?: number;
+};
+export interface TreemapControllerDatasetOptions<DType> {
+    spacing?: number;
+    rtl?: boolean;
+    backgroundColor?: Scriptable<Color, TreemapScriptableContext>;
+    borderColor?: Scriptable<Color, TreemapScriptableContext>;
+    borderWidth?: number;
+    hoverBackgroundColor?: Scriptable<Color, TreemapScriptableContext>;
+    hoverBorderColor?: Scriptable<Color, TreemapScriptableContext>;
+    hoverBorderWidth?: number;
+    captions?: TreemapControllerDatasetCaptionsOptions;
+    dividers?: TreemapControllerDatasetDividersOptions;
+    labels?: TreemapControllerDatasetLabelsOptions;
+    label?: string;
+    data: TreemapDataPoint[];
+    groups?: Array<keyof DType>;
+    sumKeys?: Array<keyof DType>;
+    tree: number[] | DType[] | AnyObject;
+    treeLeafKey?: keyof DType;
+    key?: keyof DType;
+    hidden?: boolean;
+    displayMode?: "containerBoxes" | "headerBoxes";
+    groupColors?: TreeMapGroupColor[];
+}
+export interface TreemapDataPoint {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    /**
+     * Value
+     */
+    v: number;
+    /**
+     * Sum
+     */
+    s: number;
+    /**
+     * Depth, only available if grouping
+     */
+    l?: number;
+    /**
+     * Group name, only available if grouping
+     */
+    g?: string;
+    /**
+     * Group Sum, only available if grouping
+     */
+    gs?: number;
+    /**
+     * additonal keys sums, only available if grouping
+     */
+    vs?: AnyObject;
+    isLeaf?: boolean;
+}
+declare module "chart.js" {
+    interface ChartTypeRegistry {
+        treemap: {
+            chartOptions: CoreChartOptions<"treemap">;
+            datasetOptions: TreemapControllerDatasetOptions<Record<string, unknown>>;
+            defaultDataPoint: TreemapDataPoint;
+            metaExtensions: AnyObject;
+            parsedDataType: unknown;
+            scales: never;
+        };
+    }
+}
+export interface TreemapOptions {
+    backgroundColor: Color;
+    borderColor: Color;
+    borderWidth: number | {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    };
+}
+export interface TreemapConfig {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export type TreemapController = DatasetController;
+export interface TreemapElement<T extends TreemapConfig = TreemapConfig, O extends TreemapOptions = TreemapOptions> extends Element<T, O>, VisualElement {
+}
+export {};

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

@@ -0,0 +1,22 @@
+import { ChartConfiguration } from "chart.js";
+import { UID } from "../misc";
+import { Range } from "../range";
+import { CustomizedDataSet } from "./chart";
+import { CommonChartDefinition } from "./common_chart";
+export interface ComboChartDefinition<T extends string | Range = Range> extends CommonChartDefinition<T> {
+    readonly dataSetStyles: ComboChartDataSetStyle;
+    readonly type: "combo";
+    readonly hideDataMarkers?: boolean;
+    readonly zoomable?: boolean;
+}
+export type ComboChartDataSetStyle = Record<UID, CustomizedDataSet & {
+    type?: "bar" | "line";
+}>;
+export type ComboChartRuntime = {
+    chartJsConfig: ChartConfiguration;
+    masterChartConfig?: ChartConfiguration;
+    customizableSeries: {
+        dataSetId: string;
+        label: string;
+    }[];
+};

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

@@ -0,0 +1,22 @@
+import { Color } from "../misc";
+import { Range } from "../range";
+import { AxesDesign, ChartDataSource, DataSetStyle, TitleDesign } from "./chart";
+export type VerticalAxisPosition = "left" | "right";
+export type LegendPosition = "top" | "bottom" | "left" | "right" | "none";
+export interface CommonChartDefinition<T extends string | Range = Range> {
+    readonly dataSetStyles: DataSetStyle;
+    readonly dataSource: ChartDataSource<T>;
+    readonly title: TitleDesign;
+    readonly background?: Color;
+    readonly legendPosition: LegendPosition;
+    readonly aggregated?: boolean;
+    readonly axesDesign?: AxesDesign;
+    readonly showValues?: boolean;
+    readonly humanize?: boolean;
+}
+export interface NonDataSourceBaseChartDefinition {
+    readonly title: TitleDesign;
+    readonly background?: Color;
+    readonly humanize?: boolean;
+    readonly dataSource?: undefined;
+}

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

@@ -0,0 +1,24 @@
+import { ChartConfiguration } from "chart.js";
+import { Color } from "../misc";
+import { Range } from "../range";
+import { AxesDesign, ChartDataSource, DataSetStyle, TitleDesign } from "./chart";
+import { LegendPosition } from "./common_chart";
+export interface FunnelChartDefinition<T extends string | Range = Range> {
+    readonly type: "funnel";
+    readonly dataSetStyles: DataSetStyle;
+    readonly dataSource: ChartDataSource<T>;
+    readonly title: TitleDesign;
+    readonly background?: Color;
+    readonly legendPosition: LegendPosition;
+    readonly horizontal?: boolean;
+    readonly axesDesign?: AxesDesign;
+    readonly aggregated?: boolean;
+    readonly showValues?: boolean;
+    readonly funnelColors?: FunnelChartColors;
+    readonly cumulative?: boolean;
+    readonly humanize?: boolean;
+}
+export type FunnelChartRuntime = {
+    chartJsConfig: ChartConfiguration;
+};
+export type FunnelChartColors = (Color | undefined)[];

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

@@ -0,0 +1,86 @@
+import type { ChartOptions } from "chart.js";
+import { Color } from "../misc";
+import { Range } from "../range";
+import { TitleDesign } from "./chart";
+import { NonDataSourceBaseChartDefinition } from "./common_chart";
+export interface GaugeChartDefinition<T extends string | Range = string> extends NonDataSourceBaseChartDefinition {
+    readonly type: "gauge";
+    readonly dataRange?: T;
+    readonly sectionRule: SectionRule;
+}
+export interface SectionRule {
+    readonly colors: ColorSet;
+    readonly rangeMin: string;
+    readonly rangeMax: string;
+    readonly lowerInflectionPoint: SectionThreshold;
+    readonly upperInflectionPoint: SectionThreshold;
+}
+interface ColorSet {
+    readonly lowerColor: Color;
+    readonly middleColor: Color;
+    readonly upperColor: Color;
+}
+export interface SectionThreshold {
+    readonly type: "number" | "percentage";
+    readonly value: string;
+    readonly operator: "<" | "<=";
+}
+export interface GaugeValue {
+    value: number;
+    label: string;
+}
+export interface GaugeInflectionValue extends GaugeValue {
+    operator: "<" | "<=";
+}
+export interface GaugeChartRuntime {
+    background: Color;
+    title: TitleDesign;
+    minValue: GaugeValue;
+    maxValue: GaugeValue;
+    gaugeValue?: GaugeValue;
+    inflectionValues: GaugeInflectionValue[];
+    colors: Color[];
+}
+export interface GaugeAnimatedRuntime extends GaugeChartRuntime {
+    animationValue?: number;
+}
+export interface GaugeChartOptions extends ChartOptions {
+    needle?: NeedleOptions;
+    valueLabel?: ValueLabelOptions;
+    inflectionValues: InflectionValuesOptions[];
+    minValue: string;
+    maxValue: string;
+}
+export interface NeedleOptions {
+    display?: boolean;
+    borderColor?: Color;
+    backgroundColor?: Color;
+    /**
+     * Needle width as the percentage of the chart area width
+     */
+    width?: number;
+}
+export interface InflectionValuesOptions {
+    value: number;
+    color: Color;
+    label: string;
+}
+export interface ValueLabelOptions {
+    display?: boolean;
+    formatter?: (value: any) => string;
+    font?: {
+        size?: number;
+        family?: string;
+        color?: Color;
+    };
+    backgroundColor?: Color;
+    borderColor?: Color;
+    borderRadius?: number;
+    padding?: {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    };
+}
+export {};

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

@@ -0,0 +1,26 @@
+import { ChartConfiguration } from "chart.js";
+import { Color } from "../misc";
+import { Range } from "../range";
+import { ChartColorScale, ChartRuntimeGenerationArgs } from "./chart";
+import { CommonChartDefinition } from "./common_chart";
+export interface GeoChartDefinition<T extends string | Range = Range> extends CommonChartDefinition<T> {
+    readonly type: "geo";
+    readonly colorScale?: ChartColorScale;
+    readonly missingValueColor?: Color;
+    readonly region?: string;
+    readonly showColorBar?: boolean;
+}
+export type GeoChartRuntime = {
+    chartJsConfig: ChartConfiguration;
+};
+export type GeoChartProjection = "azimuthalEqualArea" | "azimuthalEquidistant" | "gnomonic" | "orthographic" | "stereographic" | "equalEarth" | "albers" | "albersUsa" | "conicConformal" | "conicEqualArea" | "conicEquidistant" | "equirectangular" | "mercator" | "transverseMercator" | "naturalEarth1";
+export interface GeoChartRegion {
+    id: string;
+    label: string;
+    defaultProjection: GeoChartProjection;
+}
+export interface GeoChartRuntimeGenerationArgs extends ChartRuntimeGenerationArgs {
+    availableRegions: GeoChartRegion[];
+    getGeoJsonFeatures: (region: string) => GeoJSON.Feature[] | undefined;
+    geoFeatureNameToId: (region: string, featureName: string) => string | undefined;
+}

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

@@ -0,0 +1,21 @@
+import type { ChartConfiguration } from "chart.js";
+import { Range } from "../range";
+import { CommonChartDefinition } from "./common_chart";
+export interface LineChartDefinition<T extends string | Range = Range> extends CommonChartDefinition<T> {
+    readonly type: "line";
+    readonly labelsAsText: boolean;
+    readonly stacked: boolean;
+    readonly aggregated?: boolean;
+    readonly cumulative: boolean;
+    readonly fillArea?: boolean;
+    readonly hideDataMarkers?: boolean;
+    readonly zoomable?: boolean;
+}
+export type LineChartRuntime = {
+    chartJsConfig: ChartConfiguration<"line">;
+    masterChartConfig?: ChartConfiguration<"line">;
+    customizableSeries: {
+        dataSetId: string;
+        label: string;
+    }[];
+};

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

@@ -0,0 +1,15 @@
+import type { ChartConfiguration } from "chart.js";
+import { Color } from "../misc";
+import { Range } from "../range";
+import { CommonChartDefinition } from "./common_chart";
+export interface PieChartDefinition<T extends string | Range = Range> extends CommonChartDefinition<T> {
+    readonly type: "pie";
+    readonly slicesColors?: Color[];
+    readonly aggregated?: boolean;
+    readonly isDoughnut?: boolean;
+    readonly showValues?: boolean;
+    readonly pieHolePercentage?: number;
+}
+export type PieChartRuntime = {
+    chartJsConfig: ChartConfiguration<"pie" | "doughnut">;
+};

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

@@ -0,0 +1,13 @@
+import { ChartConfiguration } from "chart.js";
+import { Range } from "../range";
+import { BarChartDefinition } from "./bar_chart";
+export interface PyramidChartDefinition<T extends string | Range = Range> extends Omit<BarChartDefinition<T>, "type" | "zoomable"> {
+    readonly type: "pyramid";
+}
+export type PyramidChartRuntime = {
+    chartJsConfig: ChartConfiguration;
+    customizableSeries: {
+        dataSetId: string;
+        label: string;
+    }[];
+};

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

@@ -0,0 +1,18 @@
+import { ChartConfiguration } from "chart.js";
+import { Range } from "../range";
+import { CommonChartDefinition } from "./common_chart";
+export interface RadarChartDefinition<T extends string | Range = Range> extends CommonChartDefinition<T> {
+    readonly type: "radar";
+    readonly aggregated?: boolean;
+    readonly stacked: boolean;
+    readonly fillArea?: boolean;
+    readonly hideDataMarkers?: boolean;
+    readonly humanize?: boolean;
+}
+export type RadarChartRuntime = {
+    chartJsConfig: ChartConfiguration;
+    customizableSeries: {
+        dataSetId: string;
+        label: string;
+    }[];
+};

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

@@ -0,0 +1,6 @@
+import { Range } from "../range";
+import { LineChartDefinition, LineChartRuntime } from "./line_chart";
+export interface ScatterChartDefinition<T extends string | Range = Range> extends Omit<LineChartDefinition<T>, "type" | "stacked" | "cumulative" | "zoomable" | "hideDataMarkers"> {
+    readonly type: "scatter";
+}
+export type ScatterChartRuntime = Omit<LineChartRuntime, "masterChartConfig">;

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

@@ -0,0 +1,36 @@
+import { Color, Style } from "../misc";
+import { Range } from "../range";
+import { TitleDesign } from "./chart";
+import { NonDataSourceBaseChartDefinition } from "./common_chart";
+export interface ScorecardChartDefinition<T extends string | Range = string> extends NonDataSourceBaseChartDefinition {
+    readonly type: "scorecard";
+    readonly keyValue?: T;
+    readonly keyDescr?: TitleDesign;
+    readonly baseline?: T;
+    readonly baselineMode: BaselineMode;
+    readonly baselineDescr?: TitleDesign;
+    readonly baselineColorUp: Color;
+    readonly baselineColorDown: Color;
+}
+export type BaselineMode = "text" | "difference" | "percentage" | "progress";
+export type BaselineArrowDirection = "neutral" | "up" | "down";
+export interface ProgressBar {
+    readonly value: number;
+    readonly color: Color;
+}
+export interface ScorecardChartRuntime {
+    readonly title: TitleDesign;
+    readonly keyValue: string;
+    readonly keyDescr: string;
+    readonly baselineDisplay: string;
+    readonly baselineColor?: string;
+    readonly baselineArrow: BaselineArrowDirection;
+    readonly baselineDescr?: string;
+    readonly background: Color;
+    readonly fontColor: Color;
+    readonly keyValueStyle?: Style;
+    readonly keyValueDescrStyle?: Style;
+    readonly baselineStyle?: Style;
+    readonly baselineDescrStyle?: Style;
+    readonly progressBar?: ProgressBar;
+}