pixel-react 1.7.1 → 1.7.3

package/lib/components/ExcelFile/ExcelFile/Excel/matrix.d.ts

@@ -0,0 +1,67 @@
+import * as Point from './point';
+/** A two-dimensional array of given type T in rows and columns */
+export type Matrix<T> = Array<Array<T | undefined>>;
+/**
+ * Creates an empty matrix with given rows and columns
+ * @param rows - integer, the amount of rows the matrix should have
+ * @param columns - integer, the amount of columns the matrix should have
+ * @returns an empty matrix with given rows and columns
+ */
+export declare function createEmpty<T>(rows: number, columns: number): Matrix<T>;
+/** Gets the value at row and column of matrix. */
+export declare function get<T>(point: Point.Point, matrix: Matrix<T>): T | undefined;
+/** Creates a slice of matrix from startPoint up to, but not including, endPoint. */
+export declare function slice<T>(startPoint: Point.Point, endPoint: Point.Point, matrix: Matrix<T>): Matrix<T>;
+/** Sets the value at row and column of matrix. If a row doesn't exist, it's created. */
+export declare function set<T>(point: Point.Point, value: T, matrix: Matrix<T>): Matrix<T>;
+/** Like Matrix.set() but mutates the matrix */
+export declare function mutableSet<T>(point: Point.Point, value: T, matrix: Matrix<T>): void;
+/** Removes the coordinate of matrix */
+export declare function unset<T>(point: Point.Point, matrix: Matrix<T>): Matrix<T>;
+/** Creates an array of values by running each element in collection thru iteratee. */
+export declare function map<T, T2>(func: (value: T | undefined, point: Point.Point) => T2, matrix: Matrix<T>): Matrix<T2>;
+/** Create an iterator over the cells in the matrix */
+export declare function entries<T>(matrix: Matrix<T>): IterableIterator<[Point.Point, T | undefined]>;
+/**
+ * Converts all elements in row into a string separated by horizontalSeparator and each row string
+ * to string separated by verticalSeparator
+ */
+export declare function join(matrix: Matrix<unknown>, horizontalSeparator?: string, verticalSeparator?: string): string;
+/**
+ * Parses a CSV separated by a horizontalSeparator and verticalSeparator into a
+ * Matrix using a transform function
+ */
+export declare function split<T>(csv: string, transform: (value: string) => T, horizontalSeparator?: string, verticalSeparator?: string | RegExp): Matrix<T>;
+/** Returns whether the point exists in the matrix or not. */
+export declare function has(point: Point.Point, matrix: Matrix<unknown>): boolean;
+/** Counts of the rows and column in a matrix */
+export type Size = {
+    /** Count of the rows in the matrix */
+    rows: number;
+    /** Count of the columns in the matrix */
+    columns: number;
+};
+/** Gets the count of rows and columns of given matrix */
+export declare function getSize(matrix: Matrix<unknown>): Size;
+/** Gets the count of rows of given matrix */
+export declare function getRowsCount(matrix: Matrix<unknown>): number;
+/** Gets the count of columns of given matrix */
+export declare function getColumnsCount(matrix: Matrix<unknown>): number;
+/**
+ * Pads matrix with empty rows to match given total rows
+ * @param matrix - matrix to pad
+ * @param totalRows - number of rows the matrix should have
+ * @returns the updated matrix
+ */
+export declare function padRows<T>(matrix: Matrix<T>, totalRows: number): Matrix<T>;
+/**
+ * Pads matrix with empty columns to match given total columns
+ * @param matrix - matrix to pad
+ * @param size - minimum size of the matrix after padding.
+ * @returns the updated matrix
+ */
+export declare function pad<T>(matrix: Matrix<T>, size: Size): Matrix<T>;
+export declare function toArray<T>(matrix: Matrix<T>): T[];
+export declare function toArray<T1, T2>(matrix: Matrix<T1>, transform: (cell: T1 | undefined, coords: Point.Point) => T2): T2[];
+/** Returns the maximum point in the matrix */
+export declare function maxPoint(matrix: Matrix<unknown>): Point.Point;

