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

package/dist/types/components/figures/chart/chartJs/zoomable_chart/zoomable_chartjs.d.ts

@@ -0,0 +1,64 @@
+import { ChartJSRuntime } from "../../../../../types/chart/chart";
+import { ChartJsComponent } from "../chartjs";
+export declare class ZoomableChartJsComponent extends ChartJsComponent {
+    static template: string;
+    private store;
+    private masterChartCanvas;
+    private masterChart?;
+    private mode?;
+    private hasLinearScale?;
+    private isBarChart?;
+    private chartId;
+    private datasetBoundaries;
+    private removeEventListeners;
+    private isMasterChartAllowed;
+    setup(): void;
+    protected unmount(): void;
+    get containerStyle(): string;
+    get masterChartContainerStyle(): "" | "opacity: 0.3;";
+    get sliceable(): boolean;
+    get axisOffset(): number;
+    private getMasterChartConfiguration;
+    private getDetailChartConfiguration;
+    private getAxisLimitsFromDataset;
+    private setMasterChartCursor;
+    protected createChart(chartRuntime: ChartJSRuntime): void;
+    protected updateChartJs(chartRuntime: ChartJSRuntime): void;
+    private resetAxesLimits;
+    private updateTrendingLineAxes;
+    get upperBound(): number | undefined;
+    get lowerBound(): number | undefined;
+    private computePosition;
+    private computeCoordinate;
+    /**
+     * Compute min and max from the store, adjusting them if needed for non linear scales.
+     * Getting the value from the store, we have to ensure that the values are integers for
+     * non linear scales (bar and category). To select a bar in the chart, we have to include
+     * the whole bar, which means that for the i-th bar, the selected min should be <= i and
+     * the selected max should be >= i, so using the Math.floor and Math.ceil functions is
+     * the right way to do it.
+     * Sometimes, we can get a minimal value > the maximal value, which arise when the user
+     * select a very small area in the master chart, and hasn't selected the middle of a bar
+     * or a group of bars (in case of more than one data series).
+     * Assuming we have to select the middle of a bar/a groupe of bars, we will reject the
+     * coming value afterward. In this case, we do not update the chart because it would lead
+     * to an empty chart.
+     */
+    private getStoredBoundaries;
+    /**
+     * Adjust the min and max values of an axis if needed for non linear scales.
+     * Here, after rounding (see docstring of getStoredBoundaries), we adjust the min by
+     * substracting the axis offset, and we add it to the max, because when computing from the
+     * scale, chartJs use integer values as the limits for non linear scales. If we have a min
+     * value of 1, it means we want to start displaying from 0.5, and if we have a max value of
+     * 4, it means we want to display until 4.5.
+     * Here, we don't have to check if min > max because we are computing from the scale, and
+     * chartJs ensures that this won't happen, even after our adjustments.
+     */
+    private adjustBoundaries;
+    private updateAxisLimits;
+    onMasterChartPointerDown(ev: PointerEvent): void;
+    updateMasterChartCursor(ev: PointerEvent): void;
+    onMasterChartMouseLeave(ev: PointerEvent): void;
+    onMasterChartDoubleClick(ev: PointerEvent): void;
+}

package/dist/types/components/figures/chart/chartJs/zoomable_chart/zoomable_chartjs_plugins.d.ts

@@ -0,0 +1,12 @@
+import { ChartType, Plugin } from "chart.js";
+interface CurrentAreaPluginOptions {
+    getLowerBound: () => number | undefined;
+    getUpperBound: () => number | undefined;
+}
+export declare const zoomWindowPlugin: Plugin;
+declare module "chart.js" {
+    interface PluginOptionsByType<TType extends ChartType> {
+        zoomWindowPlugin?: CurrentAreaPluginOptions;
+    }
+}
+export {};

package/dist/types/components/figures/chart/chart_dashboard_menu/chart_dashboard_menu.d.ts

