) => T;
}
type CSSProperties = Record;
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;
}
interface MenuMouseEvent extends MouseEvent {
closedMenuId?: UID;
}
type Immutable = T extends ImmutablePrimitive ? T : T extends Array ? ImmutableArray : T extends Map ? ImmutableMap : T extends Set ? ImmutableSet : ImmutableObject;
type ImmutablePrimitive = undefined | null | boolean | string | number | Function;
type ImmutableArray = ReadonlyArray>;
type ImmutableMap = ReadonlyMap, Immutable>;
type ImmutableSet = ReadonlySet>;
type ImmutableObject = {
readonly [K in keyof T]: Immutable;
};
interface HeaderGroup {
start: HeaderIndex;
end: HeaderIndex;
isFolded?: boolean;
}
type Direction$1 = "up" | "down" | "left" | "right";
type SelectionStep = number | "end";
interface Offset {
col: number;
row: number;
}
type DebouncedFunction = T & {
stopDebounce: () => void;
isDebouncePending: () => boolean;
};
interface GridClickModifiers {
addZone: boolean;
expandZone: boolean;
}
type ComposerFocusType = "inactive" | "cellFocus" | "contentFocus";
type EditionMode = "editing" | "selecting" | "inactive";
type SortDirection = "asc" | "desc";
type LocaleCode = string & Alias;
interface Locale {
name: string;
code: LocaleCode;
thousandsSeparator?: string;
decimalSeparator: string;
weekStart: number;
dateFormat: string;
timeFormat: string;
formulaArgSeparator: string;
}
declare const DEFAULT_LOCALES: Locale[];
declare const DEFAULT_LOCALE: Locale;
type Format = string & Alias;
type FormattedValue = string & Alias;
interface LocaleFormat {
locale: Locale;
format?: Format;
}
interface CellAttributes {
readonly id: UID;
/**
* Raw cell content
*/
readonly content: string;
readonly style?: Style;
readonly format?: Format;
}
interface LiteralCell extends CellAttributes {
readonly isFormula: false;
readonly parsedValue: CellValue;
}
interface FormulaCell extends CellAttributes {
readonly isFormula: true;
readonly compiledFormula: RangeCompiledFormula;
}
type Cell = LiteralCell | FormulaCell;
interface EvaluatedCellProperties extends FunctionResultObject {
readonly format?: Format;
/**
* Cell value formatted based on the format
*/
readonly formattedValue: FormattedValue;
readonly defaultAlign: "right" | "center" | "left";
/**
* Can the cell appear in an automatic sum zone.
*/
readonly isAutoSummable: boolean;
readonly link?: Link;
}
type CellValue = string | number | boolean | null;
type EvaluatedCell = NumberCell | TextCell | BooleanCell | EmptyCell | ErrorCell;
interface NumberCell extends EvaluatedCellProperties {
readonly type: CellValueType.number;
readonly value: number;
}
interface TextCell extends EvaluatedCellProperties {
readonly type: CellValueType.text;
readonly value: string;
}
interface BooleanCell extends EvaluatedCellProperties {
readonly type: CellValueType.boolean;
readonly value: boolean;
}
interface EmptyCell extends EvaluatedCellProperties {
readonly type: CellValueType.empty;
readonly value: null;
}
interface ErrorCell extends EvaluatedCellProperties {
readonly type: CellValueType.error;
readonly value: string;
readonly message?: string;
}
declare enum CellValueType {
boolean = "boolean",
number = "number",
text = "text",
empty = "empty",
error = "error"
}
/**
* An AutofillModifier describe the possible operations to apply to the
* content of a cell when we autofill this cell.
*
* It could be:
* - Increment: increment the content by a given step
* - Copy: simply copy the content
* - Formula: update the formula, with the same behavior than paste
*/
interface IncrementModifier {
type: "INCREMENT_MODIFIER";
increment: number;
current: number;
}
interface AlphanumericIncrementModifier {
type: "ALPHANUMERIC_INCREMENT_MODIFIER";
increment: number;
current: number;
prefix: string;
numberPostfixLength: number;
}
interface DateIncrementModifier {
type: "DATE_INCREMENT_MODIFIER";
current: number;
increment: {
years: number;
months: number;
days: number;
};
}
interface CopyModifier {
type: "COPY_MODIFIER";
}
interface FormulaModifier {
type: "FORMULA_MODIFIER";
increment: number;
current: number;
}
type AutofillModifier = IncrementModifier | AlphanumericIncrementModifier | CopyModifier | FormulaModifier | DateIncrementModifier;
interface Tooltip {
props: any;
component?: any;
}
interface AutofillCellData extends UpdateCellData {
border?: Border$1;
}
interface AutofillData {
cell?: Cell;
col: number;
row: number;
sheetId: UID;
border?: Border$1;
}
interface AutofillResult {
cellData: AutofillCellData;
tooltip?: Tooltip;
origin: {
col: number;
row: number;
};
}
interface GeneratorCell {
data: AutofillData;
rule: AutofillModifier;
}
interface AutofillModifierImplementation {
apply: (rule: AutofillModifier, data: AutofillData, getters: Getters, direction: DIRECTION) => Omit;
}
interface RevisionData {
readonly id: UID;
readonly clientId: ClientId;
readonly commands: readonly CoreCommand[];
}
interface Currency {
name: string;
code: string;
symbol: string;
decimalPlaces: number;
position: "before" | "after";
}
interface DataValidationRule {
id: UID;
criterion: DataValidationCriterion;
ranges: Range[];
isBlocking?: boolean;
}
type TextContainsCriterion = {
type: "textContains";
values: string[];
};
type TextNotContainsCriterion = {
type: "textNotContains";
values: string[];
};
type TextIsCriterion = {
type: "textIs";
values: string[];
};
type TextIsEmailCriterion = {
type: "textIsEmail";
values: string[];
};
type TextIsLinkCriterion = {
type: "textIsLink";
values: string[];
};
type DateIsCriterion = {
type: "dateIs";
dateValue: DateCriterionValue;
values: string[];
};
type DateIsBeforeCriterion = {
type: "dateIsBefore";
dateValue: DateCriterionValue;
values: string[];
};
type DateIsOnOrBeforeCriterion = {
type: "dateIsOnOrBefore";
dateValue: DateCriterionValue;
values: string[];
};
type DateIsAfterCriterion = {
type: "dateIsAfter";
dateValue: DateCriterionValue;
values: string[];
};
type DateIsOnOrAfterCriterion = {
type: "dateIsOnOrAfter";
dateValue: DateCriterionValue;
values: string[];
};
type DateIsBetweenCriterion = {
type: "dateIsBetween";
values: string[];
};
type DateIsNotBetweenCriterion = {
type: "dateIsNotBetween";
values: string[];
};
type DateIsValidCriterion = {
type: "dateIsValid";
values: string[];
};
type IsEqualCriterion = {
type: "isEqual";
values: string[];
};
type IsNotEqualCriterion = {
type: "isNotEqual";
values: string[];
};
type IsGreaterThanCriterion = {
type: "isGreaterThan";
values: string[];
};
type IsGreaterOrEqualToCriterion = {
type: "isGreaterOrEqualTo";
values: string[];
};
type IsLessThanCriterion = {
type: "isLessThan";
values: string[];
};
type IsLessOrEqualToCriterion = {
type: "isLessOrEqualTo";
values: string[];
};
type IsBetweenCriterion = {
type: "isBetween";
values: string[];
};
type IsNotBetweenCriterion = {
type: "isNotBetween";
values: string[];
};
type IsCheckboxCriterion = {
type: "isBoolean";
values: string[];
};
type IsValueInListCriterion = {
type: "isValueInList";
values: string[];
displayStyle: "arrow" | "plainText";
};
type IsValueInRangeCriterion = {
type: "isValueInRange";
values: string[];
displayStyle: "arrow" | "plainText";
};
type CustomFormulaCriterion = {
type: "customFormula";
values: string[];
};
type DataValidationCriterion = TextContainsCriterion | TextNotContainsCriterion | TextIsCriterion | TextIsEmailCriterion | TextIsLinkCriterion | IsBetweenCriterion | DateIsCriterion | DateIsBeforeCriterion | DateIsOnOrBeforeCriterion | DateIsAfterCriterion | DateIsOnOrAfterCriterion | DateIsBetweenCriterion | DateIsNotBetweenCriterion | DateIsValidCriterion | IsEqualCriterion | IsNotEqualCriterion | IsGreaterThanCriterion | IsGreaterOrEqualToCriterion | IsLessThanCriterion | IsLessOrEqualToCriterion | IsNotBetweenCriterion | IsCheckboxCriterion | IsValueInListCriterion | IsValueInRangeCriterion | CustomFormulaCriterion;
type DateCriterionValue = "today" | "tomorrow" | "yesterday" | "lastWeek" | "lastMonth" | "lastYear" | "exactDate";
type DataValidationCriterionType = DataValidationCriterion["type"];
type DataValidationDateCriterion = Extract;
type ClipboardReadResult = {
status: "ok";
content: OSClipboardContent;
} | {
status: "permissionDenied" | "notImplemented";
};
interface ClipboardInterface {
write(clipboardContent: OSClipboardContent): Promise;
writeText(text: string): Promise;
read(): Promise;
}
/**
* An injectable store constructor
*/
interface StoreConstructor {
new (get: Get, ...args: A): T;
}
/**
* A store constructor for a store that implements the Disposable interface.
* Useful for local stores that need to be disposed when the component unmounts.
*/
interface LocalStoreConstructor {
new (get: Get, ...args: A): T;
}
interface Disposable {
dispose(): void;
}
type StoreParams = SkipFirst>;
/**
* A function used to inject dependencies in a store constructor
*/
type Get = (Store: T) => T extends StoreConstructor ? Store : never;
/**
* Remove the first element of a tuple
* @example
* type A = SkipFirst<[number, string, boolean]> // [string, boolean]
*/
type SkipFirst = T extends [any, ...infer U] ? U : never;
type OmitFunctions = {
[K in keyof T as T[K] extends Function ? never : K]: T[K];
};
type Store = S extends {
mutators: readonly (keyof S)[];
} ? CQS & OmitFunctions> : CQS>;
/**
* Command Query Separation [1,2] implementation with types.
*
* Mapped type applying CQS principles to an object by forcing
* - methods (commands) to never return anything, effectively making them write-only,
* - all properties (queries) to be read-only [3]
*
* [1] https://martinfowler.com/bliki/CommandQuerySeparation.html
* [2] https://en.wikipedia.org/wiki/Command%E2%80%93query_separation
* [3] in an ideal world, they would be deeply read-only, but that's not possible natively in TypeScript
*/
type CQS = {
readonly [key in keyof T]: NeverReturns;
};
/**
* Force any function to never return anything, effectively
* making it write-only.
*/
type NeverReturns = T extends (...args: any[]) => any ? (...args: Parameters) => void : T;
declare class DisposableStore implements Disposable {
protected get: Get;
private disposeCallbacks;
constructor(get: Get);
protected onDispose(callback: () => void): void;
dispose(): void;
}
interface StoreUpdateEvent {
type: "store-updated";
}
/**
* A type-safe dependency container
*/
declare class DependencyContainer extends EventBus {
private dependencies;
private factory;
/**
* Injects a store instance in the dependency container.
* Useful for injecting an external store that is not created by the container.
* Also useful for mocking a store.
*/
inject(Store: T, instance: InstanceType): void;
/**
* Get an instance of a store.
*/
get(Store: StoreConstructor): T;
instantiate(Store: StoreConstructor, ...args: StoreParams>): T;
resetStores(): void;
}
/**
* This hook should be used at the root of your app to provide the store container.
*/
declare function useStoreProvider(): DependencyContainer;
/**
* Get the instance of a store.
*/
declare function useStore(Store: T): Store>;
declare function useLocalStore>(Store: T, ...args: StoreParams extends never ? [] : StoreParams): Store>;
interface NotificationStoreMethods {
notifyUser: (notification: InformationNotification) => void;
raiseError: (text: string, callback?: () => void) => void;
askConfirmation: (content: string, confirm: () => void, cancel?: () => void) => void;
}
declare class NotificationStore {
mutators: readonly ["notifyUser", "raiseError", "askConfirmation", "updateNotificationCallbacks"];
notifyUser: NotificationStoreMethods["notifyUser"];
askConfirmation: NotificationStoreMethods["askConfirmation"];
raiseError: NotificationStoreMethods["raiseError"];
updateNotificationCallbacks(methods: Partial): void;
}
interface EditTextOptions {
error?: string;
placeholder?: string;
}
type NotificationType = "danger" | "info" | "success" | "warning";
interface InformationNotification {
text: string;
type: NotificationType;
sticky: boolean;
}
interface SpreadsheetChildEnv extends NotificationStoreMethods {
model: Model;
imageProvider?: ImageProviderInterface;
isDashboard: () => boolean;
openSidePanel: (panel: string, panelProps?: any) => void;
toggleSidePanel: (panel: string, panelProps?: any) => void;
clipboard: ClipboardInterface;
startCellEdition: (content?: string) => void;
loadCurrencies?: () => Promise;
loadLocales: () => Promise;
getStore: Get;
}
interface RangeStringOptions {
useBoundedReference?: boolean;
useFixedReference?: boolean;
}
declare class RangeAdapter implements CommandHandler {
private getters;
private providers;
constructor(getters: CoreGetters);
static getters: readonly ["adaptFormulaStringDependencies", "copyFormulaStringForSheet", "extendRange", "getRangeString", "getRangeFromSheetXC", "createAdaptedRanges", "getRangeDataFromXc", "getRangeDataFromZone", "getRangeFromRangeData", "getRangeFromZone", "getRangesUnion", "recomputeRanges", "isRangeValid", "removeRangesSheetPrefix"];
allowDispatch(cmd: Command): CommandResult;
beforeHandle(command: Command): void;
handle(cmd: Command): void;
finalize(): void;
/**
* Return a modified adapting function that verifies that after adapting a range, the range is still valid.
* Any range that gets adapted by the function adaptRange in parameter does so
* without caring if the start and end of the range in both row and column
* direction can be incorrect. This function ensure that an incorrect range gets removed.
*/
private verifyRangeRemoved;
private createAdaptedRange;
private executeOnAllRanges;
/**
* Stores the functions bound to each plugin to be able to iterate over all ranges of the application,
* without knowing any details of the internal data structure of the plugins and without storing ranges
* in the range adapter.
*
* @param provider a function bound to a plugin that will loop over its internal data structure to find
* all ranges
*/
addRangeProvider(provider: RangeProvider["adaptRanges"]): void;
createAdaptedRanges(ranges: Range[], offsetX: number, offsetY: number, sheetId: UID): Range[];
/**
* Remove the sheet name prefix if a range is part of the given sheet.
*/
removeRangesSheetPrefix(sheetId: UID, ranges: Range[]): Range[];
extendRange(range: Range, dimension: Dimension, quantity: number): Range;
/**
* Creates a range from a XC reference that can contain a sheet reference
* @param defaultSheetId the sheet to default to if the sheetXC parameter does not contain a sheet reference (usually the active sheet Id)
* @param sheetXC the string description of a range, in the form SheetName!XC:XC
*/
getRangeFromSheetXC(defaultSheetId: UID, sheetXC: string): RangeImpl;
/**
* Gets the string that represents the range as it is at the moment of the call.
* The string will be prefixed with the sheet name if the call specified a sheet id in `forSheetId`
* different than the sheet on which the range has been created.
*
* @param range the range (received from getRangeFromXC or getRangeFromZone)
* @param forSheetId the id of the sheet where the range string is supposed to be used.
* @param options
* @param options.useBoundedReference if true, the range will be returned with bounded row and column
* @param options.useFixedReference if true, the range will be returned with fixed row and column
*/
getRangeString(range: Range, forSheetId: UID, options?: RangeStringOptions): string;
getRangeDataFromXc(sheetId: UID, xc: string): RangeData;
getRangeDataFromZone(sheetId: UID, zone: Zone | UnboundedZone): RangeData;
getRangeFromZone(sheetId: UID, zone: Zone | UnboundedZone): Range;
/**
* Allows you to recompute ranges from the same sheet
*/
recomputeRanges(ranges: Range[], rangesToRemove: Range[]): Range[];
getRangeFromRangeData(data: RangeData): Range;
isRangeValid(rangeStr: string): boolean;
getRangesUnion(ranges: Range[]): Range;
adaptFormulaStringDependencies(sheetId: UID, formula: string, applyChange: ApplyRangeChange): string;
/**
* Copy a formula string to another sheet.
*
* @param mode
* `keepSameReference` will make the formula reference the exact same ranges,
* `moveReference` will change all the references to `sheetIdFrom` into references to `sheetIdTo`.
*/
copyFormulaStringForSheet(sheetIdFrom: UID, sheetIdTo: UID, formula: string, mode: "keepSameReference" | "moveReference"): string;
/**
* Get a Xc string that represent a part of a range
*/
private getRangePartString;
private getInvalidRange;
}
interface CorePluginConfig {
readonly getters: CoreGetters;
readonly stateObserver: StateObserver;
readonly range: RangeAdapter;
readonly dispatch: CoreCommandDispatcher["dispatch"];
readonly canDispatch: CoreCommandDispatcher["dispatch"];
readonly custom: ModelConfig["custom"];
readonly external: ModelConfig["external"];
}
interface CorePluginConstructor {
new (config: CorePluginConfig): CorePlugin;
getters: readonly string[];
}
/**
* Core plugins handle spreadsheet data.
* They are responsible to import, export and maintain the spreadsheet
* persisted state.
* They should not be concerned about UI parts or transient state.
*/
declare class CorePlugin extends BasePlugin implements RangeProvider {
protected getters: CoreGetters;
protected dispatch: CoreCommandDispatcher["dispatch"];
protected canDispatch: CoreCommandDispatcher["dispatch"];
constructor({ getters, stateObserver, range, dispatch, canDispatch }: CorePluginConfig);
import(data: WorkbookData): void;
export(data: WorkbookData): void;
/**
* This method can be implemented in any plugin, to loop over the plugin's data structure and adapt the plugin's ranges.
* To adapt them, the implementation of the function must have a perfect knowledge of the data structure, thus
* implementing the loops over it makes sense in the plugin itself.
* When calling the method applyChange, the range will be adapted if necessary, then a copy will be returned along with
* the type of change that occurred.
*
* @param applyChange a function that, when called, will adapt the range according to the change on the grid
* @param sheetId an optional sheetId to adapt either range of that sheet specifically, or ranges pointing to that sheet
*/
adaptRanges(applyChange: ApplyRangeChange, sheetId?: UID): void;
/**
* Implement this method to clean unused external resources, such as images
* stored on a server which have been deleted.
*/
garbageCollectExternalResources(): void;
}
interface BordersPluginState {
readonly borders: Record;
}
/**
* Formatting plugin.
*
* This plugin manages all things related to a cell look:
* - borders
*/
declare class BordersPlugin extends CorePlugin implements BordersPluginState {
static getters: readonly ["getCellBorder", "getBordersColors"];
readonly borders: BordersPluginState["borders"];
allowDispatch(cmd: CoreCommand): CommandResult.Success | CommandResult.NoChanges;
handle(cmd: CoreCommand): void;
/**
* Move borders according to the inserted columns.
* Ensure borders continuity.
*/
private handleAddColumns;
/**
* Move borders according to the inserted rows.
* Ensure borders continuity.
*/
private handleAddRows;
getCellBorder({ sheetId, col, row }: CellPosition): Border$1 | null;
getBordersColors(sheetId: UID): Color[];
/**
* Ensure border continuity between two columns.
* If the two columns have the same borders (at each row respectively),
* the same borders are applied to each cell in between.
*/
private ensureColumnBorderContinuity;
/**
* Ensure border continuity between two rows.
* If the two rows have the same borders (at each column respectively),
* the same borders are applied to each cell in between.
*/
private ensureRowBorderContinuity;
/**
* From two borders, return a new border with sides defined in both borders.
* i.e. the intersection of two borders.
*/
private getCommonSides;
/**
* Get all the columns which contains at least a border
*/
private getColumnsWithBorders;
/**
* Get all the rows which contains at least a border
*/
private getRowsWithBorders;
/**
* Get the range of all the rows in the sheet
*/
private getRowsRange;
/**
* Move borders of a sheet horizontally.
* @param sheetId
* @param start starting column (included)
* @param delta how much borders will be moved (negative if moved to the left)
*/
private shiftBordersHorizontally;
/**
* Move borders of a sheet vertically.
* @param sheetId
* @param start starting row (included)
* @param delta how much borders will be moved (negative if moved to the above)
*/
private shiftBordersVertically;
/**
* Moves the borders (left if `vertical` or top if `horizontal` depending on
* `borderDirection`) of all cells in an entire row `delta` rows to the right
* (`delta` > 0) or to the left (`delta` < 0).
* Note that as the left of a cell is the right of the cell-1, if the left is
* moved the right is also moved. However, if `horizontal`, the bottom border
* is not moved.
* It does it by replacing the target border by the moved border. If the
* argument `destructive` is given false, the target border is preserved if
* the moved border is empty
*/
private moveBordersOfRow;
/**
* Moves the borders (left if `vertical` or top if `horizontal` depending on
* `borderDirection`) of all cells in an entire column `delta` columns below
* (`delta` > 0) or above (`delta` < 0).
* Note that as the top of a cell is the bottom of the cell-1, if the top is
* moved the bottom is also moved. However, if `vertical`, the right border
* is not moved.
* It does it by replacing the target border by the moved border. If the
* argument `destructive` is given false, the target border is preserved if
* the moved border is empty
*/
private moveBordersOfColumn;
/**
* Set the borders of a cell.
* It overrides the current border if override === true.
*/
private setBorder;
/**
* Remove the borders of a zone
*/
private clearBorders;
/**
* Remove the borders inside of a zone
*/
private clearInsideBorders;
/**
* Add a border to the existing one to a cell
*/
private addBorder;
/**
* Set the borders of a zone by computing the borders to add from the given
* command
*/
private setBorders;
/**
* Compute the borders to add to the given zone merged.
*/
private addBordersToMerge;
private checkBordersUnchanged;
import(data: WorkbookData): void;
export(data: WorkbookData): void;
exportForExcel(data: ExcelWorkbookData): void;
}
interface CoreState$1 {
cells: Record | undefined>;
nextId: number;
}
/**
* Core Plugin
*
* This is the most fundamental of all plugins. It defines how to interact with
* cell and sheet content.
*/
declare class CellPlugin extends CorePlugin implements CoreState$1 {
static getters: readonly ["zoneToXC", "getCells", "getTranslatedCellFormula", "getCellStyle", "getCellById", "getFormulaString", "getFormulaMovedInSheet"];
readonly nextId = 1;
readonly cells: {
[sheetId: string]: {
[id: string]: Cell;
};
};
adaptRanges(applyChange: ApplyRangeChange, sheetId?: UID): void;
allowDispatch(cmd: CoreCommand): CommandResult | CommandResult[];
handle(cmd: CoreCommand): void;
private clearZones;
/**
* Set a format to all the cells in a zone
*/
private setFormatter;
/**
* Clear the styles and format of zones
*/
private clearFormatting;
/**
* Clear the styles, the format and the content of zones
*/
private clearCells;
/**
* Copy the style of the reference column/row to the new columns/rows.
*/
private handleAddColumnsRows;
import(data: WorkbookData): void;
export(data: WorkbookData): void;
importCell(sheetId: UID, content?: string, style?: Style, format?: Format): Cell;
exportForExcel(data: ExcelWorkbookData): void;
private removeDefaultStyleValues;
getCells(sheetId: UID): Record;
/**
* get a cell by ID. Used in evaluation when evaluating an async cell, we need to be able to find it back after
* starting an async evaluation even if it has been moved or re-allocated
*/
getCellById(cellId: UID): Cell | undefined;
getFormulaString(sheetId: UID, tokens: Token[], dependencies: Range[], useBoundedReference?: boolean): string;
getTranslatedCellFormula(sheetId: UID, offsetX: number, offsetY: number, tokens: Token[]): string;
getFormulaMovedInSheet(originSheetId: UID, targetSheetId: UID, tokens: Token[]): string;
getCellStyle(position: CellPosition): Style;
/**
* Converts a zone to a XC coordinate system
*
* The conversion also treats merges as one single cell
*
* Examples:
* {top:0,left:0,right:0,bottom:0} ==> A1
* {top:0,left:0,right:1,bottom:1} ==> A1:B2
*
* if A1:B2 is a merge:
* {top:0,left:0,right:1,bottom:1} ==> A1
* {top:1,left:0,right:1,bottom:2} ==> A1:B3
*
* if A1:B2 and A4:B5 are merges:
* {top:1,left:0,right:1,bottom:3} ==> A1:A5
*/
zoneToXC(sheetId: UID, zone: Zone, fixedParts?: RangePart[]): string;
private setStyle;
/**
* Copy the style of one column to other columns.
*/
private copyColumnStyle;
/**
* Copy the style of one row to other rows.
*/
private copyRowStyle;
/**
* gets the currently used style/border of a cell based on it's coordinates
*/
private getFormat;
private getNextUid;
private updateCell;
private createCell;
private createLiteralCell;
private createFormulaCell;
/**
* Create a new formula cell with the content
* being a computed property to rebuild the dependencies XC.
*/
private createFormulaCellWithDependencies;
private checkCellOutOfSheet;
private checkUselessClearCell;
private checkUselessUpdateCell;
}
/**
* AbstractChart is the class from which every Chart should inherit.
* The role of this class is to maintain the state of each chart.
*/
declare abstract class AbstractChart {
readonly sheetId: UID;
readonly title: TitleDesign;
abstract readonly type: ChartType;
protected readonly getters: CoreGetters;
constructor(definition: ChartDefinition, sheetId: UID, getters: CoreGetters);
/**
* Validate the chart definition given as arguments. This function will be
* called from allowDispatch function
*/
static validateChartDefinition(validator: Validator, definition: ChartDefinition): CommandResult | CommandResult[];
/**
* Get a new chart definition transformed with the executed command. This
* functions will be called during operational transform process
*/
static transformDefinition(definition: ChartDefinition, executed: AddColumnsRowsCommand | RemoveColumnsRowsCommand): ChartDefinition;
/**
* Get an empty definition based on the given context
*/
static getDefinitionFromContextCreation(context: ChartCreationContext): ChartDefinition;
/**
* Get the definition of the chart
*/
abstract getDefinition(): ChartDefinition;
/**
* Get the definition of the chart that will be used for excel export.
* If the chart is not supported by Excel, this function returns undefined.
*/
abstract getDefinitionForExcel(): ExcelChartDefinition | undefined;
/**
* This function should be used to update all the ranges of the chart after
* a grid change (add/remove col/row, rename sheet, ...)
*/
abstract updateRanges(applyChange: ApplyRangeChange): AbstractChart;
/**
* Duplicate the chart when a sheet is duplicated.
* The ranges that are in the same sheet as the chart are adapted to the new sheetId.
*/
abstract duplicateInDuplicatedSheet(newSheetId: UID): AbstractChart;
/**
* Get a copy a the chart in the given sheetId.
* The ranges of the chart will stay the same as the copied chart.
*/
abstract copyInSheetId(sheetId: UID): AbstractChart;
/**
* Extract the ChartCreationContext of the chart
*/
abstract getContextCreation(): ChartCreationContext;
}
/**
* Chart plugin
*
* This plugin manages charts
* */
interface ChartState {
readonly charts: Record;
}
declare class ChartPlugin extends CorePlugin implements ChartState {
static getters: readonly ["isChartDefined", "getChartDefinition", "getChartType", "getChartIds", "getChart", "getContextCreationChart"];
readonly charts: Record;
private createChart;
private validateChartDefinition;
adaptRanges(applyChange: ApplyRangeChange): void;
allowDispatch(cmd: Command): CommandResult | CommandResult[];
handle(cmd: CoreCommand): void;
getContextCreationChart(figureId: UID): ChartCreationContext | undefined;
getChart(figureId: UID): AbstractChart | undefined;
getChartType(figureId: UID): ChartType;
isChartDefined(figureId: UID): boolean;
getChartIds(sheetId: UID): string[];
getChartDefinition(figureId: UID): ChartDefinition;
import(data: WorkbookData): void;
export(data: WorkbookData): void;
/**
* Add a figure with tag chart with the given id at the given position
*/
private addFigure;
/**
* Add a chart in the local state. If a chart already exists, this chart is
* replaced
*/
private addChart;
private checkChartDuplicate;
private checkChartExists;
}
interface ConditionalFormatState {
readonly cfRules: {
[sheet: string]: ConditionalFormatInternal[];
};
}
declare class ConditionalFormatPlugin extends CorePlugin implements ConditionalFormatState {
static getters: readonly ["getConditionalFormats", "getRulesSelection", "getRulesByCell", "getAdaptedCfRanges"];
readonly cfRules: {
[sheet: string]: ConditionalFormatInternal[];
};
loopThroughRangesOfSheet(sheetId: UID, applyChange: ApplyRangeChange): void;
adaptRanges(applyChange: ApplyRangeChange, sheetId?: UID): void;
allowDispatch(cmd: Command): CommandResult | CommandResult[];
handle(cmd: CoreCommand): void;
import(data: WorkbookData): void;
export(data: Partial): void;
exportForExcel(data: ExcelWorkbookData): void;
/**
* Returns all the conditional format rules defined for the current sheet to display the user
*/
getConditionalFormats(sheetId: UID): ConditionalFormat[];
getRulesSelection(sheetId: UID, selection: Zone[]): UID[];
getRulesByZone(sheetId: UID, zone: Zone): Set;
getRulesByCell(sheetId: UID, cellCol: number, cellRow: number): Set;
/**
* Add or remove cells to a given conditional formatting rule and return the adapted CF's XCs.
*/
getAdaptedCfRanges(sheetId: UID, cf: ConditionalFormat, toAdd: Zone[], toRemove: Zone[]): RangeData[] | undefined;
private mapToConditionalFormat;
private mapToConditionalFormatInternal;
/**
* Add or replace a conditional format rule
*/
private addConditionalFormatting;
private checkValidPriorityChange;
private checkEmptyRange;
private checkCFRule;
private checkCFHasChanged;
private checkOperatorArgsNumber;
private checkNaN;
private checkFormulaCompilation;
private checkThresholds;
private checkInflectionPoints;
private checkLowerBiggerThanUpper;
private checkMinBiggerThanMax;
private checkMidBiggerThanMax;
private checkMinBiggerThanMid;
private checkCFValues;
private removeConditionalFormatting;
private changeCFPriority;
}
interface DataValidationState {
readonly rules: {
[sheet: string]: DataValidationRule[];
};
}
declare class DataValidationPlugin extends CorePlugin implements DataValidationState {
static getters: readonly ["cellHasListDataValidationIcon", "getDataValidationRule", "getDataValidationRules", "getValidationRuleForCell"];
readonly rules: {
[sheet: string]: DataValidationRule[];
};
adaptRanges(applyChange: ApplyRangeChange, sheetId?: UID): void;
private loopThroughRangesOfSheet;
allowDispatch(cmd: Command): CommandResult | CommandResult[];
handle(cmd: CoreCommand): void;
getDataValidationRules(sheetId: UID): DataValidationRule[];
getDataValidationRule(sheetId: UID, id: UID): DataValidationRule | undefined;
getValidationRuleForCell({ sheetId, col, row }: CellPosition): DataValidationRule | undefined;
cellHasListDataValidationIcon(cellPosition: CellPosition): boolean;
private addDataValidationRule;
private removeRangesFromRules;
private removeDataValidationRule;
private setCenterStyleToBooleanCells;
private checkEmptyRange;
import(data: WorkbookData): void;
export(data: Partial): void;
exportForExcel(data: ExcelWorkbookData): void;
private checkCriterionTypeIsValid;
private checkCriterionHasValidNumberOfValues;
private checkCriterionValuesAreValid;
private checkValidRange;
}
interface FigureState {
readonly figures: {
[sheet: string]: Record | undefined;
};
readonly insertionOrders: UID[];
}
declare class FigurePlugin extends CorePlugin implements FigureState {
static getters: readonly ["getFigures", "getFigure", "getFigureSheetId"];
readonly figures: {
[sheet: string]: Record | undefined;
};
readonly insertionOrders: UID[];
allowDispatch(cmd: CoreCommand): CommandResult;
beforeHandle(cmd: CoreCommand): void;
handle(cmd: CoreCommand): void;
private onRowColDelete;
private onRowDeletion;
private onColDeletion;
private updateFigure;
private addFigure;
private deleteSheet;
private removeFigure;
private checkFigureExists;
private checkFigureDuplicate;
getFigures(sheetId: UID): Figure[];
getFigure(sheetId: string, figureId: string): Figure | undefined;
getFigureSheetId(figureId: string): UID | undefined;
import(data: WorkbookData): void;
export(data: WorkbookData): void;
exportForExcel(data: ExcelWorkbookData): void;
}
interface State$9 {
groups: Record>;
}
declare class HeaderGroupingPlugin extends CorePlugin {
static getters: readonly ["getHeaderGroups", "getGroupsLayers", "getVisibleGroupLayers", "getHeaderGroup", "getHeaderGroupsInZone", "isGroupFolded", "isRowFolded", "isColFolded"];
private readonly groups;
allowDispatch(cmd: CoreCommand): CommandResult;
handle(cmd: CoreCommand): void;
getHeaderGroups(sheetId: UID, dim: Dimension): HeaderGroup[];
getHeaderGroup(sheetId: UID, dim: Dimension, start: number, end: number): HeaderGroup | undefined;
getHeaderGroupsInZone(sheetId: UID, dim: Dimension, zone: Zone): HeaderGroup[];
/**
* Get all the groups of a sheet in a dimension, and return an array of layers of those groups.
*
* The layering rules are:
* 1) A group containing another group should be on a layer above the group it contains
* 2) The widest/highest groups should be on the left/top layer compared to the groups it contains
* 3) The group should be on the left/top-most layer possible, barring intersections with other groups (see rules 1 and 2)
*/
getGroupsLayers(sheetId: UID, dimension: Dimension): HeaderGroup[][];
/**
* Get all the groups of a sheet in a dimension, and return an array of layers of those groups,
* excluding the groups that are totally hidden.
*/
getVisibleGroupLayers(sheetId: UID, dimension: Dimension): HeaderGroup[][];
isGroupFolded(sheetId: UID, dimension: Dimension, start: number, end: number): boolean;
isRowFolded(sheetId: UID, row: HeaderIndex): boolean;
isColFolded(sheetId: UID, col: HeaderIndex): boolean;
private getGroupId;
/**
* To get layers of groups, and to add/remove headers from groups, we can see each header of a group as a brick. Each
* brick falls down in the pile corresponding to its header, until it hits another brick, or the ground.
*
* With this abstraction, we can very simply group/ungroup headers from groups, and get the layers of groups.
* - grouping headers is done by adding a brick to each header pile
* - un-grouping headers is done by removing a brick from each header pile
* - getting the layers of groups is done by simply letting the brick fall and checking the result
*
* Example:
* We have 2 groups ([A=>E] and [C=>D]), and we want to group headers [C=>F]
*
* Headers : A B C D E F G A B C D E F G A B C D E F G
* Headers to group: [C=>D]: _ _ [C=>F]: _ _ _ _
* | | ==> | | | | ==> ==> Result: 3 groups
* | | ˅ ˅ | | _ _ - [C=>D]
* Groups: ˅ ˅ _ _ ˅ | _ _ _ - [C=>E]
* Groups: _ _ _ _ _ _ _ _ _ _ ˅ _ _ _ _ _ _ - [A=>F]
* @param groups
* @param start start of the range where to add/remove headers
* @param end end of the range where to add/remove headers
* @param delta -1: remove headers, 1: add headers, 0: get layers (don't add/remove anything)
*/
private bricksFallingAlgorithm;
private groupHeaders;
/**
* Ungroup the given headers. The headers will be taken out of the group they are in. This might split a group into two
* if the headers were in the middle of a group. If multiple groups contains a header, it will only be taken out of the
* lowest group in the layering of the groups.
*/
private unGroupHeaders;
private moveGroupsOnHeaderInsertion;
private moveGroupsOnHeaderDeletion;
private doGroupOverlap;
private removeDuplicateGroups;
private findGroupWithStartEnd;
/**
* Fold the given group, and all the groups starting at the same index that are contained inside the given group.
*/
private foldHeaderGroup;
/**
* Unfold the given group, and all the groups starting at the same index that contain the given group.
*/
private unfoldHeaderGroup;
private getGroupIndex;
import(data: WorkbookData): void;
export(data: WorkbookData): void;
exportForExcel(data: ExcelWorkbookData): void;
}
interface HeaderSizeState$1 {
sizes: Record>>;
}
declare class HeaderSizePlugin extends CorePlugin implements HeaderSizeState$1 {
static getters: readonly ["getUserRowSize", "getColSize"];
readonly sizes: Record>>;
handle(cmd: Command): void;
getColSize(sheetId: UID, index: HeaderIndex): Pixel;
getUserRowSize(sheetId: UID, index: HeaderIndex): Pixel | undefined;
import(data: WorkbookData): void;
exportForExcel(data: ExcelWorkbookData): void;
export(data: WorkbookData): void;
/**
* Export the header sizes
*
* @param exportDefaults : if true, export column/row sizes even if they have the default size
*/
exportData(data: WorkbookData, exportDefaults?: boolean): void;
}
declare class HeaderVisibilityPlugin extends CorePlugin {
static getters: readonly ["checkElementsIncludeAllVisibleHeaders", "getHiddenColsGroups", "getHiddenRowsGroups", "isHeaderHiddenByUser", "isRowHiddenByUser", "isColHiddenByUser"];
private readonly hiddenHeaders;
allowDispatch(cmd: Command): CommandResult.Success | CommandResult.NotEnoughElements | CommandResult.InvalidSheetId | CommandResult.TooManyHiddenElements | CommandResult.InvalidHeaderIndex;
handle(cmd: Command): void;
checkElementsIncludeAllVisibleHeaders(sheetId: UID, dimension: Dimension, elements: HeaderIndex[]): boolean;
isHeaderHiddenByUser(sheetId: UID, dimension: Dimension, index: HeaderIndex): boolean;
isRowHiddenByUser(sheetId: UID, index: HeaderIndex): boolean;
isColHiddenByUser(sheetId: UID, index: HeaderIndex): boolean;
getHiddenColsGroups(sheetId: UID): ConsecutiveIndexes[];
getHiddenRowsGroups(sheetId: UID): ConsecutiveIndexes[];
private getAllVisibleHeaders;
import(data: WorkbookData): void;
exportForExcel(data: ExcelWorkbookData): void;
export(data: WorkbookData): void;
exportData(data: WorkbookData, exportDefaults?: boolean): void;
}
interface ImageState {
readonly images: Record | undefined>;
}
declare class ImagePlugin extends CorePlugin implements ImageState {
static getters: readonly ["getImage", "getImagePath", "getImageSize"];
readonly fileStore?: FileStore;
readonly images: Record | undefined>;
/**
* paths of images synced with the file store server.
*/
readonly syncedImages: Set;
constructor(config: CorePluginConfig);
allowDispatch(cmd: CoreCommand): CommandResult.Success | CommandResult.InvalidFigureId;
handle(cmd: CoreCommand): void;
/**
* Delete unused images from the file store
*/
garbageCollectExternalResources(): void;
getImage(figureId: UID): Image$1;
getImagePath(figureId: UID): string;
getImageSize(figureId: UID): FigureSize;
private addImage;
import(data: WorkbookData): void;
export(data: WorkbookData): void;
exportForExcel(data: ExcelWorkbookData): void;
private getAllImages;
}
type SheetMergeCellMap = Record | undefined>;
interface MergeState {
readonly merges: Record | undefined>;
readonly mergeCellMap: Record;
}
declare class MergePlugin extends CorePlugin implements MergeState {
static getters: readonly ["isInMerge", "isInSameMerge", "isMergeHidden", "getMainCellPosition", "expandZone", "doesIntersectMerge", "doesColumnsHaveCommonMerges", "doesRowsHaveCommonMerges", "getMerges", "getMerge", "getMergesInZone", "isSingleCellOrMerge", "getSelectionRangeString", "isMainCellPosition"];
private nextId;
readonly merges: Record | undefined>;
readonly mergeCellMap: Record;
allowDispatch(cmd: CoreCommand): CommandResult | CommandResult[];
handle(cmd: CoreCommand): void;
adaptRanges(applyChange: ApplyRangeChange, sheetId?: UID): void;
getMerges(sheetId: UID): Merge[];
getMerge({ sheetId, col, row }: CellPosition): Merge | undefined;
getMergesInZone(sheetId: UID, zone: Zone): Merge[];
/**
* Same as `getRangeString` but add all necessary merge to the range to make it a valid selection
*/
getSelectionRangeString(range: Range, forSheetId: UID): string;
/**
* Return true if the zone intersects an existing merge:
* if they have at least a common cell
*/
doesIntersectMerge(sheetId: UID, zone: Zone): boolean;
/**
* Returns true if two columns have at least one merge in common
*/
doesColumnsHaveCommonMerges(sheetId: string, colA: HeaderIndex, colB: HeaderIndex): boolean;
/**
* Returns true if two rows have at least one merge in common
*/
doesRowsHaveCommonMerges(sheetId: string, rowA: HeaderIndex, rowB: HeaderIndex): boolean;
/**
* Add all necessary merge to the current selection to make it valid
*/
expandZone(sheetId: UID, zone: Zone): Zone;
isInSameMerge(sheetId: UID, colA: HeaderIndex, rowA: HeaderIndex, colB: HeaderIndex, rowB: HeaderIndex): boolean;
isInMerge({ sheetId, col, row }: CellPosition): boolean;
getMainCellPosition(position: CellPosition): CellPosition;
isMergeHidden(sheetId: UID, merge: Merge): boolean;
/**
* Check if the zone represents a single cell or a single merge.
*/
isSingleCellOrMerge(sheetId: UID, zone: Zone): boolean;
isMainCellPosition(position: CellPosition): boolean;
/**
* Return true if the current selection requires losing state if it is merged.
* This happens when there is some textual content in other cells than the
* top left.
*/
private isMergeDestructive;
private getMergeById;
private checkDestructiveMerge;
private checkOverlap;
private checkFrozenPanes;
/**
* The content of a merged cell should always be empty.
* Except for the top-left cell.
*/
private checkMergedContentUpdate;
private checkMergeExists;
/**
* Merge the current selection. Note that:
* - it assumes that we have a valid selection (no intersection with other
* merges)
* - it does nothing if the merge is trivial: A1:A1
*/
private addMerge;
private removeMerge;
/**
* Apply a range change on merges of a particular sheet.
*/
private applyRangeChangeOnSheet;
import(data: WorkbookData): void;
private importMerges;
export(data: WorkbookData): void;
exportForExcel(data: ExcelWorkbookData): void;
}
interface Pivot$1 {
definition: PivotCoreDefinition;
formulaId: string;
}
interface CoreState {
nextFormulaId: number;
pivots: Record;
formulaIds: Record;
compiledMeasureFormulas: Record>;
}
declare class PivotCorePlugin extends CorePlugin implements CoreState {
static getters: readonly ["getPivotCoreDefinition", "getPivotDisplayName", "getPivotId", "getPivotFormulaId", "getPivotIds", "getMeasureCompiledFormula", "getPivotName", "isExistingPivot"];
readonly nextFormulaId: number;
readonly pivots: {
[pivotId: UID]: Pivot$1 | undefined;
};
readonly formulaIds: {
[formulaId: UID]: UID | undefined;
};
readonly compiledMeasureFormulas: Record>;
allowDispatch(cmd: CoreCommand): CommandResult.Success | CommandResult.NoChanges | CommandResult.PivotIdNotFound | CommandResult.EmptyName | CommandResult.InvalidDefinition;
handle(cmd: CoreCommand): void;
adaptRanges(applyChange: ApplyRangeChange): void;
getPivotDisplayName(pivotId: UID): string;
getPivotName(pivotId: UID): string;
/**
* Returns the pivot core definition of the pivot with the given id.
* Be careful, this is the core definition, this should be used only in a
* context where the pivot is not loaded yet.
*/
getPivotCoreDefinition(pivotId: UID): PivotCoreDefinition;
/**
* Get the pivot ID (UID) from the formula ID (the one used in the formula)
*/
getPivotId(formulaId: string): UID | undefined;
getPivotFormulaId(pivotId: UID): string;
getPivotIds(): UID[];
isExistingPivot(pivotId: UID): boolean;
getMeasureCompiledFormula(measure: PivotCoreMeasure): RangeCompiledFormula;
private addPivot;
private compileCalculatedMeasures;
private insertPivot;
private resizeSheet;
private getPivotCore;
private compileMeasureFormula;
private replaceMeasureFormula;
private checkDuplicatedMeasureIds;
/**
* Import the pivots
*/
import(data: WorkbookData): void;
/**
* Export the pivots
*/
export(data: WorkbookData): void;
}
declare class SettingsPlugin extends CorePlugin {
static getters: readonly ["getLocale"];
private locale;
allowDispatch(cmd: CoreCommand): CommandResult.Success | CommandResult.InvalidLocale;
handle(cmd: CoreCommand): void;
getLocale(): Locale;
private changeCellsDateFormatWithLocale;
import(data: WorkbookData): void;
export(data: WorkbookData): void;
}
interface SheetState {
readonly sheets: Record;
readonly orderedSheetIds: UID[];
readonly sheetIdsMapName: Record;
readonly cellPosition: Record;
}
declare class SheetPlugin extends CorePlugin implements SheetState {
static getters: readonly ["getSheetName", "tryGetSheetName", "getSheet", "tryGetSheet", "getSheetIdByName", "getSheetIds", "getVisibleSheetIds", "isSheetVisible", "doesHeaderExist", "doesHeadersExist", "getCell", "getCellPosition", "getColsZone", "getRowCells", "getRowsZone", "getNumberCols", "getNumberRows", "getNumberHeaders", "getGridLinesVisibility", "getNextSheetName", "getSheetSize", "getSheetZone", "getPaneDivisions", "checkZonesExistInSheet", "getCommandZones", "getUnboundedZone", "checkElementsIncludeAllNonFrozenHeaders"];
readonly sheetIdsMapName: Record;
readonly orderedSheetIds: UID[];
readonly sheets: Record;
readonly cellPosition: Record;
allowDispatch(cmd: CoreCommand): CommandResult | CommandResult[];
handle(cmd: CoreCommand): void;
import(data: WorkbookData): void;
private exportSheets;
export(data: WorkbookData): void;
exportForExcel(data: ExcelWorkbookData): void;
getGridLinesVisibility(sheetId: UID): boolean;
tryGetSheet(sheetId: UID): Sheet | undefined;
getSheet(sheetId: UID): Sheet;
isSheetVisible(sheetId: UID): boolean;
/**
* Return the sheet name. Throw if the sheet is not found.
*/
getSheetName(sheetId: UID): string;
/**
* Return the sheet name or undefined if the sheet doesn't exist.
*/
tryGetSheetName(sheetId: UID): string | undefined;
getSheetIdByName(name: string | undefined): UID | undefined;
getSheetIds(): UID[];
getVisibleSheetIds(): UID[];
doesHeaderExist(sheetId: UID, dimension: Dimension, index: number): boolean;
doesHeadersExist(sheetId: UID, dimension: Dimension, headerIndexes: HeaderIndex[]): boolean;
getCell({ sheetId, col, row }: CellPosition): Cell | undefined;
getColsZone(sheetId: UID, start: HeaderIndex, end: HeaderIndex): Zone;
getRowCells(sheetId: UID, row: HeaderIndex): UID[];
getRowsZone(sheetId: UID, start: HeaderIndex, end: HeaderIndex): Zone;
getCellPosition(cellId: UID): CellPosition;
getNumberCols(sheetId: UID): number;
getNumberRows(sheetId: UID): number;
getNumberHeaders(sheetId: UID, dimension: Dimension): HeaderIndex;
getNextSheetName(baseName?: string): string;
getSheetSize(sheetId: UID): ZoneDimension;
getSheetZone(sheetId: UID): Zone;
getUnboundedZone(sheetId: UID, zone: Zone | UnboundedZone): UnboundedZone;
getPaneDivisions(sheetId: UID): Readonly;
private setPaneDivisions;
/**
* Checks if all non-frozen header indices are present in the provided elements of selected rows/columns.
* This validation ensures that all rows or columns cannot be deleted when frozen panes exist.
*/
checkElementsIncludeAllNonFrozenHeaders(sheetId: UID, dimension: Dimension, elements: HeaderIndex[]): boolean;
getCommandZones(cmd: Command): Zone[];
/**
* Check if zones in the command are well formed and
* not outside the sheet.
*/
checkZonesExistInSheet(sheetId: UID, zones: Zone[]): CommandResult;
private updateCellPosition;
/**
* Set the cell at a new position and clear its previous position.
*/
private setNewPosition;
/**
* Remove the cell at the given position (if there's one)
*/
private clearPosition;
private setGridLinesVisibility;
private createSheet;
private moveSheet;
private findIndexOfTargetSheet;
private checkSheetName;
private checkSheetPosition;
private checkRowFreezeQuantity;
private checkColFreezeQuantity;
private checkRowFreezeOverlapMerge;
private checkColFreezeOverlapMerge;
private isRenameAllowed;
private renameSheet;
private hideSheet;
private showSheet;
private duplicateSheet;
private getDuplicateSheetName;
private deleteSheet;
/**
* Delete column. This requires a lot of handling:
* - Update all the formulas in all sheets
* - Move the cells
* - Update the cols/rows (size, number, (cells), ...)
* - Reevaluate the cells
*
* @param sheet ID of the sheet on which deletion should be applied
* @param columns Columns to delete
*/
private removeColumns;
/**
* Delete row. This requires a lot of handling:
* - Update the merges
* - Update all the formulas in all sheets
* - Move the cells
* - Update the cols/rows (size, number, (cells), ...)
* - Reevaluate the cells
*
* @param sheet ID of the sheet on which deletion should be applied
* @param rows Rows to delete
*/
private removeRows;
private addColumns;
private addRows;
private moveCellOnColumnsDeletion;
/**
* Move the cells after a column or rows insertion
*/
private moveCellsOnAddition;
/**
* Move all the cells that are from the row under `deleteToRow` up to `deleteFromRow`
*
* b.e.
* move vertically with delete from 3 and delete to 5 will first clear all the cells from lines 3 to 5,
* then take all the row starting at index 6 and add them back at index 3
*
*/
private moveCellOnRowsDeletion;
private updateRowsStructureOnDeletion;
/**
* Add empty rows at the end of the rows
*
* @param sheet Sheet
* @param quantity Number of rows to add
*/
private addEmptyRows;
private getImportedSheetSize;
/**
* Check that any "sheetId" in the command matches an existing
* sheet.
*/
private checkSheetExists;
/**
* Check if zones in the command are well formed and
* not outside the sheet.
*/
private checkZonesAreInSheet;
}
interface TableStylesState {
readonly styles: {
[styleId: string]: TableStyle;
};
}
declare class TableStylePlugin extends CorePlugin implements TableStylesState {
static getters: readonly ["getNewCustomTableStyleName", "getTableStyle", "getTableStyles", "isTableStyleEditable"];
readonly styles: {
[styleId: string]: TableStyle;
};
allowDispatch(cmd: CoreCommand): CommandResult | CommandResult[];
handle(cmd: CoreCommand): void;
getTableStyle(styleId: string): TableStyle;
getTableStyles(): Record