@odoo/o-spreadsheet 19.5.0-alpha.2 → 19.5.0-alpha.20

package/dist/types/registries/chart_registry.d.ts

@@ -1,8 +1,8 @@
 import { CoreChartOptions } from "chart.js";
+import { ColorThemeName, CompiledFormula } from "..";
 import { ChartCreationContext, ChartData, ChartRuntime, ChartType, ChartTypeDefinition, ExcelChartDefinition } from "../types/chart/chart";
 import { CommandResult } from "../types/commands";
-import { CoreGetters } from "../types/core_getters";
-import { Getters } from "../types/getters";
+import { CoreGetters, EvaluationGetters } from "../types/getters";
 import { RangeAdapterFunctions, UID } from "../types/misc";
 import { Range } from "../types/range";
 import { Validator } from "../types/validator";
@@ -45,11 +45,14 @@ export interface ChartTypeBuilder<T extends ChartType> {
      * Get the definition of the chart used for excel export.
      * If the chart is not supported by Excel, this function returns undefined.
      */
-    getDefinitionForExcel(getters: Getters, definition: ChartTypeDefinition<T, Range>, params: Pick<ExcelChartDefinition, "dataSets" | "labelRange">): ExcelChartDefinition | undefined;
-    getRuntime(getters: Getters, definition: ChartTypeDefinition<T, Range>, chartDataExtractors: ChartDataExtractors, sheetId: UID, eventHandlers: ChartJsEventHandlers): ChartRuntime;
+    getDefinitionForExcel(getters: EvaluationGetters, definition: ChartTypeDefinition<T, Range>, params: Pick<ExcelChartDefinition, "dataSets" | "labelRange">): ExcelChartDefinition | undefined;
+    getRuntime(getters: EvaluationGetters, definition: ChartTypeDefinition<T, Range>, chartDataExtractors: ChartDataExtractors, sheetId: UID, eventHandlers: ChartJsEventHandlers, colorThemeName: ColorThemeName): ChartRuntime;
+    /** Get all the formulas used in the chart */
+    getFormulas(getters: CoreGetters, sheetId: UID, definition: ChartTypeDefinition<T, Range>): CompiledFormula[];
     allowedDefinitionKeys: readonly string[];
     sequence: number;
     dataSeriesLimit?: number;
+    loadDataForExport?: (getters: EvaluationGetters) => Promise<void>;
 }
 interface ChartDataExtractors {
     extractData(): ChartData;

package/dist/types/registries/criterion_registry.d.ts

@@ -1,6 +1,6 @@
 import { CellValue } from "../types/cells";
 import { EvaluatedCriterion, GenericCriterion, GenericCriterionType } from "../types/generic_criterion";
-import { Getters } from "../types/getters";
+import { EvaluationGetters } from "../types/getters";
 import { UID } from "../types/misc";
 import { Range } from "../types/range";
 import { Registry } from "./registry";
@@ -20,13 +20,13 @@ export type CriterionEvaluator<T = unknown> = {
      * For more complex criteria (like "top10"), we might want to pre-compute some data before evaluating the criterion for
      * each cell, to avoid recomputing everything each time.
      */
-    preComputeCriterion?: (criterion: GenericCriterion, criterionRanges: Range[], getters: Getters) => T;
+    preComputeCriterion?: (criterion: GenericCriterion, criterionRanges: Range[], getters: EvaluationGetters) => T;
     /**
      * Returns the error string to display when the value is not valid.
      *
      * The criterion values should be in canonical form (non-localized), and formulas should be evaluated.
      */
-    getErrorString: (criterion: EvaluatedCriterion, getters: Getters, sheetId: UID) => string;
+    getErrorString: (criterion: EvaluatedCriterion, getters: EvaluationGetters, sheetId: UID) => string;
     /**
      * Checks if a criterion value is valid.
      *
@@ -36,7 +36,7 @@ export type CriterionEvaluator<T = unknown> = {
     /** Return the number of values that the criterion must contains. Return undefined if the criterion can have any number of values */
     numberOfValues: (criterion: GenericCriterion) => number | undefined;
     name: string;
-    getPreview: (criterion: GenericCriterion, getters: Getters) => string;
+    getPreview: (criterion: GenericCriterion, getters: EvaluationGetters) => string;
     /** Error string when a criterion value is invalid */
     criterionValueErrorString: string;
     allowedValues?: "onlyLiterals" | "onlyFormulas";

package/dist/types/registries/data_source_registry.d.ts

@@ -0,0 +1,15 @@
+import { Model } from "../model";
+import { Getters } from "../types/getters";
+import { UID } from "../types/misc";
+import { Registry } from "./registry";
+export interface UnusedDataSource {
+    label: string;
+    id: UID;
+}
+export interface DataSourceType {
+    type: string;
+    unusedLabel: string;
+    getUnusedInstances: (getters: Getters) => UnusedDataSource[];
+    deleteDataSource: (dispatch: Model["dispatch"], id: UID) => void;
+}
+export declare const unusedDataSourceRegistry: Registry<DataSourceType>;

package/dist/types/registries/evaluation_registry.d.ts

@@ -1,4 +1,4 @@
-import { Getters } from "../types/getters";
+import { EvaluationGetters } from "../types/getters";
 import { Registry } from "./registry";
 /**
  * This registry is used to register functions that should be called after each iteration of the evaluation.
@@ -6,4 +6,4 @@ import { Registry } from "./registry";
  * to avoid to reload the data of the pivot at each function call (PIVOT.VALUE and PIVOT.HEADER). After each
  * evaluation iteration, the pivot has to be re-evaluated during the next iteration.
  */
-export declare const onIterationEndEvaluationRegistry: Registry<(getters: Getters) => void>;
+export declare const onIterationEndEvaluationRegistry: Registry<(getters: EvaluationGetters) => void>;

package/dist/types/registries/figures_registry.d.ts

@@ -1,4 +1,5 @@
 import { Action } from "../actions/action";
+import { Getters } from "../types/getters";
 import { UID } from "../types/misc";
 import { SpreadsheetChildEnv } from "../types/spreadsheet_env";
 import { Registry } from "./registry";
@@ -11,9 +12,12 @@ import { Registry } from "./registry";
 export interface FigureContent {
     Component: any;
     menuBuilder: (figureId: UID, env: SpreadsheetChildEnv) => Action[];
+    isThemeDependant: boolean;
     SidePanelComponent?: string;
     keepRatio?: boolean;
-    minFigSize?: number;
-    borderWidth?: number;
+    minFigSize: number;
+    borderWidth: (getters: Getters) => number;
+    hasShadow: (getters: Getters) => boolean;
+    isRounded: (getters: Getters) => boolean;
 }
 export declare const figureRegistry: Registry<FigureContent>;

package/dist/types/store_engine/dependency_container.d.ts

@@ -9,6 +9,10 @@ interface StoreUpdateEvent {
 export declare class DependencyContainer extends EventBus<StoreUpdateEvent> {
     private dependencies;
     private factory;
+    private parent?;
+    /** If the dependency container has a parent, those are the store that will be owned by this container instead of its parent */
+    private ownStores;
+    constructor(parent?: DependencyContainer, extendedStores?: StoreConstructor[]);
     /**
      * Injects a store instance in the dependency container.
      * Useful for injecting an external store that is not created by the container.
@@ -22,5 +26,6 @@ export declare class DependencyContainer extends EventBus<StoreUpdateEvent> {
     instantiate<T>(Store: StoreConstructor<T>, ...args: StoreParams<StoreConstructor<T>>): T;
     resetStores(): void;
     dispose(): void;
+    trigger(type: StoreUpdateEvent["type"], payload?: Omit<StoreUpdateEvent, "type">): void;
 }
 export {};

package/dist/types/store_engine/store_hooks.d.ts

@@ -1,8 +1,14 @@
 import { LocalStoreConstructor, Store, StoreConstructor, StoreParams } from "../types/store_engine";
+import { DependencyContainer } from "./dependency_container";
 /**
  * This hook should be used at the root of your app to provide the store container.
  */
 export declare function useStoreProvider(): any;
+/**
+ * This create a new store dependency container. The store given in the extended store array will be owned by this
+ * new container, the other stores will be owned by the parent container.
+ */
+export declare function useChildStoreProvider(extendedStores: StoreConstructor[]): DependencyContainer;
 /**
  * Get the instance of a store.
  */

package/dist/types/store_engine/store_registries.d.ts

@@ -0,0 +1,4 @@
+import { Registry } from "../registries/registry";
+import { SpreadsheetStore } from "../stores/spreadsheet_store";
+import { StoreConstructor } from "../types/store_engine";
+export declare const globalStores: Registry<StoreConstructor<SpreadsheetStore, any[]>>;

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

@@ -3,7 +3,7 @@ import { Get } from "../types/store_engine";
 import { HighlightStore } from "./highlight_store";
 import { SpreadsheetStore } from "./spreadsheet_store";
 export declare class ArrayFormulaHighlight extends SpreadsheetStore {
-    protected highlightStore: import("../types/store_engine").CQS<Pick<HighlightStore, "register" | "unRegister"> & import("../types/store_engine").OmitFunctions<HighlightStore>>;
+    protected highlightStore: import("../types/store_engine").Store<HighlightStore>;
     constructor(get: Get);
     get highlights(): Highlight[];
 }

package/dist/types/{plugins/ui_feature/automatic_sum.d.ts → stores/automatic_sum_store.d.ts}

@@ -1,14 +1,15 @@
-import { Command } from "../../types/commands";
-import { Position, UID, Zone } from "../../types/misc";
-import { UIPlugin } from "../ui_plugin";
+import { Command } from "../types/commands";
+import { Position, UID, Zone } from "../types/misc";
+import { SpreadsheetStore } from "./spreadsheet_store";
 interface AutomaticSum {
     position: Position;
     zone: Zone;
 }
-export declare class AutomaticSumPlugin extends UIPlugin {
+export declare class AutomaticSumStore extends SpreadsheetStore {
     static getters: readonly ["getAutomaticSums"];
     handle(cmd: Command): void;
     getAutomaticSums(sheetId: UID, zone: Zone, anchor: Position): AutomaticSum[];
+    get automaticSumsOnMainSelectedZone(): AutomaticSum[];
     private sumData;
     private sumAdjacentData;
     /**

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

@@ -0,0 +1,15 @@
+import { PositionMap } from "../helpers/cells/position_map";
+import { CellPosition, Color } from "../types/misc";
+import { SpreadsheetStore } from "./spreadsheet_store";
+export interface CellHoverOverlayProvider {
+    getHighlightedPositions: (hoveredPosition: CellPosition) => CellPosition[];
+}
+export declare class CellHoverOverlayStore extends SpreadsheetStore {
+    mutators: readonly ["hover", "register", "unRegister"];
+    storeGetters: readonly ["getCellHoverOverlayColor"];
+    private providers;
+    overlayColors: PositionMap<Color>;
+    hover(hoveredPosition: CellPosition | undefined): "noStateChange" | undefined;
+    register(highlightProvider: CellHoverOverlayProvider): void;
+    unRegister(highlightProvider: CellHoverOverlayProvider): void;
+}

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

@@ -0,0 +1,10 @@
+import { UID } from "../types/misc";
+/**
+ * Holds the id of the figure that a dragged chart suggestion is currently
+ * hovering over, so it can be highlighted reactively instead of through direct DOM manipulation.
+ */
+export declare class ChartDragStore {
+    mutators: readonly ["setHighlightedFigure"];
+    highlightedFigureId: UID | undefined;
+    setHighlightedFigure(figureId: UID | undefined): void;
+}

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

@@ -0,0 +1,9 @@
+import { Command } from "../types/commands";
+import { Zone } from "../types/misc";
+import { SpreadsheetStore } from "./spreadsheet_store";
+export declare class CheckboxToggleStore extends SpreadsheetStore {
+    storeGetters: readonly ["hasBooleanValidationInZones"];
+    handle(cmd: Command): void;
+    hasBooleanValidationInZones(zones: Zone[]): boolean;
+    private toggleCheckbox;
+}

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

@@ -5,6 +5,7 @@ export declare class ClientFocusStore extends SpreadsheetStore {
     mutators: readonly ["focusClient", "unfocusClient", "showClientTag", "hideClientTag", "jumpToClient"];
     private _showClientTag;
     private clientFocusTimeout;
+    private viewStore;
     constructor(get: Get);
     get focusedClients(): Set<ClientId>;
     jumpToClient(clientId: ClientId): void;

package/dist/types/{plugins/ui_stateful/clipboard.d.ts → stores/clipboard_store.d.ts}

@@ -1,25 +1,25 @@
-import { OSClipboardContent } from "../../types/clipboard";
-import { Command, CommandResult, LocalCommand } from "../../types/commands";
-import { GridRenderingContext } from "../../types/rendering";
-import { UIPlugin, UIPluginConfig } from "../ui_plugin";
+import { OSClipboardContent } from "../types/clipboard";
+import { Command, DispatchResult } from "../types/commands";
+import { GridRenderingContext } from "../types/rendering";
+import { SpreadsheetStore } from "./spreadsheet_store";
 export declare const MAX_FILE_SIZE: number;
 /**
- * Clipboard Plugin
+ * Clipboard Store
  *
  * This clipboard manages all cut/copy/paste interactions internal to the
  * application, and with the OS clipboard as well.
  */
-export declare class ClipboardPlugin extends UIPlugin {
-    static layers: readonly ["Clipboard"];
-    static getters: readonly ["getClipboardTextAndImageContent", "getClipboardId", "getClipboardTextContent", "isCutOperation"];
+export declare class ClipboardStore extends SpreadsheetStore {
+    storeGetters: readonly ["getClipboardTextAndImageContent", "getClipboardId", "getClipboardTextContent", "isCutOperation", "isCommandValid"];
     private status;
     private originSheetId?;
     private copiedData?;
     private _isCutOperation;
     private clipboardId;
-    private fileStore?;
-    constructor(config: UIPluginConfig);
-    allowDispatch(cmd: LocalCommand): CommandResult;
+    private notificationStore;
+    get renderingLayers(): readonly ["Clipboard"];
+    isCommandValid(cmd: Command): DispatchResult;
+    private getCommandResult;
     handle(cmd: Command): void;
     private getCopiedDataAbove;
     private getCopiedDataOnLeft;

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

@@ -0,0 +1,31 @@
+import { CancelledReason, Command } from "../types/commands";
+import { Get } from "../types/store_engine";
+import { SpreadsheetStore } from "./spreadsheet_store";
+export declare class DataCleanupStore extends SpreadsheetStore {
+    mutators: readonly ["setHasHeader", "setColumns", "toggleAllColumns", "toggleColumn"];
+    private notificationStore;
+    hasHeader: boolean;
+    columns: {
+        [colIndex: number]: boolean;
+    };
+    constructor(get: Get);
+    private updateColumns;
+    setHasHeader(hasHeader: boolean): void;
+    setColumns(columns: {
+        [colIndex: number]: boolean;
+    }): void;
+    toggleAllColumns(): void;
+    toggleColumn(colIndex: number): void;
+    private get isEveryColumnSelected();
+    get removeDuplicateErrors(): CancelledReason[];
+    handle(cmd: Command): void;
+    private removeDuplicates;
+    private getUniqueRowsIndexes;
+    private notifyRowsRemovedAndRemaining;
+    private checkSingleRangeSelected;
+    private checkNoMergeInZone;
+    private checkRangeContainsValues;
+    private checkNoColumnProvided;
+    private checkColumnsIncludedInZone;
+    private getColsToAnalyze;
+}

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

@@ -8,8 +8,9 @@ export declare const CELL_BACKGROUND_GRIDLINE_STROKE_STYLE = "#111";
 export declare const CELL_ANIMATION_DURATION = 200;
 export declare class GridRenderer extends DisposableStore {
     private renderer;
+    storeGetters: readonly ["drawLayer"];
     private fingerprints;
-    private hoveredTables;
+    private cellHoverOverlayStore;
     private hoveredIcon;
     private lastRenderSheetId;
     private lastRenderBoxes;
@@ -17,7 +18,7 @@ export declare class GridRenderer extends DisposableStore {
     private zonesWithPreventedAnimationsInNextFrame;
     private animations;
     protected getters: RenderingGetters;
-    constructor(get: Get, renderer?: Store<RendererStore>);
+    constructor(get: Get, renderer?: Store<RendererStore> | null);
     handle(cmd: Command): void;
     finalize(): void;
     get renderingLayers(): readonly ["Background", "Headers"];

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

@@ -0,0 +1,14 @@
+import { Command } from "../types/commands";
+import { Get } from "../types/store_engine";
+import { SpreadsheetStore } from "./spreadsheet_store";
+/**
+ * The goal of this store is to make its attached viewport store follow the active sheet
+ */
+export declare class MainViewportStore extends SpreadsheetStore {
+    private viewStore;
+    private sheetIdAtFinalize;
+    constructor(get: Get);
+    private handleEvent;
+    protected handle(cmd: Command): void;
+    protected finalize(): void;
+}

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

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

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

@@ -0,0 +1,6 @@
+import { Command, DispatchResult, ResizeTableCommand } from "../types/commands";
+import { SpreadsheetStore } from "./spreadsheet_store";
+export declare class TableResizeStore extends SpreadsheetStore {
+    canResizeTable(cmd: ResizeTableCommand): DispatchResult;
+    handle(cmd: Command): void;
+}

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

@@ -0,0 +1,9 @@
+import { Command } from "../types/commands";
+import { SpreadsheetStore } from "./spreadsheet_store";
+export declare class TrimWhitespaceStore extends SpreadsheetStore {
+    mutators: readonly ["trimWhitespace"];
+    private notificationStore;
+    trimWhitespace(): void;
+    handle(cmd: Command): void;
+    private _trimWhitespace;
+}

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

@@ -0,0 +1,85 @@
+import { CellPosition, FigureUI, HeaderDimensions, HeaderIndex, Pixel, SheetViewDimensions, UID, ViewportsGetters, Zone } from "..";
+import { ViewportCollection } from "../helpers/viewport_collection";
+import { Command } from "../types/commands";
+import { DOMCoordinates, DOMDimension, Rect, SheetDOMScrollInfo, Viewport } from "../types/rendering";
+import { Get } from "../types/store_engine";
+import { SpreadsheetStore } from "./spreadsheet_store";
+type getHeaderDimensionsCallback = (sheetId: UID, dimension: "COL" | "ROW", index: number) => HeaderDimensions;
+/**
+ * Viewport store.
+ *
+ * This store manages all things related to all viewport states.
+ *
+ */
+export declare class ViewportsStore extends SpreadsheetStore {
+    mutators: readonly ["setViewportOffset", "resizeSheetView", "shiftViewportDown", "shiftViewportUp", "scrollToCell", "setDisplayedSheetId", "setViewportArgs", "rebuildViewports"];
+    private zoomStore;
+    private getHeaderDimensionsCallback;
+    private getFooterSizeCallback;
+    private getZoomLevelCallback;
+    private zoneToDisplay;
+    viewports: ViewportCollection;
+    private sheetsWithDirtyViewports;
+    displayedSheetId: UID;
+    constructor(get: Get);
+    handle(cmd: Command): void;
+    finalize(): void;
+    private setViewports;
+    private syncPaneDivision;
+    setDisplayedSheetId(sheetId: UID): void;
+    setViewportOffset(offset: {
+        offsetX: Pixel;
+        offsetY: Pixel;
+    }): "noStateChange" | undefined;
+    resizeSheetView(dimensions: SheetViewDimensions): "noStateChange" | undefined;
+    shiftViewportDown(): void;
+    shiftViewportUp(): void;
+    scrollToCell(sheetId: UID, col: HeaderIndex, row: HeaderIndex): void;
+    get sheetViewDimensionWithHeaders(): DOMDimension;
+    get sheetViewDimension(): DOMDimension;
+    get gridOffset(): DOMCoordinates;
+    /** type as pane, not viewport but basically pane extends viewport */
+    get activeMainViewport(): Viewport;
+    /**
+     * Return the DOM scroll info of the active sheet, ie. the offset between the viewport left/top side and
+     * the grid left/top side, corresponding to the scroll of the scrollbars and not snapped to the grid.
+     */
+    get activeSheetScrollInfo(): SheetDOMScrollInfo;
+    get visibleCols(): HeaderIndex[];
+    get visibleRows(): HeaderIndex[];
+    /**
+     * Get the positions of all the cells that are visible in the viewport, taking merges into account.
+     */
+    get visibleCellPositions(): CellPosition[];
+    /**
+     * Return the main viewport maximum size relative to the client size.
+     */
+    get mainViewportRect(): Rect;
+    get maximumSheetOffset(): {
+        maxOffsetX: Pixel;
+        maxOffsetY: Pixel;
+    };
+    /**
+     * Returns the position of the MainViewport relatively to the start of the grid (without headers)
+     * It corresponds to the summed dimensions of the visible cols/rows (in x/y respectively)
+     * situated before the pane divisions.
+     */
+    get mainViewportCoordinates(): DOMCoordinates;
+    get visibleFigures(): FigureUI[];
+    /**
+     * Shift the viewport vertically and move the selection anchor
+     * such that it remains at the same place relative to the
+     * viewport top.
+     */
+    private shiftVertically;
+    private getPaneDivisions;
+    private getFooterSize;
+    setViewportArgs(args: {
+        getHeaderDimensions?: getHeaderDimensionsCallback;
+        getFooterSize?: () => Pixel;
+        zoneToDisplay?: Zone;
+    }): void;
+    rebuildViewports(): void;
+    buildViewportGetters(getHeaderDimensions: (sheetId: UID, dimension: "COL" | "ROW", index: number) => HeaderDimensions): ViewportsGetters;
+}
+export {};

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

@@ -0,0 +1,27 @@
+import { ZoomedMouseEvent } from "../components/helpers/zoom";
+import { Pixel } from "../types/misc";
+import { DOMCoordinates, Rect } from "../types/rendering";
+/**
+ * Holds the zoom level of the spreadsheet UI, and everything derived purely from it.
+ */
+export declare class ZoomStore {
+    mutators: readonly ["setZoom"];
+    storeGetters: readonly ["getZoomedRect", "getZoomedEvent"];
+    zoomLevel: number;
+    setZoom(zoom: number): "noStateChange" | undefined;
+    getZoomedRect(rect: Rect): Rect;
+    /**
+     * Return a POJO containing the original event as well as the client position and the client offset
+     * where the event would target if the spreadsheet was not zoomed
+     * @param ev unzoomed mouse event
+     * @param originalTargetPosition The original target bounding rect the resulting ZoomedMouseEvent offset must refer to
+     * @returns a ZoomedMouseEvent
+     */
+    getZoomedEvent<T extends MouseEvent>(ev: T, originalTargetPosition?: DOMCoordinates | null): ZoomedMouseEvent<T>;
+    /**
+     * Returns the bounding rect of the closest or self element who is targetable by a ZoomedMouseEvent
+     */
+    private getZoomTargetPosition;
+    get scrollBarWidth(): Pixel;
+    get cssZoom(): string;
+}

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

@@ -24,7 +24,7 @@ import { BubbleChartDefinition, BubbleChartRuntime, BubbleColorMode } from "./bu
 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>;
+export type ChartDefinition<T extends string | Range = string> = ChartDefinitionWithDataSource<T> | ScorecardChartDefinition | GaugeChartDefinition<T> | BubbleChartDefinition<T>;
 /**
  * `ChartTypeDefinition<"bar", Range>`
  * `ChartTypeDefinition<"bar", string>`
@@ -203,6 +203,8 @@ export interface ChartCreationContext {
     readonly bubbleColorMode?: BubbleColorMode;
     readonly annotationText?: string;
     readonly annotationLink?: string;
+    readonly scorecardKeyValueFormula?: string;
+    readonly scorecardBaselineFormula?: string;
 }
 export type ChartAxisFormats = {
     [axisId: string]: Format | undefined;

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

@@ -0,0 +1,137 @@
+import { ChartDefinition, ChartRangeDataSource } from "./chart";
+export interface Suggestion<T> {
+    description: string;
+    /** Defaults to always-applicable. */
+    isApplicable?: (ctx: T) => boolean;
+    build: (ctx: T) => ChartDefinition;
+}
+/** Pattern A — Single numeric column */
+export interface SingleNumberContext {
+    title: string;
+    source: ChartRangeDataSource<string>;
+    rowCount: number;
+    firstCellXC: string;
+    lastCellXC: string;
+    prevCellXC?: string;
+}
+/** Pattern B — Single percentage column */
+export interface SinglePercentageContext {
+    title: string;
+    source: ChartRangeDataSource<string>;
+    rowCount: number;
+    firstCellXC: string;
+    lastCellXC: string;
+    prevCellXC?: string;
+    isAboveOne: boolean;
+}
+/** Pattern C — Single date column */
+export interface SingleDateContext {
+    title: string;
+    lastCellXC: string;
+    rowCount: number;
+    source: ChartRangeDataSource<string>;
+}
+/** Pattern D — Single categorical column */
+export interface SingleCategoricalContext {
+    title: string;
+    source: ChartRangeDataSource<string>;
+    range: string;
+}
+/** Pattern E — Single label column */
+export interface SingleLabelContext {
+    title: string;
+    lastCellXC: string;
+    rowCount: number;
+}
+/** Pattern F — Categorical + Number */
+export interface CategoricalVsNumberContext {
+    title: string;
+    source: ChartRangeDataSource<string>;
+    treemapSource: ChartRangeDataSource<string>;
+}
+/** Patterns G & J — Date + Number or Date + Percentage */
+export interface DateVsSeriesContext {
+    title: string;
+    source: ChartRangeDataSource<string>;
+    isPercentage: boolean;
+}
+/** Pattern H — Number + Number */
+export interface NumberVsNumberContext {
+    title: string;
+    source2: ChartRangeDataSource<string>;
+    sourceBoth: ChartRangeDataSource<string>;
+    rowCount1: number;
+    rowCount2: number;
+    lastCellXC: string;
+    prevCellXC?: string;
+}
+/** Pattern I — Categorical + Percentage */
+export interface CategoricalVsPercentageContext {
+    title: string;
+    source: ChartRangeDataSource<string>;
+    rowCount: number;
+}
+/** Pattern K — Label + Number */
+export interface LabelVsNumberContext {
+    title: string;
+    source: ChartRangeDataSource<string>;
+    rowCount: number;
+    lastCellXC: string;
+    prevCellXC?: string;
+}
+/** Pattern M — Categorical + Multiple Numbers */
+export interface CategoricalVsMultipleNumbersContext {
+    title: string;
+    source: ChartRangeDataSource<string>;
+    rowCount: number;
+}
+/** Pattern N — Date + Multiple Numbers */
+export interface DateVsMultipleNumbersContext {
+    title: string;
+    source: ChartRangeDataSource<string>;
+}
+/** Pattern O — Categorical + Categorical + Number */
+export interface MultipleCategoricalsVsNumberContext {
+    title: string;
+    hierarchySource: ChartRangeDataSource<string>;
+    barSource: ChartRangeDataSource<string>;
+}
+/** Pattern P — Categorical + Date + Number */
+export interface CategoricalDateNumberContext {
+    title: string;
+    sourceByDate: ChartRangeDataSource<string>;
+    sourceByCat: ChartRangeDataSource<string>;
+}
+/** Pattern Q — Label + Multiple Numbers */
+export interface LabelVsMultipleNumbersContext {
+    title: string;
+    source: ChartRangeDataSource<string>;
+    rowCount: number;
+    numColsCount: number;
+    /** Always defined: this rule only fires with >= 2 numeric columns (open-ended shape, min 3 total). */
+    scatterSource: ChartRangeDataSource<string>;
+    /** Only defined when numColsCount === 3 (Bubble Chart's isApplicable guards its use). */
+    bubble?: {
+        xRange: string;
+        yRanges: string[];
+        sizeRange: string;
+        labelRange: string;
+        headerInZone: boolean;
+    };
+}
+/** Pattern R — Categorical + Two Numbers (Population Pyramid or Grouped) */
+export interface CategoricalTwoNumbersContext {
+    title: string;
+    sourceBoth: ChartRangeDataSource<string>;
+    isPyramid: boolean;
+}
+/** Pattern S — Many Numbers (3+ numeric columns, no categorical/date) */
+export interface ManyNumbersContext {
+    title: string;
+    source: ChartRangeDataSource<string>;
+    colsLength: number;
+    rowCount: number;
+    lastCellXC: string;
+    firstCellXC: string;
+    secondCellXC: string;
+}

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

@@ -10,7 +10,7 @@ export interface RadarChartDefinition<T extends string | Range = Range> extends
     readonly humanize?: boolean;
 }
 export type RadarChartRuntime = {
-    chartJsConfig: ChartConfiguration;
+    chartJsConfig: ChartConfiguration<"radar">;
     customizableSeries: {
         dataSetId: string;
         label: string;