@@ -0,0 +1,44 @@
+import { Component } from "@odoo/owl";
+import { UID, ValueAndLabel } from "../../../../types/misc";
+import { SpreadsheetChildEnv } from "../../../../types/spreadsheet_env";
+import { MenuPopover } from "../../../menu_popover/menu_popover";
+import { Select } from "../../../select/select";
+interface Props {
+    chartId: UID;
+    hasFullScreenButton: boolean;
+}
+interface MenuItem {
+    id: string;
+    label: string;
+    class: string;
+    onClick: () => void;
+    preview?: string;
+}
+export declare class ChartDashboardMenu extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static components: {
+        MenuPopover: typeof MenuPopover;
+        Select: typeof Select;
+    };
+    static props: {
+        chartId: StringConstructor;
+        hasFullScreenButton: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+    };
+    static defaultProps: {
+        hasFullScreenButton: boolean;
+    };
+    private fullScreenFigureStore;
+    private menuState;
+    setup(): void;
+    getMenuItems(): MenuItem[];
+    get backgroundColor(): string;
+    openContextMenu(ev: MouseEvent): void;
+    get fullScreenMenuItem(): MenuItem | undefined;
+    get regionOptions(): ValueAndLabel[];
+    get selectedRegion(): string;
+    onRegionSelected(region: string): void;
+}
+export {};

package/dist/types/components/figures/chart/gauge/gauge_chart_component.d.ts

@@ -0,0 +1,41 @@
+import { Component } from "@odoo/owl";
+import { GaugeChartRuntime } from "../../../../types/chart/gauge_chart";
+import { UID } from "../../../../types/misc";
+import { SpreadsheetChildEnv } from "../../../../types/spreadsheet_env";
+interface Props {
+    chartId: UID;
+    isFullScreen?: boolean;
+}
+export declare class GaugeChartComponent extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        chartId: StringConstructor;
+        isFullScreen: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+    };
+    private canvas;
+    private animationStore;
+    get runtime(): GaugeChartRuntime;
+    setup(): void;
+    drawGaugeWithAnimation(): Animation | null;
+    get canvasEl(): HTMLCanvasElement;
+    get animationChartId(): string;
+}
+/**
+ * Animation interpolating values using the ease-out quartic curve function (chartJS default easing)
+ */
+declare class Animation {
+    private startValue;
+    private endValue;
+    private duration;
+    private callback;
+    private startTime;
+    private animationFrameId;
+    constructor(startValue: number, endValue: number, duration: number, callback: (value: number) => void);
+    start(): void;
+    stop(): void;
+    private animate;
+}
+export {};

package/dist/types/components/figures/chart/scorecard/chart_scorecard.d.ts

@@ -0,0 +1,24 @@
+import { Component } from "@odoo/owl";
+import { ScorecardChartRuntime } from "../../../../types/chart/scorecard_chart";
+import { UID } from "../../../../types/misc";
+import { SpreadsheetChildEnv } from "../../../../types/spreadsheet_env";
+interface Props {
+    chartId: UID;
+    isFullScreen?: Boolean;
+}
+export declare class ScorecardChart extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        chartId: StringConstructor;
+        isFullScreen: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+    };
+    private canvas;
+    get runtime(): ScorecardChartRuntime;
+    get title(): string;
+    setup(): void;
+    private createChart;
+}
+export {};

package/dist/types/components/figures/figure/figure.d.ts