package/lib/components/ExcelFile/ExcelFile/Excel/point-range.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Interface for ranges between two points
+ */
+import * as Point from './point';
+/** Range between two points. Creates a normalized range between two given points */
+export declare class PointRange {
+    /** The top-left point */
+    start: Point.Point;
+    /** The bottom-right point */
+    end: Point.Point;
+    constructor(source: Point.Point, target: Point.Point);
+    /** Iterates through all the existing points in given range */
+    [Symbol.iterator](): Iterator<Point.Point>;
+    /** Returns the size (rows x columns) of the given range */
+    size(): number;
+    /** Returns whether given point exists in given range */
+    has(point: Point.Point): boolean;
+    /** Limits given masked range with given mask */
+    mask(mask: PointRange): PointRange;
+    /** Returns whether given range is equal to this range */
+    equals(range: PointRange): boolean;
+}

package/lib/components/ExcelFile/ExcelFile/Excel/point.d.ts

@@ -0,0 +1,11 @@
+/** A cell coordinates in the spreadsheet */
+export type Point = {
+    /** The cell's column */
+    column: number;
+    /** The cell's row */
+    row: number;
+};
+/** Return whether two given points are the equal */
+export declare function isEqual(source: Point, target: Point): boolean;
+/** The origin point in matrices */
+export declare const ORIGIN: Point;

package/lib/components/ExcelFile/ExcelFile/Excel/reducer.d.ts

@@ -0,0 +1,27 @@
+import * as Matrix from './matrix';
+import * as Types from './types';
+import * as Point from './point';
+import { Selection, RangeSelection, EntireColumnsSelection, EntireRowsSelection } from './selection';
+import * as Actions from './actions';
+export declare const INITIAL_STATE: Types.StoreState;
+export default function reducer(state: Types.StoreState, action: Actions.Action): Types.StoreState;
+export declare const go: (rowDelta: number, columnDelta: number) => KeyDownHandler;
+export type KeyDownHandler = (state: Types.StoreState, event: React.KeyboardEvent) => Types.StoreState | void;
+export declare enum Direction {
+    Left = "Left",
+    Right = "Right",
+    Top = "Top",
+    Bottom = "Bottom"
+}
+export declare function getKeyDownHandler(state: Types.StoreState, event: React.KeyboardEvent): KeyDownHandler | undefined;
+/** Returns whether the reducer has a handler for the given keydown event */
+export declare function hasKeyDownHandler(state: Types.StoreState, event: React.KeyboardEvent): boolean;
+/** Returns whether the active cell is read only */
+export declare function isActiveReadOnly(state: Types.StoreState): boolean;
+/** Gets active cell from given state */
+export declare function getActive(state: Types.StoreState): Types.CellBase | null;
+/** Modify given edge according to given active point and data */
+export declare function modifyEdge<T extends Selection>(selection: T, active: Point.Point | null, data: Matrix.Matrix<unknown>, direction: Direction): T;
+export declare function modifyRangeSelectionEdge(rangeSelection: RangeSelection, active: Point.Point, data: Matrix.Matrix<unknown>, edge: Direction): RangeSelection;
+export declare function modifyEntireRowsSelection(selection: EntireRowsSelection, active: Point.Point, data: Matrix.Matrix<unknown>, edge: Direction): EntireRowsSelection;
+export declare function modifyEntireColumnsSelection(selection: EntireColumnsSelection, active: Point.Point, data: Matrix.Matrix<unknown>, edge: Direction): EntireColumnsSelection;

package/lib/components/ExcelFile/ExcelFile/Excel/selection.d.ts

