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

package/dist/types/types/props_of.d.ts

@@ -0,0 +1,5 @@
+import { ComponentConstructor } from "@odoo/owl";
+/**
+ * Return the prop's type of a component
+ */
+export type PropsOf<C> = C extends ComponentConstructor<infer Props> ? Props : never;

package/dist/types/types/range.d.ts

@@ -0,0 +1,29 @@
+import { UID, UnboundedZone, Zone } from "./misc";
+export interface RangePart {
+    readonly colFixed: boolean;
+    readonly rowFixed: boolean;
+}
+export interface Range {
+    zone: Zone;
+    unboundedZone: UnboundedZone;
+    readonly parts: readonly RangePart[];
+    readonly invalidXc?: string;
+    /** true if the user provided the range with the sheet name */
+    readonly prefixSheet: boolean;
+    /** the name of any sheet that is invalid */
+    readonly invalidSheetName?: string;
+    /** the sheet on which the range is defined */
+    readonly sheetId: UID;
+}
+export interface BoundedRange {
+    sheetId: UID;
+    zone: Zone;
+}
+export interface RangeStringOptions {
+    useBoundedReference?: boolean;
+    useFixedReference?: boolean;
+}
+export interface RangeData {
+    _zone: Zone | UnboundedZone;
+    _sheetId: UID;
+}

package/dist/types/types/rendering.d.ts

@@ -0,0 +1,132 @@
+import { ViewportCollection } from "../helpers/viewport_collection";
+import { SelectionState } from "../plugins/ui_stateful/selection";
+import { GridIcon } from "../registries/icons_on_cell_registry";
+import { ImageSVG } from "./image";
+import { Alias, Align, BorderDescr, Color, DataBarFill, Pixel, Style, Zone } from "./misc";
+/**
+ * Coordinate in pixels
+ */
+export interface DOMCoordinates {
+    x: Pixel;
+    y: Pixel;
+}
+export interface DOMDimension {
+    width: Pixel;
+    height: Pixel;
+}
+export type Rect = DOMCoordinates & DOMDimension;
+export interface BoxTextContent {
+    textLines: string[];
+    width: Pixel;
+    textHeight: Pixel;
+    textWidth: Pixel;
+    align: Align;
+    fontSizePx: number;
+    x: Pixel;
+    y: Pixel;
+}
+export type BorderDescrWithOpacity = BorderDescr & {
+    opacity?: number;
+};
+export type RenderingBorder = {
+    top?: BorderDescrWithOpacity;
+    right?: BorderDescrWithOpacity;
+    bottom?: BorderDescrWithOpacity;
+    left?: BorderDescrWithOpacity;
+};
+export type RenderingGridIcon = GridIcon & {
+    clipRect?: Rect;
+    opacity?: number;
+};
+export interface RenderingBox {
+    id: string;
+    content?: BoxTextContent;
+    style: Style;
+    chip?: {
+        x: number;
+        y: number;
+        width: Pixel;
+        height: Pixel;
+        color: Color;
+    };
+    dataBarFill?: DataBarFill;
+    border?: RenderingBorder;
+    clipRect?: Rect;
+    isError?: boolean;
+    isMerge?: boolean;
+    isOverflow?: boolean;
+    overlayColor?: Color;
+    icons: {
+        left?: RenderingGridIcon;
+        right?: RenderingGridIcon;
+        center?: RenderingGridIcon;
+    };
+    textOpacity?: number;
+    disabledAnimation?: boolean;
+}
+export type Box = RenderingBox & Rect;
+export interface Image {
+    clipIcon: Rect | null;
+    size: Pixel;
+    type: "icon";
+    svg: ImageSVG;
+}
+/**
+ * The viewport is the visible area of a sheet.
+ * Column and row headers are not included in the viewport.
+ */
+export type Viewport = Zone & Alias;
+export interface SheetDOMScrollInfo {
+    /**
+     * The scrollBar offset in the X coordinate
+     */
+    scrollX: Pixel;
+    /**
+     * The scrollBar offset in the Y coordinate
+     */
+    scrollY: Pixel;
+}
+export interface GridRenderingTheme {
+    backgroundColor: string;
+    gridBorderColor: string;
+    headerBackgroundColor: string;
+    headerActiveBackgroundColor: string;
+    headerSelectedBackgroundColor: string;
+    headerTextColor: string;
+    headerBorderColor: string;
+    frozenPaneBorderColor: string;
+    frozenPaneHeaderBorderColor: string;
+    singleCellSelectionBackgroundColor: string;
+    multipleCellsSelectionBackgroundColor: string;
+}
+export type GridRenderingContext = {
+    ctx: CanvasRenderingContext2D;
+    dpr: number;
+    thinLineWidth: number;
+    viewports: ViewportCollection;
+    hideGridLines?: boolean;
+} & SelectionState;
+declare const LAYERS: {
+    readonly Background: 0;
+    readonly Highlights: 1;
+    readonly Clipboard: 2;
+    readonly Chart: 4;
+    readonly Autofill: 5;
+    readonly Selection: 6;
+    readonly Headers: 100;
+};
+export type LayerName = keyof typeof LAYERS;
+export declare const OrderedLayers: () => ("Background" | "Highlights" | "Clipboard" | "Chart" | "Autofill" | "Selection" | "Headers")[];
+/**
+ *
+ * @param layer New layer name
+ * @param priority The lower priorities are rendered first
+ */
+export declare function addRenderingLayer(layer: string, priority: number): void;
+export interface EdgeScrollInfo {
+    canEdgeScroll: boolean;
+    direction: ScrollDirection;
+    delay: number;
+}
+export type ScrollDirection = 1 | 0 | -1 | "reset";
+export {};