@@ -0,0 +1,66 @@
+import { Component } from "@odoo/owl";
+import { FigureUI, ResizeDirection } from "../../../types/figure";
+import { CSSProperties } from "../../../types/misc";
+import { Rect } from "../../../types/rendering";
+import { SpreadsheetChildEnv } from "../../../types/spreadsheet_env";
+import { MenuPopover } from "../../menu_popover/menu_popover";
+type ResizeAnchor = "top left" | "top" | "top right" | "right" | "bottom right" | "bottom" | "bottom left" | "left";
+interface Props {
+    figureUI: FigureUI;
+    style: string;
+    class: string;
+    onMouseDown: (ev: MouseEvent) => void;
+    onClickAnchor(dirX: ResizeDirection, dirY: ResizeDirection, ev: MouseEvent): void;
+}
+export declare class FigureComponent extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        figureUI: ObjectConstructor;
+        style: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        class: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        onMouseDown: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        onClickAnchor: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+    };
+    static components: {
+        MenuPopover: typeof MenuPopover;
+    };
+    static defaultProps: {
+        onMouseDown: () => void;
+        onClickAnchor: () => void;
+    };
+    private menuState;
+    private figureRef;
+    private figureWrapperRef;
+    private menuButtonRef;
+    private borderWidth;
+    get isSelected(): boolean;
+    get figureRegistry(): import("../../..").Registry<import("../../../registries/figures_registry").FigureContent>;
+    private getBorderWidth;
+    getBorderStyle(position: "top" | "right" | "bottom" | "left"): string;
+    get wrapperStyle(): string;
+    getResizerPosition(resizer: ResizeAnchor): string;
+    setup(): void;
+    clickAnchor(dirX: ResizeDirection, dirY: ResizeDirection, ev: MouseEvent): void;
+    onMouseDown(ev: MouseEvent): void;
+    onClick(ev: MouseEvent): void;
+    onKeyDown(ev: KeyboardEvent): void;
+    private postionInBoundary;
+    onContextMenu(ev: MouseEvent): void;
+    showMenu(): void;
+    openContextMenu(anchorRect: Rect): void;
+    editWrapperStyle(properties: CSSProperties): void;
+    get isFigureResizable(): boolean;
+}
+export {};

package/dist/types/components/figures/figure_carousel/figure_carousel.d.ts

@@ -0,0 +1,62 @@
+import { Component } from "@odoo/owl";
+import { Carousel, CarouselItem, FigureUI } from "../../../types/figure";
+import { CSSProperties, MenuMouseEvent } from "../../../types/misc";
+import { Rect } from "../../../types/rendering";
+import { SpreadsheetChildEnv } from "../../../types/spreadsheet_env";
+import { Store } from "../../../types/store_engine";
+import { MenuPopover } from "../../menu_popover/menu_popover";
+import { ChartAnimationStore } from "../chart/chartJs/chartjs_animation_store";
+import { ChartDashboardMenu } from "../chart/chart_dashboard_menu/chart_dashboard_menu";
+interface Props {
+    figureUI: FigureUI;
+    editFigureStyle?: (properties: CSSProperties) => void;
+    isFullScreen?: boolean;
+    openContextMenu?: (anchorRect: Rect, onClose?: () => void) => void;
+}
+export declare class CarouselFigure extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        figureUI: ObjectConstructor;
+        editFigureStyle: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        isFullScreen: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+        openContextMenu: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+    };
+    static components: {
+        ChartDashboardMenu: typeof ChartDashboardMenu;
+        MenuPopover: typeof MenuPopover;
+    };
+    private carouselTabsRef;
+    private carouselTabsDropdownRef;
+    private menuState;
+    private hiddenItems;
+    protected animationStore: Store<ChartAnimationStore> | undefined;
+    private fullScreenFigureStore;
+    setup(): void;
+    get carousel(): Carousel;
+    get selectedCarouselItem(): CarouselItem | undefined;
+    get chartComponent(): new (...args: any) => Component;
+    onCarouselDoubleClick(): void;
+    isItemSelected(item: CarouselItem): boolean;
+    getItemTitle(item: CarouselItem): string;
+    onCarouselTabClick(item: CarouselItem): void;
+    get headerStyle(): string;
+    get title(): string;
+    get titleStyle(): string;
+    private updateTabsVisibility;
+    get menuId(): string;
+    toggleMenu(ev: MenuMouseEvent): void;
+    toggleFullScreen(): void;
+    get fullScreenButtonTitle(): string;
+    get visibleCarouselItems(): CarouselItem[];
+    openContextMenu(event: MouseEvent): void;
+}
+export {};

package/dist/types/components/figures/figure_chart/figure_chart.d.ts