@@ -0,0 +1,95 @@
+import { PointRange } from './point-range';
+import * as Point from './point';
+import * as Matrix from './matrix';
+/** Selection from a spreadsheet */
+export declare abstract class Selection {
+    /** Get concrete range of the selection in the given data */
+    abstract toRange(data: Matrix.Matrix<unknown>): PointRange | null;
+    /** Normalize the selection according to the given data */
+    abstract normalizeTo(data: Matrix.Matrix<unknown>): this;
+    /** Determines whether the given row is entirely selected in given selection */
+    abstract hasEntireRow(row: number): boolean;
+    /** Determines whether the given column is entirely selected in given selection */
+    abstract hasEntireColumn(column: number): boolean;
+    /** Get the number of selected points according to given data */
+    abstract size(data: Matrix.Matrix<unknown>): number;
+    /** Determines whether the given point is within the selection */
+    abstract has(data: Matrix.Matrix<unknown>, point: Point.Point): boolean;
+    /** Determines whether the given selection is equal to this selection */
+    abstract equals(selection: Selection): boolean;
+}
+/** Selection of no cells */
+export declare class EmptySelection extends Selection {
+    toRange(data: Matrix.Matrix<unknown>): PointRange | null;
+    normalizeTo(_: Matrix.Matrix<unknown>): this;
+    hasEntireRow(): boolean;
+    hasEntireColumn(): boolean;
+    size(): number;
+    has(): boolean;
+    equals(selection: Selection): boolean;
+}
+/** Selection of a range of cells */
+export declare class RangeSelection extends Selection {
+    range: PointRange;
+    constructor(range: PointRange);
+    toRange(_: Matrix.Matrix<unknown>): PointRange | null;
+    normalizeTo(data: Matrix.Matrix<unknown>): this;
+    hasEntireRow(): boolean;
+    hasEntireColumn(): boolean;
+    size(data: Matrix.Matrix<unknown>): number;
+    has(data: Matrix.Matrix<unknown>, point: Point.Point): boolean;
+    equals(selection: Selection): boolean;
+}
+/** Selection of an entire part of the spreadsheet */
+export declare abstract class EntireSelection extends Selection {
+}
+/** Selection of the entire worksheet */
+export declare class EntireWorksheetSelection extends EntireSelection {
+    toRange(data: Matrix.Matrix<unknown>): PointRange;
+    normalizeTo(): this;
+    hasEntireColumn(): boolean;
+    hasEntireRow(): boolean;
+    size(data: Matrix.Matrix<unknown>): number;
+    has(): boolean;
+    equals(selection: Selection): boolean;
+}
+/** Selection of an entire axis in the spreadsheet */
+export declare abstract class EntireAxisSelection extends EntireSelection {
+    /** Selection start index, integer */
+    readonly start: number;
+    /** Selection end index, integer */
+    readonly end: number;
+    /**
+     * @param start - row index where the selection starts, integer
+     * @param end - row index where the selection ends, integer
+     * @throws {@link InvalidIndexError}
+     */
+    constructor(start: number, end: number);
+    equals(selection: Selection): boolean;
+}
+/** Selection of entire rows in the spreadsheet */
+export declare class EntireRowsSelection extends EntireAxisSelection {
+    toRange(data: Matrix.Matrix<unknown>): PointRange;
+    normalizeTo(data: Matrix.Matrix<unknown>): this;
+    hasEntireRow(row: number): boolean;
+    hasEntireColumn(): boolean;
+    size(data: Matrix.Matrix<unknown>): number;
+    has(_: Matrix.Matrix<unknown>, point: Point.Point): boolean;
+}
+/** Selection of entire columns in the spreadsheet */
+export declare class EntireColumnsSelection extends EntireAxisSelection {
+    toRange(data: Matrix.Matrix<unknown>): PointRange;
+    normalizeTo(data: Matrix.Matrix<unknown>): this;
+    hasEntireRow(): boolean;
+    hasEntireColumn(column: number): boolean;
+    size(data: Matrix.Matrix<unknown>): number;
+    has(_: Matrix.Matrix<unknown>, point: Point.Point): boolean;
+}
+/** Get the point range of given matrix */
+export declare function getMatrixRange(data: Matrix.Matrix<unknown>): PointRange;
+/** Determines whether the given value is a valid index */
+export declare function isIndex(value: number): boolean;
+/** Error thrown when passing a non-index value where an index value is expected */
+export declare class InvalidIndexError extends Error {
+    constructor(name: string);
+}

package/lib/components/ExcelFile/ExcelFile/Excel/types.d.ts

