@odoo/o-spreadsheet 19.2.11 → 19.3.2

package/dist/types/xlsx/conversion/conversion_maps.d.ts

@@ -0,0 +1,179 @@
+import { IconSetType } from "../../components/icons/icons";
+import { ExcelChartType, LegendPosition } from "../../types/chart";
+import { ConditionalFormattingOperatorValues, ThresholdType } from "../../types/conditional_formatting";
+import { AllowedImageMimeTypes } from "../../types/image";
+import { Align, BorderStyle, VerticalAlign } from "../../types/misc";
+import { ExcelIconSet, XLSXBorderStyle, XLSXCellType, XLSXCfOperatorType, XLSXCfType, XLSXCfValueObjectType, XLSXChartType, XLSXHorizontalAlignment, XLSXVerticalAlignment } from "../../types/xlsx";
+export declare const SUPPORTED_BORDER_STYLES: string[];
+export declare const SUPPORTED_HORIZONTAL_ALIGNMENTS: XLSXHorizontalAlignment[];
+export declare const SUPPORTED_VERTICAL_ALIGNMENTS: XLSXVerticalAlignment[];
+export declare const SUPPORTED_FONTS: string[];
+export declare const SUPPORTED_FILL_PATTERNS: string[];
+export declare const SUPPORTED_CF_TYPES: string[];
+/** Map between cell type in XLSX file and human readable cell type  */
+export declare const CELL_TYPE_CONVERSION_MAP: Record<string, XLSXCellType>;
+/** Conversion map Border Style in XLSX <=> Border style in o_spreadsheet*/
+export declare const BORDER_STYLE_CONVERSION_MAP: Record<XLSXBorderStyle, BorderStyle | undefined>;
+/** Conversion map Horizontal Alignment in XLSX <=> Horizontal Alignment in o_spreadsheet*/
+export declare const H_ALIGNMENT_CONVERSION_MAP: Record<XLSXHorizontalAlignment, Align>;
+/** Conversion map Vertical Alignment in XLSX => Vertical Alignment in o_spreadsheet */
+export declare const V_ALIGNMENT_CONVERSION_MAP: Record<XLSXVerticalAlignment, VerticalAlign>;
+/** Conversion map Vertical Alignment in o-spreadsheet => Vertical Alignment in XLSX */
+export declare const V_ALIGNMENT_EXPORT_CONVERSION_MAP: Record<Exclude<VerticalAlign, undefined>, XLSXVerticalAlignment>;
+/** Conversion map CF types in XLSX <=> Cf types in o_spreadsheet */
+export declare const CF_OPERATOR_TYPE_CONVERSION_MAP: Record<XLSXCfOperatorType, ConditionalFormattingOperatorValues | undefined>;
+/** Conversion map CF types in XLSX <=> Cf types in o_spreadsheet */
+export declare const CF_TYPE_CONVERSION_MAP: Record<XLSXCfType, ConditionalFormattingOperatorValues | undefined>;
+/** Conversion map CF thresholds types in XLSX <=> Cf thresholds types in o_spreadsheet */
+export declare const CF_THRESHOLD_CONVERSION_MAP: Record<XLSXCfValueObjectType, ThresholdType>;
+/**
+ * Conversion map between Excels IconSets and our own IconSets. The string is the key of the iconset in the ICON_SETS constant.
+ *
+ * NoIcons is undefined instead of an empty string because we don't support it and need to mange it separately.
+ */
+export declare const ICON_SET_CONVERSION_MAP: Record<ExcelIconSet, IconSetType | undefined>;
+/** Map between legend position in XLSX file and human readable position  */
+export declare const DRAWING_LEGEND_POSITION_CONVERSION_MAP: Record<string, LegendPosition>;
+/** Conversion map chart types in XLSX <=> Cf chart types o_spreadsheet (undefined for unsupported chart types)*/
+export declare const CHART_TYPE_CONVERSION_MAP: Record<XLSXChartType, ExcelChartType | undefined>;
+export declare const EXCEL_TO_SPREADSHEET_TRENDLINE_TYPE_MAPPING: {
+    readonly exp: "exponential";
+    readonly log: "logarithmic";
+    readonly poly: "polynomial";
+    readonly movingAvg: "trailingMovingAverage";
+};
+/** Conversion map for the SUBTOTAL(index, formula) function in xlsx, index <=> actual function*/
+export declare const SUBTOTAL_FUNCTION_CONVERSION_MAP: Record<number, string>;
+/** Mapping between Excel format indexes (see XLSX_FORMAT_MAP) and some supported formats  */
+export declare const XLSX_FORMATS_CONVERSION_MAP: Record<number, string | undefined>;
+/**
+ * Mapping format index to format defined by default
+ *
+ * OpenXML $18.8.30
+ * */
+export declare const XLSX_FORMAT_MAP: {
+    "0": number;
+    "0.00": number;
+    "#,#00": number;
+    "#,##0.00": number;
+    "0%": number;
+    "0.00%": number;
+    "0.00E+00": number;
+    "# ?/?": number;
+    "# ??/??": number;
+    "mm-dd-yy": number;
+    "d-mm-yy": number;
+    "mm-yy": number;
+    "mmm-yy": number;
+    "h:mm AM/PM": number;
+    "h:mm:ss AM/PM": number;
+    "h:mm": number;
+    "h:mm:ss": number;
+    "m/d/yy h:mm": number;
+    "#,##0 ;(#,##0)": number;
+    "#,##0 ;[Red](#,##0)": number;
+    "#,##0.00;(#,##0.00)": number;
+    "#,##0.00;[Red](#,##0.00)": number;
+    "mm:ss": number;
+    "[h]:mm:ss": number;
+    "mmss.0": number;
+    "##0.0E+0": number;
+    "@": number;
+    "hh:mm:ss a": number;
+};
+/** OpenXML $18.8.27 */
+export declare const XLSX_INDEXED_COLORS: {
+    0: string;
+    1: string;
+    2: string;
+    3: string;
+    4: string;
+    5: string;
+    6: string;
+    7: string;
+    8: string;
+    9: string;
+    10: string;
+    11: string;
+    12: string;
+    13: string;
+    14: string;
+    15: string;
+    16: string;
+    17: string;
+    18: string;
+    19: string;
+    20: string;
+    21: string;
+    22: string;
+    23: string;
+    24: string;
+    25: string;
+    26: string;
+    27: string;
+    28: string;
+    29: string;
+    30: string;
+    31: string;
+    32: string;
+    33: string;
+    34: string;
+    35: string;
+    36: string;
+    37: string;
+    38: string;
+    39: string;
+    40: string;
+    41: string;
+    42: string;
+    43: string;
+    44: string;
+    45: string;
+    46: string;
+    47: string;
+    48: string;
+    49: string;
+    50: string;
+    51: string;
+    52: string;
+    53: string;
+    54: string;
+    55: string;
+    56: string;
+    57: string;
+    58: string;
+    59: string;
+    60: string;
+    61: string;
+    62: string;
+    63: string;
+    64: string;
+    65: string;
+};
+type MimeExtensionMap = {
+    [key in (typeof AllowedImageMimeTypes)[number]]: string;
+};
+export declare const IMAGE_MIMETYPE_TO_EXTENSION_MAPPING: MimeExtensionMap;
+export declare const IMAGE_EXTENSION_TO_MIMETYPE_MAPPING: {
+    [K in keyof MimeExtensionMap as MimeExtensionMap[K]]: K;
+};
+export declare const XLSX_DV_DECIMAL_OPERATOR_MAPPING: {
+    readonly between: "isBetween";
+    readonly notBetween: "isNotBetween";
+    readonly equal: "isEqual";
+    readonly notEqual: "isNotEqual";
+    readonly greaterThan: "isGreaterThan";
+    readonly greaterThanOrEqual: "isGreaterOrEqualTo";
+    readonly lessThan: "isLessThan";
+    readonly lessThanOrEqual: "isLessOrEqualTo";
+};
+export declare const XLSX_DV_DATE_OPERATOR_TO_DV_TYPE_MAPPING: {
+    readonly between: "dateIsBetween";
+    readonly notBetween: "dateIsNotBetween";
+    readonly equal: "dateIs";
+    readonly greaterThan: "dateIsAfter";
+    readonly greaterThanOrEqual: "dateIsOnOrAfter";
+    readonly lessThan: "dateIsBefore";
+    readonly lessThanOrEqual: "dateIsOnOrBefore";
+};
+export {};

