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

package/dist/types/components/standalone_grid_canvas/carousel_data_view_print.d.ts

@@ -0,0 +1,32 @@
+import { Component } from "../../owl3_compatibility_layer";
+import { GridRenderer } from "../../stores/grid_renderer_store";
+import { ViewportsStore } from "../../stores/viewports_store";
+import { GridRenderingContext } from "../../types/rendering";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+import { Store } from "../../types/store_engine";
+export declare class CarouselDataViewPrint extends Component<SpreadsheetChildEnv> {
+    static template: string;
+    props: import("@odoo/owl").Props<{
+        range: import("../..").Range;
+        rect: {
+            x: import("../..").Pixel;
+            y: import("../..").Pixel;
+            width: import("../..").Pixel;
+            height: import("../..").Pixel;
+        };
+        rendererStore: {
+            readonly register: (renderer: import("../../stores/renderer_store").Renderer) => void;
+            readonly unRegister: (renderer: import("../../stores/renderer_store").Renderer) => void;
+            readonly draw: (context?: GridRenderingContext | undefined, timestamp?: number | undefined) => void;
+            readonly startAnimation: (animationId: string) => void;
+            readonly stopAnimation: (animationId: string) => void;
+            readonly mutators: readonly ["register", "unRegister", "draw", "startAnimation", "stopAnimation"];
+        };
+        columnWeights?: number[] | undefined;
+    }>;
+    viewportsStore: Store<ViewportsStore>;
+    gridRender: Store<GridRenderer>;
+    setup(): void;
+    get renderingLayers(): readonly ["Chart"];
+    drawLayer(renderingContext: GridRenderingContext): void;
+}

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

@@ -1,27 +1,422 @@
 import { Component } from "../../owl3_compatibility_layer";
 import { RendererStore } from "../../stores/renderer_store";
+import { PropsOf } from "../../types/props_of";
 import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
 import { Store } from "../../types/store_engine";