@@ -0,0 +1,178 @@
+import * as React from 'react';
+import FormulaParser from 'fast-formula-parser';
+import { Point } from './point';
+import { Selection } from './selection';
+import { Model } from './engine';
+import { PointRange } from './point-range';
+import { Matrix } from './matrix';
+/** The base type of cell data in Spreadsheet */
+export type CellBase<Value = any> = {
+    /** Whether the cell should not be editable */
+    readOnly?: boolean;
+    /** Class to be given for the cell element */
+    className?: string;
+    /** The value of the cell */
+    value: Value;
+    style?: React.CSSProperties | undefined;
+    type?: boolean;
+    /** Custom component to render when the cell is edited, if not defined would default to the component defined for the Spreadsheet */
+    DataEditor?: DataEditorComponent<CellBase<Value>>;
+    /** Custom component to render when the cell is viewed, if not defined would default to the component defined for the Spreadsheet */
+    DataViewer?: DataViewerComponent<CellBase<Value>>;
+};
+/**
+ * A cell with it's coordinates
+ * @deprecated the component does not use cell descriptors anymore. Instead it passes cell point and cell value explicitly.
+ */
+export type CellDescriptor<Cell extends CellBase> = {
+    /** The cell's data */
+    data: Cell | undefined;
+} & Point;
+/** The spreadsheet's write mode */
+export type Mode = 'view' | 'edit';
+/** Dimensions of an element */
+export type Dimensions = {
+    /** The element's width in pixels */
+    width: number;
+    /** The element's height in pixels */
+    height: number;
+    /** The distance of the element from it's container top border in pixels */
+    top: number;
+    /** The distance of the element from it's container left border in pixels */
+    left: number;
+};
+export type StoreState<Cell extends CellBase = CellBase> = {
+    model: Model<Cell>;
+    selected: Selection;
+    copied: PointRange | null;
+    hasPasted: boolean;
+    cut: boolean;
+    active: Point | null;
+    mode: Mode;
+    rowDimensions: Record<number, Pick<Dimensions, 'height' | 'top'> | undefined>;
+    columnDimensions: Record<number, Pick<Dimensions, 'width' | 'left'> | undefined>;
+    dragging: boolean;
+    lastChanged: Point | null;
+    lastCommit: null | CellChange<Cell>[];
+};
+export type CellChange<Cell extends CellBase = CellBase> = {
+    prevCell: Cell | null;
+    nextCell: Cell | null;
+};
+/** Type of Spreadsheet Cell component props */
+export type CellComponentProps<Cell extends CellBase = CellBase> = {
+    /** The row of the cell */
+    row: number;
+    /** The column of the cell */
+    column: number;
+    /** The DataViewer component to be used by the cell */
+    DataViewer: DataViewerComponent<Cell>;
+    /** Whether the cell is selected */
+    selected: boolean;
+    /** Whether the cell is active */
+    active: boolean;
+    /** Whether the cell is copied */
+    copied: boolean;
+    /** Whether the user is dragging */
+    dragging: boolean;
+    /** The mode of the cell */
+    mode: Mode;
+    /** The data of the cell */
+    data: Cell | undefined;
+    /** The evaluated data of the cell */
+    evaluatedData: Cell | undefined;
+    /** Select the cell at the given point */
+    select: (point: Point) => void;
+    /** Activate the cell at the given point */
+    activate: (point: Point) => void;
+    /** Set the dimensions of the cell at the given point with the given dimensions */
+    setCellDimensions: (point: Point, dimensions: Dimensions) => void;
+    /** Set data of the cell */
+    setCellData: (cell: Cell) => void;
+};
+/** Type of the Spreadsheet Cell component */
+export type CellComponent<Cell extends CellBase = CellBase> = React.ComponentType<CellComponentProps<Cell>>;
+type DataComponentProps<Cell extends CellBase> = {
+    /** The rendered cell by the component */
+    cell: Cell | undefined;
+} & Point;
+/** Type of the Spreadsheet DataViewer component props */
+export type DataViewerProps<Cell extends CellBase = CellBase> = DataComponentProps<Cell> & {
+    /** Set data of the cell */
+    setCellData: (cell: Cell) => void;
+    evaluatedCell: Cell | undefined;
+};
+/** Type of the Spreadsheet DataViewer component */
+export type DataViewerComponent<Cell extends CellBase = CellBase> = React.ComponentType<DataViewerProps<Cell>>;
+/** Type of the Spreadsheet DataEditor component props */
+export type DataEditorProps<Cell extends CellBase = CellBase> = DataComponentProps<Cell> & {
+    /** Callback to be called when the cell's value is changed */
+    onChange: (cell: Cell) => void;
+    /** Callback to be called when edit mode should be exited */
+    exitEditMode: () => void;
+};
+/** Type of the Spreadsheet DataEditor component */
+export type DataEditorComponent<Cell extends CellBase = CellBase> = React.ComponentType<DataEditorProps<Cell>>;
+/** Type of the Spreadsheet Table component props */
+export type TableProps = React.PropsWithChildren<{
+    /** Number of columns the table should render */
+    columns: number;
+    /** Whether column indicators are hidden */
+    hideColumnIndicators?: boolean | null;
+}>;
+/** Type of the Spreadsheet Table component */
+export type TableComponent = React.ComponentType<TableProps>;
+/** Type of the Spreadsheet Row component props */
+export type RowProps = React.PropsWithChildren<{
+    /** The row index of the table */
+    row: number;
+}>;
+/** Type of the Row component */
+export type RowComponent = React.ComponentType<RowProps>;
+/** Type of the Spreadsheet HeaderRow component props */
+export type HeaderRowProps = React.PropsWithChildren<{}>;
+/** Type of the HeaderRow component */
+export type HeaderRowComponent = React.ComponentType<HeaderRowProps>;
+/** Type of the Spreadsheet RowIndicator component props */
+export type RowIndicatorProps = {
+    /** The row the indicator indicates */
+    row: number;
+    /** A custom label for the indicator as provided in rowLabels */
+    label?: React.ReactNode | null;
+    /** Whether the entire row is selected */
+    selected: boolean;
+    /** Callback to be called when the row is selected */
+    onSelect: (row: number, extend: boolean) => void;
+};
+/** Type of the RowIndicator component */
+export type RowIndicatorComponent = React.ComponentType<RowIndicatorProps>;
+/** Type of the Spreadsheet ColumnIndicator component props */
+export type ColumnIndicatorProps = {
+    /** The column the indicator indicates */
+    column: number;
+    /** A custom label for the indicator as provided in columnLabels */
+    label?: React.ReactNode | null;
+    /** Whether the entire column in selected */
+    selected: boolean;
+    /** Whether the entire column in Fixed */
+    fixed?: boolean;
+    /** Callback to be called when the column is selected */
+    onSelect: (column: number, extend: boolean) => void;
+};
+/** Type of the ColumnIndicator component */
+export type ColumnIndicatorComponent = React.ComponentType<ColumnIndicatorProps>;
+/** Type of the Spreadsheet CornerIndicator component props */
+export type CornerIndicatorProps = {
+    /** Whether the entire table is selected */
+    selected: boolean;
+    /** Callback to select the entire table */
+    onSelect: () => void;
+};
+/** Type of the CornerIndicator component */
+export type CornerIndicatorComponent = React.ComponentType<CornerIndicatorProps>;
+export type CommitChanges<Cell extends CellBase = CellBase> = Array<{
+    prevCell: Cell | null;
+    nextCell: Cell | null;
+}>;
+export type CreateFormulaParser = (data: Matrix<CellBase>) => FormulaParser;
+export {};