package/dist/types/xlsx/conversion/data_validation_conversion.d.ts

@@ -0,0 +1,4 @@
+import { DataValidationRuleData } from "../../types/workbook_data";
+import { XLSXDataValidation } from "../../types/xlsx";
+import { XLSXImportWarningManager } from "../helpers/xlsx_parser_error_manager";
+export declare function convertDataValidationRules(xlsxDataValidations: XLSXDataValidation[], warningManager: XLSXImportWarningManager): DataValidationRuleData[];

package/dist/types/xlsx/conversion/figure_conversion.d.ts

@@ -0,0 +1,3 @@
+import { FigureData } from "../../types/workbook_data";
+import { XLSXWorksheet } from "../../types/xlsx";
+export declare function convertFigures(sheetData: XLSXWorksheet): FigureData<any>[];

package/dist/types/xlsx/conversion/format_conversion.d.ts

@@ -0,0 +1,8 @@
+import { XLSXNumFormat } from "../../types/xlsx";
+import { XLSXImportWarningManager } from "../helpers/xlsx_parser_error_manager";
+/**
+ * Convert excel format to o_spreadsheet format
+ *
+ * Excel format are defined in openXML §18.8.31
+ */
+export declare function convertXlsxFormat(numFmtId: number, formats: XLSXNumFormat[], warningManager: XLSXImportWarningManager): string | undefined;