+import { CarouselDataViewPrint } from "./carousel_data_view_print";
 import { FigureRendererStore } from "./figure_renderer_store";
 export declare class StandaloneGridCanvas extends Component<SpreadsheetChildEnv> {
     static template: string;
+    static components: {
+        CarouselDataViewPrint: typeof CarouselDataViewPrint;
+    };
     protected props: import("@odoo/owl").Props<{
         sheetId: import("../..").UID;
         zone: import("../..").Zone;
         renderingCtx: {
             sheetId: import("../..").UID;
             hideGridLines?: boolean | undefined;
-            selectedZones: import("../..").Zone[];
             viewports: import("../../helpers/viewport_collection").ViewportCollection;
+            selectedZones: import("../..").Zone[];
             dpr: number;
+            hideFrozenPaneBorder?: boolean | undefined;
             activeCols: Set<number>;
             activeRows: Set<number>;
             activePosition: import("../..").CellPosition | undefined;
         };
+        canvas: {
+            height: number;
+            width: number;
+            captureStream: (frameRequestRate?: number) => MediaStream;
+            getContext: {
+                (contextId: "2d", options?: CanvasRenderingContext2DSettings): CanvasRenderingContext2D | null;
+                (contextId: "bitmaprenderer", options?: ImageBitmapRenderingContextSettings): ImageBitmapRenderingContext | null;
+                (contextId: "webgl", options?: WebGLContextAttributes): WebGLRenderingContext | null;
+                (contextId: "webgl2", options?: WebGLContextAttributes): WebGL2RenderingContext | null;
+                (contextId: string, options?: any): RenderingContext | null;
+            };
+            toBlob: (callback: BlobCallback, type?: string, quality?: number) => void;
+            toDataURL: (type?: string, quality?: number) => string;
+            transferControlToOffscreen: () => OffscreenCanvas;
+            addEventListener: {
+                <K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLCanvasElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+            };
+            removeEventListener: {
+                <K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLCanvasElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+            };
+            accessKey: string;
+            readonly accessKeyLabel: string;
+            autocapitalize: string;
+            autocorrect: boolean;
+            dir: string;
+            draggable: boolean;
+            hidden: boolean | "until-found";
+            inert: boolean;
+            innerText: string;
+            lang: string;
+            readonly offsetHeight: number;
+            readonly offsetLeft: number;
+            readonly offsetParent: Element | null;
+            readonly offsetTop: number;
+            readonly offsetWidth: number;
+            outerText: string;
+            popover: string | null;
+            spellcheck: boolean;
+            title: string;
+            translate: boolean;
+            writingSuggestions: string;
+            attachInternals: () => ElementInternals;
+            click: () => void;
+            hidePopover: () => void;
+            showPopover: (options?: ShowPopoverOptions) => void;
+            togglePopover: (options?: TogglePopoverOptions | boolean) => boolean;
+            readonly attributes: NamedNodeMap;
+            classList: DOMTokenList;
+            className: string;
+            readonly clientHeight: number;
+            readonly clientLeft: number;
+            readonly clientTop: number;
+            readonly clientWidth: number;
+            readonly currentCSSZoom: number;
+            readonly customElementRegistry: CustomElementRegistry | null;
+            id: string;
+            innerHTML: string;
+            readonly localName: string;
+            readonly namespaceURI: string | null;
+            onfullscreenchange: ((this: Element, ev: Event) => any) | null;
+            onfullscreenerror: ((this: Element, ev: Event) => any) | null;
+            outerHTML: string;
+            readonly ownerDocument: Document;
+            part: DOMTokenList;
+            readonly prefix: string | null;
+            readonly scrollHeight: number;
+            scrollLeft: number;
+            scrollTop: number;
+            readonly scrollWidth: number;
+            readonly shadowRoot: ShadowRoot | null;
+            slot: string;
+            readonly tagName: string;
+            attachShadow: (init: ShadowRootInit) => ShadowRoot;
+            checkVisibility: (options?: CheckVisibilityOptions) => boolean;
+            closest: {
+                <K extends keyof HTMLElementTagNameMap>(selector: K): HTMLElementTagNameMap[K] | null;
+                <K extends keyof SVGElementTagNameMap>(selector: K): SVGElementTagNameMap[K] | null;
+                <K extends keyof MathMLElementTagNameMap>(selector: K): MathMLElementTagNameMap[K] | null;
+                <E extends Element = Element>(selectors: string): E | null;
+            };
+            computedStyleMap: () => StylePropertyMapReadOnly;
+            getAttribute: (qualifiedName: string) => string | null;
+            getAttributeNS: (namespace: string | null, localName: string) => string | null;
+            getAttributeNames: () => string[];
+            getAttributeNode: (qualifiedName: string) => Attr | null;
+            getAttributeNodeNS: (namespace: string | null, localName: string) => Attr | null;
+            getBoundingClientRect: () => DOMRect;
+            getClientRects: () => DOMRectList;
+            getElementsByClassName: (classNames: string) => HTMLCollectionOf<Element>;
+            getElementsByTagName: {
+                <K extends keyof HTMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementTagNameMap[K]>;
+                <K extends keyof SVGElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<SVGElementTagNameMap[K]>;
+                <K extends keyof MathMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<MathMLElementTagNameMap[K]>;
+                <K extends keyof HTMLElementDeprecatedTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementDeprecatedTagNameMap[K]>;
+                (qualifiedName: string): HTMLCollectionOf<Element>;
+            };
+            getElementsByTagNameNS: {
+                (namespaceURI: "http://www.w3.org/1999/xhtml", localName: string): HTMLCollectionOf<HTMLElement>;
+                (namespaceURI: "http://www.w3.org/2000/svg", localName: string): HTMLCollectionOf<SVGElement>;
+                (namespaceURI: "http://www.w3.org/1998/Math/MathML", localName: string): HTMLCollectionOf<MathMLElement>;
+                (namespace: string | null, localName: string): HTMLCollectionOf<Element>;
+            };
+            getHTML: (options?: GetHTMLOptions) => string;
+            hasAttribute: (qualifiedName: string) => boolean;
+            hasAttributeNS: (namespace: string | null, localName: string) => boolean;
+            hasAttributes: () => boolean;
+            hasPointerCapture: (pointerId: number) => boolean;
+            insertAdjacentElement: (where: InsertPosition, element: Element) => Element | null;
+            insertAdjacentHTML: (position: InsertPosition, string: string) => void;
+            insertAdjacentText: (where: InsertPosition, data: string) => void;
+            matches: {
+                <K extends keyof HTMLElementTagNameMap>(selectors: K): this is HTMLElementTagNameMap[K];
+                <K extends keyof SVGElementTagNameMap>(selectors: K): this is SVGElementTagNameMap[K];
+                <K extends keyof MathMLElementTagNameMap>(selectors: K): this is MathMLElementTagNameMap[K];
+                (selectors: string): boolean;
+            };
+            releasePointerCapture: (pointerId: number) => void;
+            removeAttribute: (qualifiedName: string) => void;
+            removeAttributeNS: (namespace: string | null, localName: string) => void;
+            removeAttributeNode: (attr: Attr) => Attr;
+            requestFullscreen: (options?: FullscreenOptions) => Promise<void>;
+            requestPointerLock: (options?: PointerLockOptions) => Promise<void>;
+            scroll: {
+                (options?: ScrollToOptions): void;
+                (x: number, y: number): void;
+            };
+            scrollBy: {
+                (options?: ScrollToOptions): void;
+                (x: number, y: number): void;
+            };
+            scrollIntoView: (arg?: boolean | ScrollIntoViewOptions) => void;
+            scrollTo: {
+                (options?: ScrollToOptions): void;
+                (x: number, y: number): void;
+            };
+            setAttribute: (qualifiedName: string, value: string) => void;
+            setAttributeNS: (namespace: string | null, qualifiedName: string, value: string) => void;
+            setAttributeNode: (attr: Attr) => Attr | null;
+            setAttributeNodeNS: (attr: Attr) => Attr | null;
+            setHTMLUnsafe: (html: string) => void;
+            setPointerCapture: (pointerId: number) => void;
+            toggleAttribute: (qualifiedName: string, force?: boolean) => boolean;
+            webkitMatchesSelector: (selectors: string) => boolean;
+            textContent: string;
+            readonly baseURI: string;
+            readonly childNodes: NodeListOf<ChildNode>;
+            readonly firstChild: ChildNode | null;
+            readonly isConnected: boolean;
+            readonly lastChild: ChildNode | null;
+            readonly nextSibling: ChildNode | null;
+            readonly nodeName: string;
+            readonly nodeType: number;
+            nodeValue: string | null;
+            readonly parentElement: HTMLElement | null;
+            readonly parentNode: ParentNode | null;
+            readonly previousSibling: ChildNode | null;
+            appendChild: <T extends Node>(node: T) => T;
+            cloneNode: (subtree?: boolean) => Node;
+            compareDocumentPosition: (other: Node) => number;
+            contains: (other: Node | null) => boolean;
+            getRootNode: (options?: GetRootNodeOptions) => Node;
+            hasChildNodes: () => boolean;
+            insertBefore: <T extends Node>(node: T, child: Node | null) => T;
+            isDefaultNamespace: (namespace: string | null) => boolean;
+            isEqualNode: (otherNode: Node | null) => boolean;
+            isSameNode: (otherNode: Node | null) => boolean;
+            lookupNamespaceURI: (prefix: string | null) => string | null;
+            lookupPrefix: (namespace: string | null) => string | null;
+            normalize: () => void;
+            removeChild: <T extends Node>(child: T) => T;
+            replaceChild: <T extends Node>(node: Node, child: T) => T;
+            readonly ELEMENT_NODE: 1;
+            readonly ATTRIBUTE_NODE: 2;
+            readonly TEXT_NODE: 3;
+            readonly CDATA_SECTION_NODE: 4;
+            readonly ENTITY_REFERENCE_NODE: 5;
+            readonly ENTITY_NODE: 6;
+            readonly PROCESSING_INSTRUCTION_NODE: 7;
+            readonly COMMENT_NODE: 8;
+            readonly DOCUMENT_NODE: 9;
+            readonly DOCUMENT_TYPE_NODE: 10;
+            readonly DOCUMENT_FRAGMENT_NODE: 11;
+            readonly NOTATION_NODE: 12;
+            readonly DOCUMENT_POSITION_DISCONNECTED: 1;
+            readonly DOCUMENT_POSITION_PRECEDING: 2;
+            readonly DOCUMENT_POSITION_FOLLOWING: 4;
+            readonly DOCUMENT_POSITION_CONTAINS: 8;
+            readonly DOCUMENT_POSITION_CONTAINED_BY: 16;
+            readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: 32;
+            dispatchEvent: (event: Event) => boolean;
+            ariaActiveDescendantElement: Element | null;
+            ariaAtomic: string | null;
+            ariaAutoComplete: string | null;
+            ariaBrailleLabel: string | null;
+            ariaBrailleRoleDescription: string | null;
+            ariaBusy: string | null;
+            ariaChecked: string | null;
+            ariaColCount: string | null;
+            ariaColIndex: string | null;
+            ariaColIndexText: string | null;
+            ariaColSpan: string | null;
+            ariaControlsElements: ReadonlyArray<Element> | null;
+            ariaCurrent: string | null;
+            ariaDescribedByElements: ReadonlyArray<Element> | null;
+            ariaDescription: string | null;
+            ariaDetailsElements: ReadonlyArray<Element> | null;
+            ariaDisabled: string | null;
+            ariaErrorMessageElements: ReadonlyArray<Element> | null;
+            ariaExpanded: string | null;
+            ariaFlowToElements: ReadonlyArray<Element> | null;
+            ariaHasPopup: string | null;
+            ariaHidden: string | null;
+            ariaInvalid: string | null;
+            ariaKeyShortcuts: string | null;
+            ariaLabel: string | null;
+            ariaLabelledByElements: ReadonlyArray<Element> | null;
+            ariaLevel: string | null;
+            ariaLive: string | null;
+            ariaModal: string | null;
+            ariaMultiLine: string | null;
+            ariaMultiSelectable: string | null;
+            ariaOrientation: string | null;
+            ariaOwnsElements: ReadonlyArray<Element> | null;
+            ariaPlaceholder: string | null;
+            ariaPosInSet: string | null;
+            ariaPressed: string | null;
+            ariaReadOnly: string | null;
+            ariaRelevant: string | null;
+            ariaRequired: string | null;
+            ariaRoleDescription: string | null;
+            ariaRowCount: string | null;
+            ariaRowIndex: string | null;
+            ariaRowIndexText: string | null;
+            ariaRowSpan: string | null;
+            ariaSelected: string | null;
+            ariaSetSize: string | null;
+            ariaSort: string | null;
+            ariaValueMax: string | null;
+            ariaValueMin: string | null;
+            ariaValueNow: string | null;
+            ariaValueText: string | null;
+            role: string | null;
+            animate: (keyframes: Keyframe[] | PropertyIndexedKeyframes | null, options?: number | KeyframeAnimationOptions) => Animation;
+            getAnimations: (options?: GetAnimationsOptions) => Animation[];
+            after: (...nodes: (Node | string)[]) => void;
+            before: (...nodes: (Node | string)[]) => void;
+            remove: () => void;
+            replaceWith: (...nodes: (Node | string)[]) => void;
+            readonly nextElementSibling: Element | null;
+            readonly previousElementSibling: Element | null;
+            readonly childElementCount: number;
+            readonly children: HTMLCollection;
+            readonly firstElementChild: Element | null;
+            readonly lastElementChild: Element | null;
+            append: (...nodes: (Node | string)[]) => void;
+            moveBefore: (node: Node, child: Node | null) => void;
+            prepend: (...nodes: (Node | string)[]) => void;
+            querySelector: {
+                <K extends keyof HTMLElementTagNameMap>(selectors: K): HTMLElementTagNameMap[K] | null;
+                <K extends keyof SVGElementTagNameMap>(selectors: K): SVGElementTagNameMap[K] | null;
+                <K extends keyof MathMLElementTagNameMap>(selectors: K): MathMLElementTagNameMap[K] | null;
+                <K extends keyof HTMLElementDeprecatedTagNameMap>(selectors: K): HTMLElementDeprecatedTagNameMap[K] | null;
+                <E extends Element = Element>(selectors: string): E | null;
+            };
+            querySelectorAll: {
+                <K extends keyof HTMLElementTagNameMap>(selectors: K): NodeListOf<HTMLElementTagNameMap[K]>;
+                <K extends keyof SVGElementTagNameMap>(selectors: K): NodeListOf<SVGElementTagNameMap[K]>;
+                <K extends keyof MathMLElementTagNameMap>(selectors: K): NodeListOf<MathMLElementTagNameMap[K]>;
+                <K extends keyof HTMLElementDeprecatedTagNameMap>(selectors: K): NodeListOf<HTMLElementDeprecatedTagNameMap[K]>;
+                <E extends Element = Element>(selectors: string): NodeListOf<E>;
+            };
+            replaceChildren: (...nodes: (Node | string)[]) => void;
+            readonly assignedSlot: HTMLSlotElement | null;
+            readonly attributeStyleMap: StylePropertyMap;
+            style: CSSStyleDeclaration;
+            contentEditable: string;
+            enterKeyHint: string;
+            inputMode: string;
+            readonly isContentEditable: boolean;
+            onabort: ((this: GlobalEventHandlers, ev: UIEvent) => any) | null;
+            onanimationcancel: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
+            onanimationend: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
+            onanimationiteration: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
+            onanimationstart: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
+            onauxclick: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+            onbeforeinput: ((this: GlobalEventHandlers, ev: InputEvent) => any) | null;
+            onbeforematch: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onbeforetoggle: ((this: GlobalEventHandlers, ev: ToggleEvent) => any) | null;
+            onblur: ((this: GlobalEventHandlers, ev: FocusEvent) => any) | null;
+            oncancel: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            oncanplay: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            oncanplaythrough: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onclick: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+            onclose: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            oncommand: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            oncontextlost: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            oncontextmenu: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+            oncontextrestored: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            oncopy: ((this: GlobalEventHandlers, ev: ClipboardEvent) => any) | null;
+            oncuechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            oncut: ((this: GlobalEventHandlers, ev: ClipboardEvent) => any) | null;
+            ondblclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+            ondrag: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+            ondragend: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+            ondragenter: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+            ondragleave: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+            ondragover: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+            ondragstart: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+            ondrop: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+            ondurationchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onemptied: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onended: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onerror: OnErrorEventHandler;
+            onfocus: ((this: GlobalEventHandlers, ev: FocusEvent) => any) | null;
+            onformdata: ((this: GlobalEventHandlers, ev: FormDataEvent) => any) | null;
+            ongotpointercapture: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+            oninput: ((this: GlobalEventHandlers, ev: InputEvent) => any) | null;
+            oninvalid: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onkeydown: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
+            onkeypress: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
+            onkeyup: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
+            onload: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onloadeddata: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onloadedmetadata: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onloadstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onlostpointercapture: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+            onmousedown: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+            onmouseenter: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+            onmouseleave: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+            onmousemove: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+            onmouseout: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+            onmouseover: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+            onmouseup: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+            onpaste: ((this: GlobalEventHandlers, ev: ClipboardEvent) => any) | null;
+            onpause: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onplay: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onplaying: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onpointercancel: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+            onpointerdown: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+            onpointerenter: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+            onpointerleave: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+            onpointermove: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+            onpointerout: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+            onpointerover: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+            onpointerrawupdate: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onpointerup: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+            onprogress: ((this: GlobalEventHandlers, ev: ProgressEvent) => any) | null;
+            onratechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onreset: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onresize: ((this: GlobalEventHandlers, ev: UIEvent) => any) | null;
+            onscroll: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onscrollend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onsecuritypolicyviolation: ((this: GlobalEventHandlers, ev: SecurityPolicyViolationEvent) => any) | null;
+            onseeked: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onseeking: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onselect: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onselectionchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onselectstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onslotchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onstalled: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onsubmit: ((this: GlobalEventHandlers, ev: SubmitEvent) => any) | null;
+            onsuspend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            ontimeupdate: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            ontoggle: ((this: GlobalEventHandlers, ev: ToggleEvent) => any) | null;
+            ontouchcancel?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined | undefined;
+            ontouchend?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined | undefined;
+            ontouchmove?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined | undefined;
+            ontouchstart?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined | undefined;
+            ontransitioncancel: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
+            ontransitionend: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
+            ontransitionrun: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
+            ontransitionstart: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
+            onvolumechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onwaiting: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onwebkitanimationend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onwebkitanimationiteration: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onwebkitanimationstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onwebkittransitionend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onwheel: ((this: GlobalEventHandlers, ev: WheelEvent) => any) | null;
+            autofocus: boolean;
+            readonly dataset: DOMStringMap;
+            nonce: string;
+            tabIndex: number;
+            blur: () => void;
+            focus: (options?: FocusOptions) => void;
+        };
     }>;
-    private canvasRef;
     rendererStore: Store<RendererStore>;
     figureRendererStore: Store<FigureRendererStore>;
     setup(): void;
     private loadImages;
+    get carouselDataViews(): PropsOf<CarouselDataViewPrint>[];
 }

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