package/dist/types/types/scroll_direction.d.ts

@@ -0,0 +1 @@
+export type ScrollDirection = "horizontal" | "vertical";

package/dist/types/types/selection_stream_processor.d.ts

@@ -0,0 +1,35 @@
+import { StreamCallbacks } from "../selection_stream/event_stream";
+import { DispatchResult } from "./commands";
+import { SelectionEvent, SelectionEventOptions } from "./event_stream/selection_events";
+import { AnchorZone, Direction, SelectionStep } from "./misc";
+type StatefulStream<Event, State> = {
+    capture(owner: unknown, state: State, callbacks: StreamCallbacks<Event>): void;
+    registerAsDefault: (owner: unknown, state: State, callbacks: StreamCallbacks<Event>) => void;
+    resetDefaultAnchor: (owner: unknown, state: State) => void;
+    resetAnchor: (owner: unknown, state: State) => void;
+    observe: (owner: unknown, callbacks: StreamCallbacks<Event>) => void;
+    unobserve: (owner: unknown) => void;
+    release: (owner: unknown) => void;
+    getBackToDefault(): void;
+};
+/**
+ * Allows to select cells in the grid and update the selection
+ */
+interface SelectionProcessor {
+    selectZone(anchor: AnchorZone, options?: SelectionEventOptions): DispatchResult;
+    selectCell(col: number, row: number): DispatchResult;
+    moveAnchorCell(direction: Direction, step: SelectionStep): DispatchResult;
+    updateAnchorCell(col: number, row: number, options?: SelectionEventOptions): DispatchResult;
+    setAnchorCorner(col: number, row: number): DispatchResult;
+    addCellToSelection(col: number, row: number): DispatchResult;
+    resizeAnchorZone(direction: Direction, step: SelectionStep): DispatchResult;
+    selectColumn(index: number, mode: SelectionEvent["mode"]): DispatchResult;
+    selectRow(index: number, mode: SelectionEvent["mode"]): DispatchResult;
+    selectAll(): DispatchResult;
+    loopSelection(): DispatchResult;
+    selectTableAroundSelection(): DispatchResult;
+    commitSelection(): DispatchResult;
+    isListening(owner: unknown): boolean;
+}
+export type SelectionStreamProcessor = SelectionProcessor & StatefulStream<SelectionEvent, AnchorZone>;
+export {};

package/dist/types/types/spreadsheet_env.d.ts