package/dist/types/xlsx/conversion/formula_conversion.d.ts

@@ -0,0 +1,9 @@
+import { XLSXImportData, XLSXSharedFormula, XLSXWorksheet } from "../../types/xlsx";
+export declare function convertFormulasContent(sheet: XLSXWorksheet, data: XLSXImportData): void;
+/**
+ * Transform a shared formula for the given target.
+ *
+ * This will compute the offset between the original cell of the shared formula and the target cell,
+ * then apply this offset to all the ranges in the formula (taking fixed references into account)
+ */
+export declare function adaptFormula(targetCell: string, sf: XLSXSharedFormula): string;

package/dist/types/xlsx/conversion/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./cf_conversion";
+export * from "./color_conversion";
+export * from "./conversion_maps";
+export * from "./figure_conversion";
+export * from "./sheet_conversion";
+export * from "./style_conversion";
+export * from "./table_conversion";

package/dist/types/xlsx/conversion/sheet_conversion.d.ts

@@ -0,0 +1,4 @@
+import { SheetData } from "../../types/workbook_data";
+import { XLSXImportData } from "../../types/xlsx";
+import { XLSXImportWarningManager } from "../helpers/xlsx_parser_error_manager";
+export declare function convertSheets(data: XLSXImportData, warningManager: XLSXImportWarningManager): SheetData[];

package/dist/types/xlsx/conversion/style_conversion.d.ts

@@ -0,0 +1,19 @@
+import { Border, Style } from "../../types/misc";
+import { XLSXCellAlignment, XLSXFill, XLSXFont, XLSXImportData } from "../../types/xlsx";
+import { XLSXImportWarningManager } from "../helpers/xlsx_parser_error_manager";
+interface StyleStruct {
+    fontStyle?: XLSXFont;
+    fillStyle?: XLSXFill;
+    alignment?: XLSXCellAlignment;
+}
+export declare function convertBorders(data: XLSXImportData, warningManager: XLSXImportWarningManager): {
+    [key: number]: Border;
+};
+export declare function convertStyles(data: XLSXImportData, warningManager: XLSXImportWarningManager): {
+    [key: number]: Style;
+};
+export declare function convertStyle(styleStruct: StyleStruct, warningManager: XLSXImportWarningManager): Style;
+export declare function convertFormats(data: XLSXImportData, warningManager: XLSXImportWarningManager): {
+    [key: number]: string;
+};
+export {};