package/lib/components/ExcelFile/ExcelFile/Excel/use-dispatch.d.ts

@@ -0,0 +1,3 @@
+import { Dispatch } from './context';
+declare function useDispatch(): Dispatch;
+export default useDispatch;

package/lib/components/ExcelFile/ExcelFile/Excel/use-selector.d.ts

@@ -0,0 +1,3 @@
+import * as Types from './types';
+declare function useSelector<T>(selector: (state: Types.StoreState) => T): T;
+export default useSelector;

package/lib/components/ExcelFile/ExcelFile/Excel/util.d.ts

@@ -0,0 +1,44 @@
+import * as Types from './types';
+import * as Matrix from './matrix';
+import * as Point from './point';
+import { PointRange } from './point-range';
+import { Selection } from './selection';
+export { createEmpty as createEmptyMatrix } from './matrix';
+export declare const PLAIN_TEXT_MIME = "text/plain";
+export declare const FOCUS_WITHIN_SELECTOR = ":focus-within";
+/** Move the cursor of given input element to the input's end */
+export declare function moveCursorToEnd(el: HTMLInputElement): void;
+/**
+ * Creates an array of numbers (positive and/or negative) progressing from start up to, but not including, end. A step of -1 is used if a negative start is specified without an end or step. If end is not specified, it's set to start with start then set to 0.
+ * @param end - an integer number specifying at which position to stop (not included).
+ * @param start - An integer number specifying at which position to start.
+ * @param step - An integer number specifying the Increment */
+export declare function range(end: number, start?: number, step?: number): number[];
+/** Return whether given point is active */
+export declare function isActive(active: Types.StoreState['active'], point: Point.Point): boolean;
+/** Get the offset values of given element */
+export declare function getOffsetRect(element: HTMLElement): Types.Dimensions;
+/** Write given data to clipboard with given event */
+export declare function writeTextToClipboard(event: ClipboardEvent, data: string): void;
+/** Read text from given clipboard event */
+export declare function readTextFromClipboard(event: ClipboardEvent): string;
+/** Get the dimensions of cell at point from state */
+export declare function getCellDimensions(point: Point.Point, rowDimensions: Types.StoreState['rowDimensions'] | undefined, columnDimensions: Types.StoreState['columnDimensions'] | undefined): Types.Dimensions | undefined;
+/** Get the dimensions of a range of cells */
+export declare function getRangeDimensions(rowDimensions: Types.StoreState['rowDimensions'], columnDimensions: Types.StoreState['columnDimensions'], range: PointRange): Types.Dimensions | undefined;
+/** Get the dimensions of selected */
+export declare function getSelectedDimensions(rowDimensions: Types.StoreState['rowDimensions'], columnDimensions: Types.StoreState['columnDimensions'], data: Matrix.Matrix<unknown>, selected: Selection): Types.Dimensions | undefined;
+/** Get given data as CSV */
+export declare function getCSV(data: Matrix.Matrix<Types.CellBase>): string;
+/**
+ * Calculate the rows and columns counts of a spreadsheet
+ * @param data - the spreadsheet's data
+ * @param rowLabels - the spreadsheet's row labels (if defined)
+ * @param columnLabels - the spreadsheet's column labels (if defined)
+ * @returns the rows and columns counts of a spreadsheet
+ */
+export declare function calculateSpreadsheetSize(data: Matrix.Matrix<unknown>, rowLabels?: string[], columnLabels?: string[]): Matrix.Size;
+/** Should spreadsheet handle clipboard event */
+export declare function shouldHandleClipboardEvent(root: Element | null, mode: Types.Mode): boolean;
+export declare function isFocusedWithin(element: Element): boolean;
+export declare function hasLineBreaker(value: unknown): boolean;

