@odoo/o-spreadsheet 17.0.84 → 17.0.96

package/dist/types/types/misc.d.ts

@@ -0,0 +1,276 @@
+import { ComponentConstructor } from "@odoo/owl";
+import { Token } from "../formulas";
+import { Cell, CellValue, EvaluatedCell } from "./cells";
+import { CommandResult } from "./commands";
+import { Format } from "./format";
+import { Range } from "./range";
+/**
+ * The following type is meant to be used in union with other aliases to prevent
+ * Intellisense from resolving it.
+ * See https://github.com/microsoft/TypeScript/issues/31940#issuecomment-841712377
+ */
+export type Alias = {} & {};
+export type HeaderIndex = number & Alias;
+export type Pixel = number & Alias;
+export type UID = string & Alias;
+export type SetDecimalStep = 1 | -1;
+export type FilterId = UID & Alias;
+export type FilterTableId = UID & Alias;
+/**
+ * CSS style color string
+ * e.g. "#ABC", "#AAAFFF", "rgb(30, 80, 16)"
+ */
+export type Color = string & Alias;
+export interface RGBA {
+    a: number;
+    r: number;
+    g: number;
+    b: number;
+}
+export interface HSLA {
+    a: number;
+    h: number;
+    s: number;
+    l: number;
+}
+export interface Link {
+    readonly label: string;
+    readonly url: string;
+    readonly isExternal: boolean;
+    /**
+     * Specifies if the URL is editable by the end user.
+     * Special links might not allow it.
+     */
+    readonly isUrlEditable: boolean;
+}
+export interface Zone {
+    left: HeaderIndex;
+    right: HeaderIndex;
+    top: HeaderIndex;
+    bottom: HeaderIndex;
+}
+export interface AnchorZone {
+    zone: Zone;
+    cell: Position;
+}
+export interface Selection {
+    anchor: AnchorZone;
+    zones: Zone[];
+}
+export interface UnboundedZone {
+    top: HeaderIndex;
+    bottom: HeaderIndex | undefined;
+    left: HeaderIndex;
+    right: HeaderIndex | undefined;
+    hasHeader?: boolean;
+}
+export interface ZoneDimension {
+    numberOfRows: HeaderIndex;
+    numberOfCols: HeaderIndex;
+}
+export type Align = "left" | "right" | "center" | undefined;
+export type VerticalAlign = "top" | "middle" | "bottom" | undefined;
+export type Wrapping = "overflow" | "wrap" | "clip" | undefined;
+export interface Style {
+    bold?: boolean;
+    italic?: boolean;
+    strikethrough?: boolean;
+    underline?: boolean;
+    align?: Align;
+    wrapping?: Wrapping;
+    verticalAlign?: VerticalAlign;
+    fillColor?: Color;
+    textColor?: Color;
+    fontSize?: number;
+}
+export interface UpdateCellData {
+    content?: string;
+    formula?: string;
+    style?: Style | null;
+    format?: Format;
+}
+export interface Sheet {
+    id: UID;
+    name: string;
+    numberOfCols: number;
+    rows: Row[];
+    areGridLinesVisible: boolean;
+    isVisible: boolean;
+    panes: PaneDivision;
+}
+export interface CellPosition {
+    col: HeaderIndex;
+    row: HeaderIndex;
+    sheetId: UID;
+}
+export declare const borderStyles: readonly ["thin", "medium", "thick", "dashed", "dotted"];
+export type BorderStyle = (typeof borderStyles)[number];
+export type BorderDescr = {
+    style: BorderStyle;
+    color: Color;
+};
+/**
+ * A complete border(s) data is a set of position-color-style information
+ */
+export type BorderData = {
+    position: BorderPosition;
+    color?: Color;
+    style?: BorderStyle;
+};
+export interface Border {
+    top?: BorderDescr;
+    left?: BorderDescr;
+    bottom?: BorderDescr;
+    right?: BorderDescr;
+}
+export type ReferenceDenormalizer = (range: Range, isMeta: boolean, functionName: string, paramNumber: number) => any | any[][];
+export type EnsureRange = (range: Range) => Matrix<ValueAndFormat>;
+export type NumberParser = (str: string) => number;
+export type _CompiledFormula = (deps: Range[], refFn: ReferenceDenormalizer, range: EnsureRange, ctx: {}) => Matrix<ValueAndFormat> | ValueAndFormat;
+export interface CompiledFormula {
+    execute: _CompiledFormula;
+    tokens: Token[];
+    dependencies: string[];
+}
+export interface RangeCompiledFormula extends Omit<CompiledFormula, "dependencies"> {
+    dependencies: Range[];
+}
+export type Matrix<T = unknown> = T[][];
+export type ValueAndFormat = {
+    value: CellValue;
+    format?: Format;
+};
+export type Arg = Maybe<ValueAndFormat> | Matrix<ValueAndFormat>;
+export type ArgValue = Maybe<CellValue> | Matrix<CellValue>;
+export declare function isMatrix(x: any): x is Matrix<any>;
+export interface ClipboardCell {
+    cell?: Cell;
+    evaluatedCell: EvaluatedCell;
+    border?: Border;
+    position: CellPosition;
+}
+export interface HeaderDimensions {
+    start: Pixel;
+    size: Pixel;
+    end: Pixel;
+}
+export interface Row {
+    cells: Record<number, UID | undefined>;
+}
+export interface Position {
+    col: HeaderIndex;
+    row: HeaderIndex;
+}
+export interface PixelPosition {
+    x: Pixel;
+    y: Pixel;
+}
+export interface Merge extends Zone {
+    id: number;
+    topLeft: Position;
+}
+export interface Highlight {
+    zone: Zone;
+    sheetId: UID;
+    color: Color | null;
+}
+export interface PaneDivision {
+    /** Represents the number of frozen columns */
+    xSplit: number;
+    /** Represents the number of frozen rows */
+    ySplit: number;
+}
+export type BorderPosition = "all" | "hv" | "h" | "v" | "external" | "left" | "top" | "right" | "bottom" | "clear";
+export type BorderDescription = {
+    vertical?: BorderDescr;
+    horizontal?: BorderDescr;
+} | undefined;
+export declare const enum DIRECTION {
+    UP = "up",
+    DOWN = "down",
+    LEFT = "left",
+    RIGHT = "right"
+}
+export type ChangeType = "REMOVE" | "RESIZE" | "MOVE" | "CHANGE" | "NONE";
+export type ApplyRangeChangeResult = {
+    changeType: Exclude<ChangeType, "NONE">;
+    range: Range;
+} | {
+    changeType: "NONE";
+};
+export type ApplyRangeChange = (range: Range) => ApplyRangeChangeResult;
+export type Dimension = "COL" | "ROW";
+export type ConsecutiveIndexes = HeaderIndex[];
+export interface RangeProvider {
+    adaptRanges: (applyChange: ApplyRangeChange, sheetId?: UID) => void;
+}
+export type Validation<T> = (toValidate: T) => CommandResult | CommandResult[];
+export type Increment = 1 | -1 | 0;
+export interface Ref<T> {
+    el: T | null;
+}
+/**
+ * Return the prop's type of a component
+ */
+export type PropsOf<C> = C extends ComponentConstructor<infer Props> ? Props : never;
+/**
+ * Container for a lazy computed value
+ */
+export interface Lazy<T> {
+    /**
+     * Return the computed value.
+     * The value is computed only once and memoized.
+     */
+    (): T;
+    /**
+     * Map a lazy value to another lazy value.
+     *
+     * ```ts
+     * // neither function is called here
+     * const lazyValue = lazy(() => veryExpensive(...)).map((result) => alsoVeryExpensive(result));
+     *
+     * // both values are computed now
+     * const value = lazyValue()
+     * ```
+     */
+    map: <U>(callback: (value: T) => U) => Lazy<U>;
+}
+export type Maybe<T> = T | undefined;
+export interface Cloneable<T> {
+    clone: (args?: Partial<T>) => T;
+}
+export type CSSProperties<P extends string = string> = Record<P, string | undefined>;
+export interface SortOptions {
+    /** If true sort the headers of the range along with the rest */
+    sortHeaders?: boolean;
+    /** If true treat empty cells as "0" instead of undefined */
+    emptyCellAsZero?: boolean;
+}
+export interface MenuMouseEvent extends MouseEvent {
+    closedMenuId?: UID;
+}
+export type Immutable<T> = T extends ImmutablePrimitive ? T : T extends Array<infer U> ? ImmutableArray<U> : T extends Map<infer K, infer V> ? ImmutableMap<K, V> : T extends Set<infer M> ? ImmutableSet<M> : ImmutableObject<T>;
+type ImmutablePrimitive = undefined | null | boolean | string | number | Function;
+type ImmutableArray<T> = ReadonlyArray<Immutable<T>>;
+type ImmutableMap<K, V> = ReadonlyMap<Immutable<K>, Immutable<V>>;
+type ImmutableSet<T> = ReadonlySet<Immutable<T>>;
+type ImmutableObject<T> = {
+    readonly [K in keyof T]: Immutable<T[K]>;
+};
+export interface HeaderGroup {
+    start: HeaderIndex;
+    end: HeaderIndex;
+    isFolded?: boolean;
+}
+export type Direction = "up" | "down" | "left" | "right";
+export type SelectionStep = number | "end";
+export interface Offset {
+    col: number;
+    row: number;
+}
+export type DeepPartial<T> = T extends Function ? T : T extends Array<infer U> ? _DeepPartialArray<U> : T extends object ? _DeepPartialObject<T> : T | undefined;
+type _DeepPartialArray<T> = Array<DeepPartial<T>>;
+type _DeepPartialObject<T> = {
+    [P in keyof T]?: DeepPartial<T[P]>;
+};
+export {};

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