package/dist/types/xlsx/conversion/table_conversion.d.ts

@@ -0,0 +1,8 @@
+import { WorkbookData } from "../../types/workbook_data";
+import { XLSXImportData } from "../../types/xlsx";
+/**
+ * Convert the imported XLSX tables and pivots convert the table-specific formula references into standard references.
+ *
+ * Change the converted data in-place.
+ */
+export declare function convertTables(convertedData: WorkbookData, xlsxData: XLSXImportData): void;

package/dist/types/xlsx/extraction/base_extractor.d.ts

@@ -0,0 +1,141 @@
+import { XLSXColor, XLSXFileStructure, XLSXImageFile, XLSXImportFile, XLSXRel, XLSXTheme, XMLFile } from "../../types/xlsx";
+import { XLSXImportWarningManager } from "../helpers/xlsx_parser_error_manager";
+interface MapOnElementArgs {
+    query: string;
+    parent: Element | XMLDocument;
+    children?: boolean;
+}
+interface ExtractArg {
+    required?: boolean;
+    default?: string | boolean | number;
+}
+declare class AttributeValue {
+    private readonly value;
+    constructor(value: string | boolean | number);
+    asString(): string;
+    asBool(): boolean;
+    asNum(): number;
+}
+type ExtractAttrType<T> = T extends {
+    required: true;
+} | {
+    default: string | number | boolean;
+} ? AttributeValue : AttributeValue | undefined;
+type ExtractTextType<T> = T extends {
+    required: true;
+} | {
+    default: string | number | boolean;
+} ? string : string | undefined;
+export declare class XlsxBaseExtractor {
+    protected rootFile: XLSXImportFile;
+    protected xlsxFileStructure: XLSXFileStructure;
+    protected warningManager: XLSXImportWarningManager;
+    protected relationships: Record<string, XLSXRel>;
+    protected currentFile: string | undefined;
+    /**
+     * /!\ Important : There should be no namespaces in the tags of the XML files.
+     *
+     * This class use native querySelector and querySelectorAll, that's used for HTML (not XML). These aren't supposed to
+     * handled namespaces, as they are not supported by the HTML specification. Some implementations (most browsers) do
+     * actually support namespaces, but some don't (e.g. jsdom).
+     *
+     * The namespace should be escaped as with NAMESPACE string (eg. <t:foo> => <NAMESPACEtNAMESPACEfoo>).
+     */
+    constructor(rootFile: XLSXImportFile, xlsxStructure: XLSXFileStructure, warningManager: XLSXImportWarningManager);
+    /**
+     * Extract all the relationships inside a .xml.rels file
+     */
+    protected extractRelationships(relFile: XMLFile): XLSXRel[];
+    /**
+     * Get the list of all the XLSX files in the XLSX file structure
+     */
+    protected getListOfXMLFiles(): XLSXImportFile[];
+    /**
+     * Return an array containing the return value of the given function applied to all the XML elements
+     * found using the MapOnElementArgs.
+     *
+     * The arguments contains :
+     *  - query : a QuerySelector string to find the elements to apply the function to
+     *  - parent : an XML element or XML document in which to find the queried elements
+     *  - children : if true, the function is applied on the direct children of the queried element
+     *
+     * This method will also handle the errors thrown in the argument function.
+     */
+    protected mapOnElements<T>(args: MapOnElementArgs, fct: (e: Element) => T): T[];
+    /**
+     * Log an error caught when parsing an element in the warningManager.
+     */
+    protected catchErrorOnElement(error: Error, onElement?: Element): void;
+    /**
+     * Extract an attribute from an Element.
+     *
+     * If the attribute is required but was not found, will add a warning in the warningManager if it was given a default
+     * value, and throw an error if no default value was given.
+     *
+     * Can only return undefined value for non-required attributes without default value.
+     */
+    protected extractAttr<T extends ExtractArg>(e: Element, attName: string, optionalArgs?: T): ExtractAttrType<T>;
+    /**
+     * Extract the text content of an Element.
+     *
+     * If the text content is required but was not found, will add a warning in the warningManager if it was given a default
+     * value, and throw an error if no default value was given.
+     *
+     * Can only return undefined value for non-required text content without default value.
+     */
+    protected extractTextContent<T extends ExtractArg>(element: Element, optionalArgs?: T): ExtractTextType<T>;
+    /**
+     * Extract an attribute of a child of the given element.
+     *
+     * The reference of a child can be a string (tag of the child) or an number (index in the list of children of the element)
+     *
+     * If the attribute is required but either the attribute or the referenced child element was not found, it will
+     * will add a warning in the warningManager if it was given a default value, and throw an error if no default value was given.
+     *
+     * Can only return undefined value for non-required attributes without default value.
+     */
+    protected extractChildAttr<T extends ExtractArg>(e: Element, childRef: string | number, attName: string, optionalArgs?: T): ExtractAttrType<T>;
+    /**
+     * Extract the text content of a child of the given element.
+     *
+     * If the text content is required but either the text content or the referenced child element was not found, it will
+     * will add a warning in the warningManager if it was given a default value, and throw an error if no default value was given.
+     *
+     * Can only return undefined value for non-required text content without default value.
+     */
+    protected extractChildTextContent<T extends ExtractArg>(e: Element, childRef: string, optionalArgs?: T): ExtractTextType<T>;
+    /**
+     * Should be called if a extractAttr/extractTextContent doesn't find the element it needs to extract.
+     *
+     * If the extractable was required, this function will add a warning in the warningManager if there was a default value,
+     * and throw an error if no default value was given.
+     */
+    private handleMissingValue;
+    /**
+     * Extract a color, extracting it from the theme if needed.
+     *
+     * Will throw an error if the element references a theme, but no theme was provided or the theme it doesn't contain the color.
+     */
+    protected extractColor<T extends string | undefined>(colorElement: Element | null, theme: XLSXTheme | undefined, defaultColor?: T): T extends string ? XLSXColor : XLSXColor | undefined;
+    /**
+     * Returns the xml file targeted by a relationship.
+     */
+    protected getTargetXmlFile(relationship: XLSXRel): XLSXImportFile;
+    /**
+     * Returns the image parameters targeted by a relationship.
+     */
+    protected getTargetImageFile(relationship: XLSXRel): XLSXImageFile;
+    protected querySelector(element: Element | Document, query: string): Element | null;
+    protected querySelectorAll(element: Element | Document, query: string): NodeListOf<Element>;
+    /**
+     * Get a color from its id in the Theme's colorScheme.
+     *
+     * Note that Excel don't use the colors from the theme but from its own internal theme, so the displayed
+     * colors will be different in the import than in excel.
+     * .
+     */
+    private getThemeColor;
+    /** Remove signs of relative path. */
+    private processRelationshipTargetName;
+}
+export {};