@@ -0,0 +1,39 @@
+import { Component } from "@odoo/owl";
+import { ChartType } from "../../../types/chart/chart";
+import { FigureUI } from "../../../types/figure";
+import { CSSProperties, UID } from "../../../types/misc";
+import { Rect } from "../../../types/rendering";
+import { SpreadsheetChildEnv } from "../../../types/spreadsheet_env";
+import { ChartDashboardMenu } from "../chart/chart_dashboard_menu/chart_dashboard_menu";
+interface Props {
+    figureUI: FigureUI;
+    editFigureStyle?: (properties: CSSProperties) => void;
+    isFullScreen?: boolean;
+    openContextMenu?: (anchorRect: Rect, onClose?: () => void) => void;
+}
+export declare class ChartFigure extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        figureUI: ObjectConstructor;
+        editFigureStyle: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        isFullScreen: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+        openContextMenu: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+    };
+    static components: {
+        ChartDashboardMenu: typeof ChartDashboardMenu;
+    };
+    onDoubleClick(): void;
+    get chartType(): ChartType;
+    get chartId(): UID;
+    get chartComponent(): new (...args: any) => Component;
+}
+export {};

package/dist/types/components/figures/figure_container/figure_container.d.ts

@@ -0,0 +1,122 @@
+import { Component } from "@odoo/owl";
+import { FigureUI, ResizeDirection } from "../../../types/figure";
+import { SpreadsheetChildEnv } from "../../../types/spreadsheet_env";
+import { HFigureAxisType, SnapLine, VFigureAxisType } from "../../helpers/figure_snap_helper";
+import { FigureComponent } from "../figure/figure";
+type ContainerType = "topLeft" | "topRight" | "bottomLeft" | "bottomRight" | "dnd";
+interface Props {
+}
+interface Container {
+    type: ContainerType;
+    figures: FigureUI[];
+    style: string;
+    inverseViewportStyle: string;
+}
+interface Snap<T extends HFigureAxisType | VFigureAxisType> {
+    line: SnapLine<T>;
+    lineStyle: string;
+    containerStyle: string;
+}
+interface DndState {
+    draggedFigure?: FigureUI;
+    horizontalSnap?: Snap<HFigureAxisType>;
+    verticalSnap?: Snap<VFigureAxisType>;
+    cancelDnd: (() => void) | undefined;
+    overlappingCarousel?: FigureUI;
+}
+/**
+ * Each figure ⭐ is positioned inside a container `div` placed and sized
+ * according to the split pane the figure is part of, or a separate container for the figure
+ * currently drag & dropped. Any part of the figure outside of the container is hidden
+ * thanks to its `overflow: hidden` property.
+ *
+ * Additionally, the figure is placed inside a "inverse viewport" `div` 🟥.
+ * Its position represents the viewport position in the grid: its top/left
+ * corner represents the top/left corner of the grid.
+ *
+ * It allows to position the figure inside this div regardless of the
+ * (possibly freezed) viewports and the scrolling position.
+ *
+ * --: container limits
+ * 🟥: inverse viewport
+ * ⭐: figure top/left position
+ *
+ *                     container
+ *                         ↓
+ * |🟥--------------------------------------------
+ * |  \                                          |
+ * |   \                                         |
+ * |    \                                        |
+ * |     \          visible area                 |  no scroll
+ * |      ⭐                                     |
+ * |                                             |
+ * |                                             |
+ * -----------------------------------------------
+ *
+ * the scrolling of the pane is applied as an inverse offset
+ * to the div which will in turn move the figure up and down
+ * inside the container.
+ * Hence, once the figure position is (resp. partly) out of
+ * the container dimensions, it will be (resp. partly) hidden.
+ *
+ * The same reasoning applies to the horizontal axis.
+ *
+ *  🟥 ························
+ *    \                       ↑
+ *     \                      |
+ *      \                     | inverse viewport = -1 * scroll of pane
+ *       \                    |
+ *        ⭐ <- not visible   |
+ *                            ↓
+ * -----------------------------------------------
+ * |                                             |
+ * |                                             |
+ * |                                             |
+ * |               visible area                  |
+ * |                                             |
+ * |                                             |
+ * |                                             |
+ * -----------------------------------------------
+ *
+ * In the case the d&d figure container, the container is the same as the "topLeft" container for
+ * frozen pane (unaffected by scroll and always visible). The figure coordinates are transformed
+ * for this container at the start of the d&d, and transformed back at the end to adapt to the scroll
+ * that occurred during the drag & drop, and to position the figure on the correct pane.
+ *
+ */
+export declare class FiguresContainer extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {};
+    static components: {
+        FigureComponent: typeof FigureComponent;
+    };
+    dnd: DndState;
+    setup(): void;
+    private getVisibleFigures;
+    get containers(): Container[];
+    private getContainerStyle;
+    private rectToCss;
+    private getContainerRect;
+    private getInverseViewportPositionStyle;
+    private getFigureContainer;
+    private toBottomRightViewport;
+    startDraggingFigure(figureUI: FigureUI, ev: MouseEvent): void;
+    /**
+     * Initialize the resize of a figure with mouse movements
+     *
+     * @param dirX X direction of the resize. -1 : resize from the left border of the figure, 0 : no resize in X, 1 :
+     * resize from the right border of the figure
+     * @param dirY Y direction of the resize. -1 : resize from the top border of the figure, 0 : no resize in Y, 1 :
+     * resize from the bottom border of the figure
+     * @param ev Mouse Event
+     */
+    startResize(figureUI: FigureUI, dirX: ResizeDirection, dirY: ResizeDirection, ev: MouseEvent): void;
+    private getOtherFigures;
+    private getDndFigure;
+    getFigureStyle(figureUI: FigureUI): string;
+    getFigureClass(figureUI: FigureUI): string;
+    private getSnap;
+    private getSnapLineStyle;
+    private getCarouselOverlappingChart;
+}
+export {};