@@ -0,0 +1,23 @@
+import { Model } from "../model";
+import { ClipboardInterface } from "./clipboard/clipboard_interface";
+import { Currency } from "./currency";
+import { ImageProviderInterface } from "./files";
+import { Locale } from "./locale";
+import { Get } from "./store_engine";
+import { NotificationStoreMethods } from "./stores/notification_store_methods";
+export interface SpreadsheetChildEnv extends NotificationStoreMethods {
+    model: Model;
+    imageProvider?: ImageProviderInterface;
+    isDashboard: () => boolean;
+    openSidePanel: (panel: string, panelProps?: any) => void;
+    replaceSidePanel: (panel: string, currentPanel: string, panelProps?: any) => void;
+    toggleSidePanel: (panel: string, panelProps?: any) => void;
+    clipboard: ClipboardInterface;
+    startCellEdition: (content?: string) => void;
+    loadCurrencies?: () => Promise<Currency[]>;
+    loadLocales: () => Promise<Locale[]>;
+    getStore: Get;
+    isSmall: boolean;
+    isMobile: () => boolean;
+    printSpreadsheet: () => void;
+}

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

@@ -0,0 +1,52 @@
+/**
+ * An injectable store constructor
+ */
+export interface StoreConstructor<T = any, A extends unknown[] = any[]> {
+    new (get: Get, ...args: A): T;
+}
+/**
+ * A store constructor for a store that implements the Disposable interface.
+ * Useful for local stores that need to be disposed when the component unmounts.
+ */
+export interface LocalStoreConstructor<T extends Disposable = any, A extends unknown[] = unknown[]> {
+    new (get: Get, ...args: A): T;
+}
+export interface Disposable {
+    dispose(): void;
+}
+export type StoreParams<T extends StoreConstructor> = SkipFirst<ConstructorParameters<T>>;
+/**
+ * A function used to inject dependencies in a store constructor
+ */
+export type Get = <T extends StoreConstructor>(Store: T) => T extends StoreConstructor<infer I> ? Store<I> : never;
+/**
+ * Remove the first element of a tuple
+ * @example
+ * type A = SkipFirst<[number, string, boolean]> // [string, boolean]
+ */
+export type SkipFirst<T extends any[]> = T extends [any, ...infer U] ? U : never;
+export type OmitFunctions<T> = {
+    [K in keyof T as T[K] extends Function ? never : K]: T[K];
+};
+export type Store<S> = S extends {
+    mutators: readonly (keyof S)[];
+} ? CQS<Pick<S, S["mutators"][number]> & OmitFunctions<S>> : CQS<OmitFunctions<S>>;
+/**
+ * Command Query Separation [1,2] implementation with types.
+ *
+ * Mapped type applying CQS principles to an object by forcing
+ * - methods (commands) to never return anything, effectively making them write-only,
+ * - all properties (queries) to be read-only [3]
+ *
+ * [1] https://martinfowler.com/bliki/CommandQuerySeparation.html
+ * [2] https://en.wikipedia.org/wiki/Command%E2%80%93query_separation
+ * [3] in an ideal world, they would be deeply read-only, but that's not possible natively in TypeScript
+ */
+export type CQS<T> = {
+    readonly [key in keyof T]: NeverReturns<T[key]>;
+};
+/**
+ * Force any function to never return anything, effectively
+ * making it write-only.
+ */
+export type NeverReturns<T> = T extends (...args: any[]) => any ? (...args: Parameters<T>) => void : T;

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

@@ -0,0 +1,6 @@
+import { InformationNotification } from "../env";
+export interface NotificationStoreMethods {
+    notifyUser: (notification: InformationNotification) => void;
+    raiseError: (text: string, callback?: () => void) => void;
+    askConfirmation: (content: string, confirm: () => void, cancel?: () => void) => void;
+}

package/dist/types/types/table.d.ts