package/dist/types/xlsx/extraction/cf_extractor.d.ts

@@ -0,0 +1,15 @@
+import { XLSXConditionalFormat, XLSXFileStructure, XLSXImportFile, XLSXTheme } from "../../types/xlsx";
+import { XLSXImportWarningManager } from "../helpers/xlsx_parser_error_manager";
+import { XlsxBaseExtractor } from "./base_extractor";
+export declare class XlsxCfExtractor extends XlsxBaseExtractor {
+    theme?: XLSXTheme;
+    constructor(sheetFile: XLSXImportFile, xlsxStructure: XLSXFileStructure, warningManager: XLSXImportWarningManager, theme: XLSXTheme | undefined);
+    extractConditionalFormattings(): XLSXConditionalFormat[];
+    private extractCFRules;
+    private extractCfFormula;
+    private extractCfColorScale;
+    private extractCfDataBar;
+    private extractCfIconSet;
+    private extractCfIcons;
+    private extractCFVos;
+}

package/dist/types/xlsx/extraction/chart_extractor.d.ts

@@ -0,0 +1,15 @@
+import { ExcelChartDefinition } from "../../types/chart";
+import { XlsxBaseExtractor } from "./base_extractor";
+export declare class XlsxChartExtractor extends XlsxBaseExtractor {
+    extractChart(): ExcelChartDefinition | undefined;
+    private extractLabelRange;
+    private extractComboChart;
+    private extractChartDatasets;
+    private extractChartTrendline;
+    private extractScatterChartDatasets;
+    /**
+     * The chart type in the XML isn't explicitly defined, but there is an XML element that define the
+     * chart, and this element tag name tells us which type of chart it is. We just need to find this XML element.
+     */
+    private getChartType;
+}