package/lib/components/ExcelFile/ExcelFile/ExcelFile.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+interface ExcelFileProps {
+    /** The Excel data containing sheets and their content */
+    excelData: {
+        sheets: WorkSheet[];
+    };
+    /** Optional: Provide context menu options for actions like right-click */
+    contextOption?: {
+        name: string;
+        title: React.ReactNode;
+        action: () => void;
+    }[];
+    /** Controls whether the toolbar is shown, disabled, or hidden */
+    toolbar?: 'show' | 'disable' | 'hide';
+    /** Callback function to save the Excel data */
+    onSave?: (excelData?: any) => void;
+}
+declare const ExcelFile: React.FC<ExcelFileProps>;
+export default ExcelFile;

package/lib/components/ExcelFile/ExcelFile.stories.d.ts

@@ -0,0 +1,6 @@
+import type { Meta, StoryObj } from '@storybook/react';
+import ExcelFile from './ExcelFile/ExcelFile';
+declare const meta: Meta<typeof ExcelFile>;
+type Story = StoryObj<typeof ExcelFile>;
+export declare const Default: Story;
+export default meta;

package/lib/components/ExcelFile/ExcelSheetBar/ExcelSheetBar.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+interface ExcelSheetBarProps {
+    fileDetails: {
+        sheetNames: string[];
+    };
+    handleSheetChange: (name: string, index: number) => void;
+    selectedSheet: {
+        name: string;
+    };
+}
+declare const ExcelSheetBar: React.FC<ExcelSheetBarProps>;
+export default ExcelSheetBar;

package/lib/components/ExcelFile/ExcelToolBar/ExcelToolBar.d.ts

@@ -0,0 +1,15 @@
+import './ExcelToolBar.scss';
+import { CellBase } from '../ExcelFile/Excel';
+import * as Matrix from '../ExcelFile/Excel/matrix';
+interface ExcelToolBarProps {
+    toolbar?: 'show' | 'disable' | 'hide';
+    data: Matrix.Matrix<CellBase>;
+    onBold: (data: Matrix.Matrix<CellBase>) => void;
+    onItalic: (data: Matrix.Matrix<CellBase>) => void;
+    onUnderline: (data: Matrix.Matrix<CellBase>) => void;
+    setColor: (data: Matrix.Matrix<CellBase>, value: string) => void;
+    setBackgroundColor: (data: Matrix.Matrix<CellBase>, value: string) => void;
+    setFormatePainter: (data: Matrix.Matrix<CellBase>) => void;
+}
+declare const ExcelToolBar: React.FC<ExcelToolBarProps>;
+export default ExcelToolBar;

package/lib/components/ExcelFile/ImportExcelStyles.d.ts

@@ -0,0 +1,24 @@
+interface CellStyle {
+    color?: string;
+    backgroundColor?: string;
+    bold?: boolean;
+    italic?: boolean;
+    name?: string;
+    border: {
+        top: string;
+        bottom: string;
+        left: string;
+        right: string;
+    };
+    alignment: {
+        horizontal?: string;
+        vertical?: string;
+        wrapText?: boolean;
+    };
+}
+interface CellData {
+    style?: CellStyle;
+}
+type ImportExcelStylesData = Array<Array<CellData>>;
+export default function ImportExcelStyles(data: ImportExcelStylesData | null): void;
+export {};