@@ -0,0 +1,21 @@
+import { Cloneable, UID, UnboundedZone, Zone } from "./misc";
+export interface RangePart {
+    readonly colFixed: boolean;
+    readonly rowFixed: boolean;
+}
+export interface Range extends Cloneable<Range> {
+    readonly zone: Readonly<Zone>;
+    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;
+    readonly rangeData: RangeData;
+}
+export interface RangeData {
+    _zone: Zone | UnboundedZone;
+    _sheetId: UID;
+}

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

@@ -0,0 +1,86 @@
+import { Alias, Align, Border, Pixel, Style, VerticalAlign, 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;
+    align: Align;
+}
+export interface Box extends Rect {
+    content?: BoxTextContent;
+    style: Style;
+    border?: Border;
+    hasIcon?: boolean;
+    clipRect?: Rect;
+    isError?: boolean;
+    image?: Image;
+    isMerge?: boolean;
+    verticalAlign?: VerticalAlign;
+    isOverflow?: boolean;
+}
+export interface Image {
+    clipIcon: Rect | null;
+    size: Pixel;
+    type: "icon";
+    image: HTMLImageElement;
+}
+/**
+ * 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 SheetScrollInfo {
+    /**
+     * The offset in the X coordinate between the viewport left side and
+     * the grid left side (left of column "A").
+     */
+    scrollX: Pixel;
+    /**
+     * The offset in the Y coordinate between the viewport top side and
+     * the grid top side (top of row "1").
+     */
+    scrollY: Pixel;
+}
+export interface SheetDOMScrollInfo {
+    /**
+     * The scrollBar offset in the X coordinate, which can differ from offsetX as
+     * the former is "smooth" and the latter will "snap" from one cell coordinate to the other
+     */
+    scrollX: Pixel;
+    /**
+     * The scrollBar offset in the Y coordinate, which can differ from offsetX as
+     * the former is "smooth" and the latter will "snap" from one cell coordinate to the other
+     */
+    scrollY: Pixel;
+}
+export interface GridRenderingContext {
+    ctx: CanvasRenderingContext2D;
+    dpr: number;
+    thinLineWidth: number;
+}
+export declare const enum LAYERS {
+    Background = 0,
+    Highlights = 1,
+    Clipboard = 2,
+    Search = 3,
+    Chart = 4,
+    Autofill = 5,
+    Selection = 6,
+    Headers = 7
+}
+export interface EdgeScrollInfo {
+    canEdgeScroll: boolean;
+    direction: ScrollDirection;
+    delay: number;
+}
+export type ScrollDirection = 1 | 0 | -1 | "reset";

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<T>[]): CommandResult | CommandResult[];
+}

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