package/dist/types/xlsx/extraction/data_validation_extractor.d.ts

@@ -0,0 +1,9 @@
+import { XLSXDataValidation, XLSXFileStructure, XLSXImportFile, XLSXTheme } from "../../types/xlsx";
+import { XLSXImportWarningManager } from "../helpers/xlsx_parser_error_manager";
+import { XlsxBaseExtractor } from "./base_extractor";
+export declare class XlsxDataValidationExtractor extends XlsxBaseExtractor {
+    theme?: XLSXTheme;
+    constructor(sheetFile: XLSXImportFile, xlsxStructure: XLSXFileStructure, warningManager: XLSXImportWarningManager, theme: XLSXTheme | undefined);
+    extractDataValidations(): XLSXDataValidation[];
+    private extractDataValidationFormula;
+}

package/dist/types/xlsx/extraction/external_book_extractor.d.ts

@@ -0,0 +1,6 @@
+import { XLSXExternalBook } from "../../types/xlsx";
+import { XlsxBaseExtractor } from "./base_extractor";
+export declare class XlsxExternalBookExtractor extends XlsxBaseExtractor {
+    getExternalBook(): XLSXExternalBook;
+    private extractExternalSheetData;
+}

package/dist/types/xlsx/extraction/figure_extractor.d.ts

@@ -0,0 +1,10 @@
+import { XLSXFigure } from "../../types/xlsx";
+import { XlsxBaseExtractor } from "./base_extractor";
+export declare class XlsxFigureExtractor extends XlsxBaseExtractor {
+    extractFigures(): XLSXFigure[];
+    private extractFigureAnchorsByType;
+    private extractFigureSizeFromSizeTag;
+    private extractFigureAnchor;
+    private extractChart;
+    private extractImage;
+}

package/dist/types/xlsx/extraction/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./misc_extractor";
+export * from "./sheet_extractor";
+export * from "./style_extractor";

package/dist/types/xlsx/extraction/misc_extractor.d.ts

@@ -0,0 +1,18 @@
+import { XLSXTheme } from "../../types/xlsx";
+import { XlsxBaseExtractor } from "./base_extractor";
+/**
+ * XLSX Extractor class that can be used for either sharedString XML files or theme XML files.
+ *
+ * Since they both are quite simple, it make sense to make a single class to manage them all, to avoid unnecessary file
+ * cluttering.
+ */
+export declare class XlsxMiscExtractor extends XlsxBaseExtractor {
+    getTheme(): XLSXTheme;
+    /**
+     * Get the array of shared strings of the XLSX.
+     *
+     * Worth noting that running a prettier on the xml can mess up some strings, since there is an option in the
+     * xmls to keep the spacing and not trim the string.
+     */
+    getSharedStrings(): string[];
+}

package/dist/types/xlsx/extraction/pivot_extractor.d.ts

@@ -0,0 +1,10 @@
+import { XLSXPivotTable } from "../../types/xlsx";
+import { XlsxBaseExtractor } from "./base_extractor";
+/**
+ * We don't really support pivot tables, we'll just extract them as Tables.
+ */
+export declare class XlsxPivotExtractor extends XlsxBaseExtractor {
+    getPivotTable(): XLSXPivotTable;
+    private extractPivotLocation;
+    private extractPivotStyleInfo;
+}