package/dist/types/components/figures/figure_image/figure_image.d.ts

@@ -0,0 +1,28 @@
+import { Component } from "@odoo/owl";
+import { FigureUI } from "../../../types/figure";
+import { CSSProperties, UID } from "../../../types/misc";
+import { Rect } from "../../../types/rendering";
+import { SpreadsheetChildEnv } from "../../../types/spreadsheet_env";
+interface Props {
+    figureUI: FigureUI;
+    editFigureStyle?: (properties: CSSProperties) => void;
+    openContextMenu?: (anchorRect: Rect, onClose?: () => void) => void;
+}
+export declare class ImageFigure extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        figureUI: ObjectConstructor;
+        editFigureStyle: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        openContextMenu: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+    };
+    static components: {};
+    get figureId(): UID;
+    get getImagePath(): string;
+}
+export {};

package/dist/types/components/filters/filter_menu/filter_menu.d.ts

@@ -0,0 +1,42 @@
+import { Component } from "@odoo/owl";
+import { PopoverBuilders } from "../../../types/cell_popovers";
+import { Position, SortDirection } from "../../../types/misc";
+import { SpreadsheetChildEnv } from "../../../types/spreadsheet_env";
+import { CriterionFilter } from "../../../types/table";
+import { SidePanelCollapsible } from "../../side_panel/components/collapsible/side_panel_collapsible";
+import { FilterMenuCriterion } from "../filter_menu_criterion/filter_menu_criterion";
+import { FilterMenuValueList } from "../filter_menu_value_list/filter_menu_value_list";
+interface Props {
+    filterPosition: Position;
+    onClosed?: () => void;
+}
+export declare class FilterMenu extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        filterPosition: ObjectConstructor;
+        onClosed: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+    };
+    static components: {
+        FilterMenuValueList: typeof FilterMenuValueList;
+        SidePanelCollapsible: typeof SidePanelCollapsible;
+        FilterMenuCriterion: typeof FilterMenuCriterion;
+    };
+    private criterionCategory;
+    private updatedCriterionValue;
+    setup(): void;
+    get isSortable(): boolean;
+    get table(): import("../../..").Table | undefined;
+    get filterValueType(): "values" | "criterion" | undefined;
+    private getCriterionCategory;
+    onUpdateHiddenValues(values: string[]): void;
+    onCriterionChanged(criterion: CriterionFilter): void;
+    confirm(): void;
+    get criterionOperators(): import("../../..").GenericCriterionType[];
+    cancel(): void;
+    sortFilterZone(sortDirection: SortDirection): void;
+}
+export declare const FilterMenuPopoverBuilder: PopoverBuilders;
+export {};