@@ -0,0 +1,59 @@
+import { Component } from "../../owl3_compatibility_layer";
+import { RendererStore } from "../../stores/renderer_store";
+import { ViewportsStore } from "../../stores/viewports_store";
+import { ZoomStore } from "../../stores/zoom_store";
+import { HeaderIndex } from "../../types/misc";
+import { Rect } from "../../types/rendering";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+import { Store } from "../../types/store_engine";
+import { ClickableCellsOverlay } from "../clickable_cells_overlay/clickable_cells_overlay";
+import { GridOverlay } from "../grid_overlay/grid_overlay";
+import { GridPopover } from "../grid_popover/grid_popover";
+import { CellPopoverStore } from "../popover/cell_popover_store";
+import { VerticalScrollBar } from "../scrollbar/scrollbar_vertical";
+interface ColResizer {
+    col: HeaderIndex;
+    style: string;
+}
+interface DnDResizeState {
+    col: HeaderIndex | undefined;
+}
+export declare class StandaloneViewport extends Component<SpreadsheetChildEnv> {
+    static template: string;
+    static components: {
+        VerticalScrollBar: typeof VerticalScrollBar;
+        GridOverlay: typeof GridOverlay;
+        ClickableCellsOverlay: typeof ClickableCellsOverlay;
+        GridPopover: typeof GridPopover;
+    };
+    protected props: import("@odoo/owl").PropsWithDefaults<{
+        range: import("../..").Range;
+        canResizeColumns: boolean;
+        size: {
+            width: import("../..").Pixel;
+            height: import("../..").Pixel;
+        };
+        onResizeColumns?: ((columnWeights: number[] | undefined) => void) | undefined;
+        columnWeights?: number[] | undefined;
+    }, "canResizeColumns">;
+    private canvasRef;
+    private containerRef;
+    private store;
+    dndState: DnDResizeState;
+    onMouseWheel: (ev: WheelEvent) => void;
+    rendererStore: Store<RendererStore>;
+    viewStore: Store<ViewportsStore>;
+    zoomStore: Store<ZoomStore>;
+    cellPopoverStore: Store<CellPopoverStore>;
+    setup(): void;
+    get contentWidth(): number;
+    get hasVerticalScrollBar(): boolean;
+    get scrollBarContainerStyle(): string;
+    onCellDoubleClicked(col: HeaderIndex, row: HeaderIndex, ev: MouseEvent): void;
+    get gridOverlayDimensions(): string;
+    get colResizers(): ColResizer[];
+    onResizerPointerDown(ev: MouseEvent, resizer: ColResizer): void;
+    onResizerDoubleClick(): void;
+    getGridRect(): Rect;
+}
+export {};