@@ -0,0 +1,103 @@
+import { DateCriterionValue, GenericCriterionType } from "./generic_criterion";
+import { Border, BorderDescr, Style, TableId, UID } from "./misc";
+import { Range } from "./range";
+export interface Table {
+    readonly id: TableId;
+    readonly range: Range;
+    readonly filters: Filter[];
+    readonly config: TableConfig;
+    readonly isPivotTable?: boolean;
+}
+export interface StaticTable extends Table {
+    readonly type: "static" | "forceStatic";
+}
+export interface DynamicTable extends Omit<Table, "filters"> {
+    readonly type: "dynamic";
+}
+export type CoreTable = StaticTable | DynamicTable;
+export type CoreTableType = Extract<CoreTable, {
+    type: string;
+}>["type"];
+export interface Filter {
+    readonly id: UID;
+    readonly rangeWithHeaders: Range;
+    readonly col: number;
+    /** The filtered zone doesn't includes the headers of the table */
+    readonly filteredRange: Range | undefined;
+}
+export interface TableConfig {
+    hasFilters: boolean;
+    totalRow: boolean;
+    firstColumn: boolean;
+    lastColumn: boolean;
+    numberOfHeaders: number;
+    bandedRows: boolean;
+    bandedColumns: boolean;
+    automaticAutofill?: boolean;
+    styleId: string;
+}
+export interface TableMetaData {
+    mode: "pivot" | "table";
+    numberOfCols: number;
+    numberOfRows: number;
+    measureRow?: number;
+    mainSubHeaderRows?: Set<number>;
+    firstAlternatingSubHeaderIndexes?: Set<number>;
+    secondAlternatingSubHeaderIndexes?: Set<number>;
+    isTabular?: boolean;
+}
+export interface ComputedTableStyle {
+    borders: Border[][];
+    styles: Style[][];
+}
+export interface TableElementStyle {
+    border?: TableBorder;
+    style?: Style;
+    size?: number;
+}
+export interface TableBorder {
+    top?: BorderDescr | null;
+    bottom?: BorderDescr | null;
+    left?: BorderDescr | null;
+    right?: BorderDescr | null;
+    horizontal?: BorderDescr | null;
+    vertical?: BorderDescr | null;
+}
+export interface TableStyle {
+    category: string;
+    displayName: string;
+    templateName: TableStyleTemplateName;
+    primaryColor: string;
+    wholeTable?: TableElementStyle;
+    firstColumnStripe?: TableElementStyle;
+    secondColumnStripe?: TableElementStyle;
+    firstRowStripe?: TableElementStyle;
+    secondRowStripe?: TableElementStyle;
+    firstColumn?: TableElementStyle;
+    lastColumn?: TableElementStyle;
+    headerRow?: TableElementStyle;
+    totalRow?: TableElementStyle;
+    measureHeader?: TableElementStyle;
+    mainSubHeaderRow?: TableElementStyle;
+    firstAlternatingSubHeaderRow?: TableElementStyle;
+    secondAlternatingSubHeaderRow?: TableElementStyle;
+}
+export type TableStyleTemplateName = string;
+declare const filterCriterions: GenericCriterionType[];
+export type FilterCriterionType = (typeof filterCriterions)[number];
+export declare const availableFiltersOperators: Set<FilterCriterionType>;
+export declare const filterTextCriterionOperators: FilterCriterionType[];
+export declare const filterNumberCriterionOperators: FilterCriterionType[];
+export declare const filterDateCriterionOperators: FilterCriterionType[];
+export interface ValuesFilter {
+    filterType: "values";
+    hiddenValues: string[];
+}
+export interface CriterionFilter {
+    filterType: "criterion";
+    type: FilterCriterionType | "none";
+    values: string[];
+    dateValue?: DateCriterionValue;
+}
+export type DataFilterValue = ValuesFilter | CriterionFilter;
+export {};

package/dist/types/types/validator.d.ts

@@ -0,0 +1,16 @@
+import { CommandResult } from "./commands";
+import { Validation } from "./misc";
+export interface Validator {
+    /**
+     * Combine multiple validation functions into a single function
+     * returning the list of result of every validation.
+     */
+    batchValidations<T>(...validations: Validation<T>[]): Validation<T>;
+    /**
+     * Combine multiple validation functions. Every validation is executed one after
+     * the other. As soon as one validation fails, it stops and the cancelled reason
+     * is returned.
+     */
+    chainValidations<T>(...validations: Validation<T>[]): Validation<T>;
+    checkValidations<T>(command: T, ...validations: Validation<NoInfer<T>>[]): CommandResult | CommandResult[];
+}

package/dist/types/types/workbook_data.d.ts