package/dist/types/components/filters/filter_menu_criterion/filter_menu_criterion.d.ts

@@ -0,0 +1,30 @@
+import { Component, ComponentConstructor } from "@odoo/owl";
+import { GenericCriterionType } from "../../../types/generic_criterion";
+import { Position, ValueAndLabel } from "../../../types/misc";
+import { SpreadsheetChildEnv } from "../../../types/spreadsheet_env";
+import { CriterionFilter } from "../../../types/table";
+import { Select } from "../../select/select";
+interface Props {
+    filterPosition: Position;
+    criterionOperators: GenericCriterionType[];
+    onCriterionChanged: (criterion: CriterionFilter) => void;
+}
+export declare class FilterMenuCriterion extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        filterPosition: ObjectConstructor;
+        onCriterionChanged: FunctionConstructor;
+        criterionOperators: ArrayConstructor;
+    };
+    static components: {
+        Select: typeof Select;
+    };
+    private state;
+    setup(): void;
+    private getFilterCriterionValue;
+    get criterionOptions(): ValueAndLabel[];
+    get criterionComponent(): ComponentConstructor | undefined;
+    onCriterionChanged(criterion: CriterionFilter): void;
+    onCriterionTypeChange(type: CriterionFilter["type"]): void;
+}
+export {};

package/dist/types/components/filters/filter_menu_item/filter_menu_value_item.d.ts

@@ -0,0 +1,32 @@
+import { Component } from "@odoo/owl";
+import { SpreadsheetChildEnv } from "../../../types/spreadsheet_env";
+import { Checkbox } from "../../side_panel/components/checkbox/checkbox";
+interface Props {
+    value: string;
+    isChecked: boolean;
+    isSelected: boolean;
+    onClick: () => void;
+    onMouseMove: () => void;
+    scrolledTo: "top" | "bottom" | undefined;
+}
+export declare class FilterMenuValueItem extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static components: {
+        Checkbox: typeof Checkbox;
+    };
+    static props: {
+        value: StringConstructor;
+        isChecked: BooleanConstructor;
+        isSelected: BooleanConstructor;
+        onMouseMove: FunctionConstructor;
+        onClick: FunctionConstructor;
+        scrolledTo: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+    };
+    private itemRef;
+    setup(): void;
+    private scrollListToSelectedValue;
+}
+export {};

package/dist/types/components/filters/filter_menu_value_list/filter_menu_value_list.d.ts

@@ -0,0 +1,41 @@
+import { Component } from "@odoo/owl";
+import { Position } from "../../../types/misc";
+import { SpreadsheetChildEnv } from "../../../types/spreadsheet_env";
+import { FilterMenuValueItem } from "../filter_menu_item/filter_menu_value_item";
+interface Props {
+    filterPosition: Position;
+    onUpdateHiddenValues: (values: string[]) => void;
+}
+interface Value {
+    checked: boolean;
+    string: string;
+    scrolledTo?: "top" | "bottom" | undefined;
+}
+export declare class FilterMenuValueList extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        filterPosition: ObjectConstructor;
+        onUpdateHiddenValues: FunctionConstructor;
+    };
+    static components: {
+        FilterMenuValueItem: typeof FilterMenuValueItem;
+    };
+    private state;
+    private searchBar;
+    setup(): void;
+    private getFilterHiddenValues;
+    checkValue(value: Value): void;
+    onMouseMove(value: Value): void;
+    private getSearchedValues;
+    setAllChecked(checked: boolean): void;
+    selectAll(): void;
+    clearAll(): void;
+    updateHiddenValues(): void;
+    updateSearch(ev: Event): void;
+    computeDisplayedValues(): void;
+    loadMoreValues(): void;
+    onKeyDown(ev: KeyboardEvent): void;
+    clearScrolledToValue(): void;
+    private scrollListToSelectedValue;
+}
+export {};

package/dist/types/components/focus_store.d.ts

@@ -0,0 +1,6 @@
+export declare class FocusStore {
+    mutators: readonly ["focus", "unfocus"];
+    focusedElement: object | null;
+    focus(element: object): void;
+    unfocus(element: object): void;
+}