package/dist/types/components/standalone_viewport/standalone_viewport_store.d.ts

@@ -0,0 +1,29 @@
+import { SpreadsheetStore } from "../../stores/spreadsheet_store";
+import { Command } from "../../types/commands";
+import { CellPosition, HeaderDimensions, HeaderIndex, UID } from "../../types/misc";
+import { Range } from "../../types/range";
+import { GridRenderingContext } from "../../types/rendering";
+import { Get } from "../../types/store_engine";
+export declare class StandaloneViewportStore extends SpreadsheetStore {
+    mutators: readonly ["setContainerSize", "setRange", "resizeColumn", "setCustomColWeights"];
+    cachedColDimensions: Record<HeaderIndex, HeaderDimensions> | undefined;
+    private containerWidth;
+    private containerHeight;
+    private range;
+    private customColWeights;
+    private viewStore;
+    constructor(get: Get, range: Range, customColWeights?: number[]);
+    handle(cmd: Command): void;
+    setContainerSize(width: number, height: number): "noStateChange" | undefined;
+    setRange(range: Range): "noStateChange" | undefined;
+    setCustomColWeights(weights: number[] | undefined): "noStateChange" | undefined;
+    resizeColumn(resizedCol: HeaderIndex, weightDelta: number, weightsAtStartOfDrag: number[]): void;
+    private changeColumnWeights;
+    get renderingContext(): Omit<GridRenderingContext, "ctx" | "thinLineWidth">;
+    get headerDimensionsCallback(): (sheetId: UID, dimension: "COL" | "ROW", index: number) => HeaderDimensions;
+    getHeaderDimensions(sheetId: UID, dimension: "COL" | "ROW", index: number): HeaderDimensions;
+    get columnWeights(): number[];
+    private computeColDimensions;
+    private normalizeWeights;
+    getHighlightedPositions(position: CellPosition): CellPosition[];
+}

