@odoo/o-spreadsheet 18.0.55 → 18.0.68

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

@@ -0,0 +1,312 @@
+import { CellValue, EvaluatedCell } from "./cells";
+import { CommandResult } from "./commands";
+import { ComponentConstructor } from "@odoo/owl";
+import { Token } from "../formulas";
+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 TableId = 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;
+    /**
+     * The hasHeader flag is used to determine if the zone has a header (eg. A2:A or C3:3).
+     *
+     * The main issue is that the zone A1:A and A:A have different behavior. The "correct" way to handle this would be to
+     * allow the top/left to be undefined, but this make typing and using unbounded zones VERY annoying. So we use this
+     * boolean instead.
+     */
+    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 DataBarFill {
+    color: Color;
+    percentage: 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;
+    color?: Color;
+}
+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) => FunctionResultObject;
+export type EnsureRange = (range: Range) => Matrix<FunctionResultObject>;
+export type GetSymbolValue = (symbolName: string) => Arg;
+export type FormulaToExecute = (deps: Range[], refFn: ReferenceDenormalizer, range: EnsureRange, getSymbolValue: GetSymbolValue, ctx: {}) => Matrix<FunctionResultObject> | FunctionResultObject;
+export interface CompiledFormula {
+    execute: FormulaToExecute;
+    tokens: Token[];
+    dependencies: string[];
+    isBadExpression: boolean;
+}
+export interface RangeCompiledFormula extends Omit<CompiledFormula, "dependencies"> {
+    dependencies: Range[];
+}
+export type Matrix<T = unknown> = T[][];
+export type FunctionResultObject = {
+    value: CellValue;
+    format?: Format;
+    message?: string;
+};
+export type FunctionResultNumber = {
+    value: number;
+    format?: string;
+};
+export type Arg = Maybe<FunctionResultObject> | Matrix<FunctionResultObject>;
+export declare function isMatrix(x: any): x is Matrix<any>;
+export interface ClipboardCell {
+    evaluatedCell: EvaluatedCell;
+    position: CellPosition;
+    content: string;
+    style?: Style | undefined;
+    format?: Format | undefined;
+    tokens?: Token[];
+    border?: Border;
+}
+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;
+}
+export interface Highlight {
+    zone: Zone;
+    sheetId: UID;
+    color: Color;
+    interactive?: boolean;
+    thinLine?: boolean;
+    noFill?: boolean;
+    /** transparency of the fill color (0-1) */
+    fillAlpha?: number;
+    noBorder?: boolean;
+    dashed?: boolean;
+}
+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 DebouncedFunction<T> = T & {
+    stopDebounce: () => void;
+    isDebouncePending: () => boolean;
+};
+export interface GridClickModifiers {
+    addZone: boolean;
+    expandZone: boolean;
+}
+export type ComposerFocusType = "inactive" | "cellFocus" | "contentFocus";
+export type EditionMode = "editing" | "selecting" | "inactive";
+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/pivot.d.ts