@@ -0,0 +1,112 @@
+import { CellValue, DataValidationRule, Format, Locale } from ".";
+import { ExcelChartDefinition } from "./chart/chart";
+import { ConditionalFormat } from "./conditional_formatting";
+import { Image } from "./image";
+import { Border, Dimension, HeaderGroup, PaneDivision, Pixel, Style, UID } from "./misc";
+export interface Dependencies {
+    references: string[];
+    numbers: number[];
+    strings: string[];
+}
+export interface CellData {
+    content?: string;
+    style?: number;
+    border?: number;
+    format?: number;
+}
+export interface HeaderData {
+    size?: number;
+    isHidden?: boolean;
+}
+export interface FigureData<T> {
+    id: UID;
+    x: Pixel;
+    y: Pixel;
+    width: Pixel;
+    height: Pixel;
+    tag: string;
+    data: T;
+}
+export interface SheetData {
+    id: string;
+    name: string;
+    colNumber: number;
+    rowNumber: number;
+    cells: {
+        [key: string]: CellData | undefined;
+    };
+    merges: string[];
+    figures: FigureData<any>[];
+    cols: {
+        [key: number]: HeaderData;
+    };
+    rows: {
+        [key: number]: HeaderData;
+    };
+    conditionalFormats: ConditionalFormat[];
+    dataValidationRules?: DataValidationRuleData[];
+    filterTables: FilterTableData[];
+    areGridLinesVisible?: boolean;
+    isVisible: boolean;
+    panes?: PaneDivision;
+    headerGroups?: Record<Dimension, HeaderGroup[]>;
+}
+interface WorkbookSettings {
+    locale: Locale;
+}
+export interface WorkbookData {
+    version: number;
+    sheets: SheetData[];
+    styles: {
+        [key: number]: Style;
+    };
+    formats: {
+        [key: number]: Format;
+    };
+    borders: {
+        [key: number]: Border;
+    };
+    entities: {
+        [key: string]: {
+            [key: string]: any;
+        };
+    };
+    revisionId: UID;
+    uniqueFigureIds: boolean;
+    settings: WorkbookSettings;
+}
+export interface ExcelWorkbookData extends WorkbookData {
+    sheets: ExcelSheetData[];
+}
+export interface ExcelCellData extends CellData {
+    value: CellValue;
+    isFormula: Boolean;
+    computedFormat?: Format;
+}
+export interface ExcelSheetData extends Omit<SheetData, "figureTables"> {
+    cells: {
+        [key: string]: ExcelCellData | undefined;
+    };
+    formulaSpillRanges: {
+        [xc: string]: string;
+    };
+    charts: FigureData<ExcelChartDefinition>[];
+    images: FigureData<Image>[];
+    filterTables: ExcelFilterTableData[];
+}
+export interface FilterTableData {
+    range: string;
+}
+export interface DataValidationRuleData extends Omit<DataValidationRule, "ranges"> {
+    ranges: string[];
+}
+export interface ExcelFilterTableData {
+    range: string;
+    filters: ExcelFilterData[];
+}
+export interface ExcelFilterData {
+    colId: number;
+    displayedValues: string[];
+    displayBlanks?: boolean;
+}
+export {};