package/dist/types/components/tables/hovered_table_store.d.ts

@@ -1,14 +1,10 @@
-import { PositionMap } from "../../helpers/cells/position_map";
 import { SpreadsheetStore } from "../../stores/spreadsheet_store";
-import { Command } from "../../types/commands";
-import { Color, Position } from "../../types/misc";
+import { CellPosition } from "../../types/misc";
+import { Get } from "../../types/store_engine";
 export declare class HoveredTableStore extends SpreadsheetStore {
-    mutators: readonly ["clear", "hover"];
-    col: number | undefined;
-    row: number | undefined;
-    overlayColors: PositionMap<Color>;
-    handle(cmd: Command): void;
-    hover(position: Partial<Position>): "noStateChange" | undefined;
-    clear(): void;
-    private computeOverlay;
+    mutators: readonly ["hover"];
+    storeGetters: readonly ["getCellHoverOverlayColor"];
+    position: CellPosition | undefined;
+    constructor(get: Get);
+    getHighlightedPositions(hoveredPosition: CellPosition): CellPosition[];
 }

package/dist/types/components/tables/table_resizer/table_resizer.d.ts

@@ -16,6 +16,8 @@ export declare class TableResizer extends Component<SpreadsheetChildEnv> {
             clientY: number;
         }, onPointerMove: (col: HeaderIndex, row: HeaderIndex, ev: MouseEvent) => void, onPointerUp: () => void, startScrollDirection?: import("../../helpers/drag_and_drop_grid_hook").DnDDirection) => void;
     };