package/dist/types/xlsx/extraction/sheet_extractor.d.ts

@@ -0,0 +1,27 @@
+import { XLSXFileStructure, XLSXImportFile, XLSXTheme, XLSXWorksheet } from "../../types/xlsx";
+import { XLSXImportWarningManager } from "../helpers/xlsx_parser_error_manager";
+import { XlsxBaseExtractor } from "./base_extractor";
+export declare class XlsxSheetExtractor extends XlsxBaseExtractor {
+    theme?: XLSXTheme;
+    constructor(sheetFile: XLSXImportFile, xlsxStructure: XLSXFileStructure, warningManager: XLSXImportWarningManager, theme: XLSXTheme | undefined);
+    getSheet(): XLSXWorksheet;
+    private extractSheetViews;
+    private extractSheetName;
+    private getSheetWorkbookInfo;
+    private extractConditionalFormats;
+    private extractDataValidations;
+    private extractFigures;
+    private extractTables;
+    private extractPivotTables;
+    private extractMerges;
+    private extractSheetFormat;
+    private extractSheetProperties;
+    private extractSheetOutlineProperties;
+    private extractCols;
+    private extractRows;
+    private extractCells;
+    private extractCellFormula;
+    private extractHyperLinks;
+    private extractSharedFormulas;
+    private extractProtection;
+}

package/dist/types/xlsx/extraction/style_extractor.d.ts

@@ -0,0 +1,19 @@
+import { XLSXBorder, XLSXDxf, XLSXFileStructure, XLSXFill, XLSXFont, XLSXNumFormat, XLSXStyle, XLSXTheme } from "../../types/xlsx";
+import { XLSXImportWarningManager } from "../helpers/xlsx_parser_error_manager";
+import { XlsxBaseExtractor } from "./base_extractor";
+export declare class XlsxStyleExtractor extends XlsxBaseExtractor {
+    theme?: XLSXTheme;
+    constructor(xlsxStructure: XLSXFileStructure, warningManager: XLSXImportWarningManager, theme: XLSXTheme | undefined);
+    getNumFormats(): XLSXNumFormat[];
+    private extractNumFormats;
+    getFonts(): XLSXFont[];
+    private extractFont;
+    getFills(): XLSXFill[];
+    private extractFill;
+    getBorders(): XLSXBorder[];
+    private extractBorder;
+    private extractSingleBorder;
+    private extractAlignment;
+    getDxfs(): XLSXDxf[];
+    getStyles(): XLSXStyle[];
+}

package/dist/types/xlsx/extraction/table_extractor.d.ts

@@ -0,0 +1,10 @@
+import { XLSXTable } from "../../types/xlsx";
+import { XlsxBaseExtractor } from "./base_extractor";
+export declare class XlsxTableExtractor extends XlsxBaseExtractor {
+    getTable(): XLSXTable;
+    private extractTableCols;
+    private extractTableStyleInfo;
+    private extractTableAutoFilter;
+    private extractFilterColumns;
+    private extractSimpleFilter;
+}

package/dist/types/xlsx/functions/cells.d.ts

@@ -0,0 +1,11 @@
+import { CellValue } from "../../types/cells";
+import { XMLAttributes, XMLString } from "../../types/xlsx";
+export declare function addFormula(formula: string | undefined, value: CellValue, formulaSpillRange: string): {
+    attrs: XMLAttributes;
+    node: XMLString;
+};
+export declare function addContent(content: string, sharedStrings: string[], forceString?: boolean): {
+    attrs: XMLAttributes;
+    node: XMLString;
+};
+export declare function adaptFormulaToExcel(formulaText: string): string;

package/dist/types/xlsx/functions/charts.d.ts

@@ -0,0 +1,3 @@
+import { ExcelChartDefinition } from "../../types/chart";
+import { ExcelWorkbookData, FigureData } from "../../types/workbook_data";
+export declare function createChart(chart: FigureData<ExcelChartDefinition>, chartSheetIndex: string, data: ExcelWorkbookData): XMLDocument;