@@ -0,0 +1,136 @@
+import { NEXT_VALUE, PREVIOUS_VALUE } from "../helpers/pivot/pivot_domain_helpers";
+import { CellValue } from "./cells";
+import { Format } from "./format";
+import { Locale } from "./locale";
+import { FunctionResultObject, UID, Zone } from "./misc";
+export type Aggregator = "array_agg" | "count" | "count_distinct" | "bool_and" | "bool_or" | "max" | "min" | "avg" | "sum";
+export type Granularity = "day" | "week" | "month" | "quarter" | "year" | "second_number" | "minute_number" | "hour_number" | "day_of_week" | "day_of_month" | "iso_week_number" | "month_number" | "quarter_number";
+export interface PivotCoreDimension {
+    fieldName: string;
+    order?: "asc" | "desc";
+    granularity?: Granularity | string;
+}
+export interface PivotCoreMeasure {
+    /**
+     * Identifier of the measure, `technicalName:aggregator{:autoIncrementedNumber}`.
+     * It's used to identify the measure in the pivot formula.
+     */
+    id: string;
+    userDefinedName?: string;
+    fieldName: string;
+    aggregator: Aggregator | string;
+    isHidden?: boolean;
+    format?: Format;
+    computedBy?: {
+        sheetId: UID;
+        formula: string;
+    };
+    display?: PivotMeasureDisplay;
+}
+export interface CommonPivotCoreDefinition {
+    columns: PivotCoreDimension[];
+    rows: PivotCoreDimension[];
+    measures: PivotCoreMeasure[];
+    name: string;
+}
+export interface SpreadsheetPivotCoreDefinition extends CommonPivotCoreDefinition {
+    type: "SPREADSHEET";
+    dataSet?: {
+        sheetId: UID;
+        zone: Zone;
+    };
+}
+interface FakePivotDefinition extends CommonPivotCoreDefinition {
+    type: "FAKE";
+}
+export type PivotCoreDefinition = SpreadsheetPivotCoreDefinition | FakePivotDefinition;
+export type TechnicalName = string;
+export interface PivotField {
+    name: TechnicalName;
+    type: string;
+    string: string;
+    aggregator?: string;
+    help?: string;
+}
+export type PivotFields = Record<TechnicalName, PivotField | undefined>;
+export interface PivotMeasure extends PivotCoreMeasure {
+    displayName: string;
+    type: string;
+    isValid: boolean;
+}
+export interface PivotDimension extends PivotCoreDimension {
+    nameWithGranularity: string;
+    displayName: string;
+    type: string;
+    isValid: boolean;
+}
+export interface PivotTableColumn {
+    fields: string[];
+    values: CellValue[];
+    width: number;
+    offset: number;
+}
+export interface PivotTableRow {
+    fields: string[];
+    values: CellValue[];
+    indent: number;
+}
+export interface PivotTableData {
+    cols: PivotTableColumn[][];
+    rows: PivotTableRow[];
+    measures: string[];
+    fieldsType?: Record<string, string | undefined>;
+}
+export interface PivotHeaderCell {
+    type: "HEADER";
+    domain: PivotDomain;
+}
+export interface PivotMeasureHeaderCell {
+    type: "MEASURE_HEADER";
+    domain: PivotDomain;
+    measure: string;
+}
+export interface PivotValueCell {
+    type: "VALUE";
+    domain: PivotDomain;
+    measure: string;
+}
+export interface PivotEmptyCell {
+    type: "EMPTY";
+}
+export type PivotTableCell = PivotHeaderCell | PivotMeasureHeaderCell | PivotValueCell | PivotEmptyCell;
+export interface PivotTimeAdapterNotNull<T> {
+    normalizeFunctionValue: (value: Exclude<CellValue, null>) => T;
+    toValueAndFormat: (normalizedValue: T, locale?: Locale) => FunctionResultObject;
+    toFunctionValue: (normalizedValue: T) => string;
+}
+export interface PivotTimeAdapter<T> {
+    normalizeFunctionValue: (value: CellValue) => T | null;
+    toValueAndFormat: (normalizedValue: T, locale?: Locale) => FunctionResultObject;
+    toFunctionValue: (normalizedValue: T) => string;
+}
+export interface PivotNode {
+    field: string;
+    type: string;
+    value: CellValue;
+}
+export type PivotDomain = PivotNode[];
+/** Pivot domain splitted for the domain related to the pivot's rows and columns  */
+export interface PivotColRowDomain {
+    colDomain: PivotDomain;
+    rowDomain: PivotDomain;
+}
+export interface PivotMeasureDisplay {
+    type: PivotMeasureDisplayType;
+    fieldNameWithGranularity?: string;
+    value?: string | boolean | number | typeof PREVIOUS_VALUE | typeof NEXT_VALUE;
+}
+export type PivotMeasureDisplayType = "no_calculations" | "%_of_grand_total" | "%_of_col_total" | "%_of_row_total" | "%_of_parent_row_total" | "%_of_parent_col_total" | "index" | "%_of_parent_total" | "running_total" | "%_running_total" | "rank_asc" | "rank_desc" | "%_of" | "difference_from" | "%_difference_from";
+export interface DimensionTreeNode {
+    value: CellValue;
+    field: string;
+    children: DimensionTree;
+    width: number;
+}
+export type DimensionTree = DimensionTreeNode[];
+export {};

package/dist/types/types/pivot_runtime.d.ts

@@ -0,0 +1,31 @@
+import { PivotRuntimeDefinition } from "../helpers/pivot/pivot_runtime_definition";
+import { SpreadsheetPivotTable } from "../helpers/pivot/table_spreadsheet_pivot";
+import { FunctionResultObject, Maybe } from "./misc";
+import { PivotCoreDefinition, PivotDimension, PivotDomain, PivotFields, PivotMeasure } from "./pivot";
+export interface InitPivotParams {
+    reload?: boolean;
+}
+export interface Pivot<T = PivotRuntimeDefinition> {
+    type: PivotCoreDefinition["type"];
+    definition: T;
+    init(params?: InitPivotParams): void;
+    isValid(): boolean;
+    onDefinitionChange(nextDefinition: PivotCoreDefinition): void;
+    getTableStructure(): SpreadsheetPivotTable;
+    getFields(): PivotFields;
+    getPivotHeaderValueAndFormat(domain: PivotDomain): FunctionResultObject;
+    getPivotCellValueAndFormat(measure: string, domain: PivotDomain): FunctionResultObject;
+    getPivotMeasureValue(measure: string, domain: PivotDomain): FunctionResultObject;
+    getMeasure: (id: string) => PivotMeasure;
+    parseArgsToPivotDomain(args: Maybe<FunctionResultObject>[]): PivotDomain;
+    areDomainArgsFieldsValid(args: Maybe<FunctionResultObject>[]): boolean;
+    assertIsValid({ throwOnError }: {
+        throwOnError: boolean;
+    }): FunctionResultObject | undefined;
+    getPossibleFieldValues(dimension: PivotDimension): {
+        value: string | boolean | number;
+        label: string;
+    }[];
+    needsReevaluation: boolean;
+    markAsDirtyForEvaluation?(): void;
+}

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,95 @@
+import { Alias, Align, Border, DataBarFill, 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;
+    dataBarFill?: DataBarFill;
+    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;
+}
+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: () => ("Chart" | "Clipboard" | "Headers" | "Selection" | "Background" | "Highlights" | "Autofill")[];
+/**
+ *
+ * @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/table.d.ts

@@ -0,0 +1,65 @@
+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;
+}
+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 ComputedTableStyle {
+    borders: Border[][];
+    styles: Style[][];
+}
+export interface TableElementStyle {
+    border?: TableBorder;
+    style?: Style;
+    size?: number;
+}
+export interface TableBorder extends Border {
+    horizontal?: BorderDescr;
+    vertical?: BorderDescr;
+}
+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;
+}
+export type TableStyleTemplateName = "none" | "lightColoredText" | "lightAllBorders" | "mediumAllBorders" | "lightWithHeader" | "mediumBandedBorders" | "mediumMinimalBorders" | "darkNoBorders" | "mediumWhiteBorders" | "dark";

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[];
+}