+    private viewStore;
+    private zoomStore;
     setup(): void;
     get containerStyle(): string;
     onMouseDown(ev: PointerEvent): void;

package/dist/types/components/tables/table_styles_popover/table_styles_popover.d.ts

@@ -36,7 +36,6 @@ export declare class TableStylesPopover extends Component<SpreadsheetChildEnv> {
             zIndex?: number | undefined;
             class?: string | undefined;
             anchorRect: import("../../..").Rect;
-            containerRect?: {} | undefined;
             positioning?: "top-right" | "bottom-left" | undefined;
             verticalOffset?: number | undefined;
             onMouseWheel?: (() => void) | undefined;

package/dist/types/components/top_bar/color_editor/color_editor.d.ts

@@ -9,7 +9,7 @@ export declare class TopBarColorEditor extends Component<SpreadsheetChildEnv> {
     static template: string;
     protected props: import("@odoo/owl").Props<{
         class: string;
-        style: "textColor" | "fillColor";
+        style: "fillColor" | "textColor";
         icon: string;
         title: string;
     }>;

package/dist/types/components/top_bar/zoom_editor/zoom_editor.d.ts

@@ -1,7 +1,7 @@
+import { Component } from "../../../owl3_compatibility_layer";
 import { SpreadsheetChildEnv } from "../../../types/spreadsheet_env";
 import { ToolBarDropdownStore } from "../../helpers/top_bar_tool_hook";
 import { NumberEditor } from "../../number_editor/number_editor";
-import { Component } from "../../../owl3_compatibility_layer";
 export declare class ToolBarZoom extends Component<SpreadsheetChildEnv> {
     static template: string;
     static components: {
@@ -11,6 +11,7 @@ export declare class ToolBarZoom extends Component<SpreadsheetChildEnv> {
         class: string;
     }>;
     topBarToolStore: ToolBarDropdownStore;
+    private zoomStore;
     valueList: number[];
     setup(): void;
     get currentFontSize(): number;