@@ -0,0 +1,147 @@
+import { SquishedContent } from "../plugins/core/squisher";
+import { CellValue } from "./cells";
+import { ExcelChartDefinition } from "./chart/chart";
+import { ConditionalFormat } from "./conditional_formatting";
+import { DataValidationRule } from "./data_validation";
+import { Format } from "./format";
+import { Image } from "./image";
+import { Locale } from "./locale";
+import { Border, Color, Dimension, HeaderGroup, HeaderIndex, PaneDivision, Pixel, PixelPosition, Style, UID } from "./misc";
+import { PivotCoreDefinition } from "./pivot";
+import { CoreTableType, TableConfig, TableStyleTemplateName } from "./table";
+export interface Dependencies {
+    references: string[];
+    numbers: number[];
+    strings: string[];
+}
+export interface HeaderData {
+    size?: number;
+    isHidden?: boolean;
+}
+export interface FigureData<T> {
+    id: UID;
+    col: HeaderIndex;
+    row: HeaderIndex;
+    offset: PixelPosition;
+    width: Pixel;
+    height: Pixel;
+    tag: string;
+    data: T;
+}
+export interface SheetData {
+    id: string;
+    name: string;
+    colNumber: number;
+    rowNumber: number;
+    cells: {
+        [key: string]: undefined | SquishedContent;
+    };
+    styles: {
+        [zone: string]: number;
+    };
+    formats: {
+        [zone: string]: number;
+    };
+    borders: {
+        [zone: string]: number;
+    };
+    merges: string[];
+    figures: FigureData<any>[];
+    cols: {
+        [key: number]: HeaderData;
+    };
+    rows: {
+        [key: number]: HeaderData;
+    };
+    conditionalFormats: ConditionalFormat[];
+    dataValidationRules: DataValidationRuleData[];
+    tables: TableData[];
+    areGridLinesVisible?: boolean;
+    isVisible: boolean;
+    panes?: PaneDivision;
+    headerGroups?: Record<Dimension, HeaderGroup[]>;
+    color?: Color;
+    isLocked?: boolean;
+}
+interface WorkbookSettings {
+    locale: Locale;
+    disableCellAnimations?: boolean;
+}
+type PivotData = {
+    formulaId: string;
+} & PivotCoreDefinition;
+export interface WorkbookData {
+    version: string;
+    sheets: SheetData[];
+    styles: {
+        [key: number]: Style;
+    };
+    formats: {
+        [key: number]: Format;
+    };
+    borders: {
+        [key: number]: Border;
+    };
+    pivots: {
+        [key: string]: PivotData;
+    };
+    pivotNextId: number;
+    revisionId: UID;
+    uniqueFigureIds: boolean;
+    settings: WorkbookSettings;
+    customTableStyles: {
+        [key: string]: TableStyleData;
+    };
+    isNotSquishable?: boolean;
+    namedRanges: {
+        [name: string]: string;
+    };
+}
+export interface ExcelWorkbookData extends WorkbookData {
+    sheets: ExcelSheetData[];
+}
+export interface ExcelSheetData extends Omit<SheetData, "figureTables" | "cols" | "rows"> {
+    cellValues: {
+        [xc: string]: CellValue | undefined;
+    };
+    formulaSpillRanges: {
+        [xc: string]: string;
+    };
+    charts: FigureData<ExcelChartDefinition>[];
+    images: FigureData<Image>[];
+    tables: ExcelTableData[];
+    cols: {
+        [key: number]: ExcelHeaderData;
+    };
+    rows: {
+        [key: number]: ExcelHeaderData;
+    };
+}
+export interface ExcelHeaderData extends HeaderData {
+    outlineLevel?: number;
+    collapsed?: boolean;
+}
+export interface TableData {
+    range: string;
+    config?: TableConfig;
+    type?: CoreTableType;
+}
+export interface DataValidationRuleData extends Omit<DataValidationRule, "ranges"> {
+    ranges: string[];
+}
+export interface ExcelTableData {
+    range: string;
+    filters: ExcelFilterData[];
+    config: TableConfig;
+}
+export interface ExcelFilterData {
+    colId: number;
+    displayedValues: string[];
+    displayBlanks?: boolean;
+}
+export interface TableStyleData {
+    templateName: TableStyleTemplateName;
+    primaryColor: string;
+    displayName: string;
+}
+export {};