package/dist/types/xlsx/functions/conditional_formatting.d.ts

@@ -0,0 +1,3 @@
+import { ConditionalFormat } from "../../types/conditional_formatting";
+import { XLSXDxf, XMLString } from "../../types/xlsx";
+export declare function addConditionalFormatting(dxfs: XLSXDxf[], conditionalFormats: ConditionalFormat[]): XMLString[];

package/dist/types/xlsx/functions/data_validation.d.ts

@@ -0,0 +1,3 @@
+import { DataValidationRuleData } from "../../types/workbook_data";
+import { XMLString } from "../../types/xlsx";
+export declare function addDataValidationRules(dataValidationRules: DataValidationRuleData[]): XMLString[];

package/dist/types/xlsx/functions/drawings.d.ts

@@ -0,0 +1,5 @@
+import { ExcelChartDefinition } from "../../types/chart";
+import { Image } from "../../types/image";
+import { FigureData, SheetData } from "../../types/workbook_data";
+import { XLSXStructure } from "../../types/xlsx";
+export declare function createDrawing(drawingRelIds: string[], sheet: SheetData, figures: FigureData<ExcelChartDefinition | Image>[], construct: XLSXStructure): XMLDocument;

package/dist/types/xlsx/functions/sheet_protection.d.ts

@@ -0,0 +1,2 @@
+import { ExcelSheetData } from "../../types/workbook_data";
+export declare function addSheetProtection(sheet: ExcelSheetData): "" | import("../../types/xlsx").XMLString;

package/dist/types/xlsx/functions/styles.d.ts

@@ -0,0 +1,10 @@
+import { XLSXBorder, XLSXDxf, XLSXFill, XLSXFont, XLSXNumFormat, XLSXStyle, XMLString } from "../../types/xlsx";
+export declare function addNumberFormats(numFmts: XLSXNumFormat[]): XMLString;
+export declare function addFonts(fonts: XLSXFont[]): XMLString;
+export declare function addFills(fills: XLSXFill[]): XMLString;
+export declare function addBorders(borders: XLSXBorder[]): XMLString;
+export declare function addStyles(styles: XLSXStyle[]): XMLString;
+/**
+ * DXFS : Differential Formatting Records - Conditional formats
+ */
+export declare function addCellWiseConditionalFormatting(dxfs: XLSXDxf[]): XMLString;

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

@@ -0,0 +1,2 @@
+import { ExcelSheetData, ExcelTableData } from "../../types/workbook_data";
+export declare function createTable(table: ExcelTableData, tableId: number, sheetData: ExcelSheetData): XMLDocument;

package/dist/types/xlsx/functions/worksheet.d.ts

@@ -0,0 +1,10 @@
+import { ExcelHeaderData, ExcelSheetData, ExcelWorkbookData } from "../../types/workbook_data";
+import { XLSXStructure, XMLString } from "../../types/xlsx";
+export declare function addColumns(cols: {
+    [key: number]: ExcelHeaderData;
+}): XMLString;
+export declare function addRows(construct: XLSXStructure, data: ExcelWorkbookData, sheet: ExcelSheetData): XMLString;
+export declare function addHyperlinks(construct: XLSXStructure, data: ExcelWorkbookData, sheetIndex: string): XMLString;
+export declare function addMerges(merges: string[]): XMLString;
+export declare function addSheetViews(sheet: ExcelSheetData): XMLString;
+export declare function addSheetProperties(sheet: ExcelSheetData): "" | XMLString;

package/dist/types/xlsx/helpers/colors.d.ts

@@ -0,0 +1,8 @@
+import { Color } from "../../types/misc";
+import { XlsxHexColor } from "../../types/xlsx";
+/**
+ * Convert a JS color hexadecimal to an excel compatible color.
+ *
+ * In Excel the color don't start with a '#' and the format is AARRGGBB instead of RRGGBBAA
+ */
+export declare function toXlsxHexColor(color: Color): XlsxHexColor;