@dou-ui/sheet 0.0.0-stage → 0.1.0-alpha.1

package/dist/types/core/commands.d.ts

@@ -0,0 +1,76 @@
+import type { Component } from 'vue';
+import type { SheetContext } from '../context';
+import type { SheetMessages } from '../locale';
+/** Text shown in a menu or tooltip: fixed, or read from the sheet's messages so it follows the language. */
+export type SheetLabel = string | ((messages: SheetMessages) => string);
+export declare const labelOf: (label: SheetLabel | undefined, messages: SheetMessages) => string;
+/**
+ * Something the sheet can do, by name: toolbar items, menu items and keys
+ * can all refer to it, and take its label, icon and state from it.
+ */
+export interface SheetCommand<Arg = any> {
+    label: SheetLabel;
+    icon?: Component;
+    /**
+     * The key shown beside it, written as in `useHotkey` (e.g. `mod+shift+e`).
+     * Only a hint: bind the key with the extension's `keymap`.
+     */
+    shortcut?: string;
+    /**
+     * Does it. `arg` is what the caller passes to `commands.run`, if anything.
+     * Return `false` when there was nothing to do.
+     */
+    run: (context: SheetContext, arg?: Arg) => boolean | void | Promise<unknown>;
+    /** Whether it can be run now; greyed out in menus and the toolbar when not. Defaults to `true`. */
+    enabled?: (context: SheetContext) => boolean;
+    /** For a command that turns something on and off: whether it is on, e.g. bold for a bold cell. */
+    pressed?: (context: SheetContext) => boolean;
+    /**
+     * Lets it replace the built-in command of the same name. Without it, a
+     * name the sheet already has is an error, so a command isn't replaced by accident.
+     */
+    override?: boolean;
+}
+/** Declares a command; only gives it a type. */
+export declare function defineSheetCommand<Arg = any>(command: SheetCommand<Arg>): SheetCommand<Arg>;
+/** A command as menus and the toolbar show it. */
+export interface SheetCommandInfo {
+    name: string;
+    label: string;
+    icon?: Component;
+    shortcut?: string;
+    /** Whether it turns something on and off (it has `pressed`). */
+    toggle: boolean;
+    /** Whether it is the sheet's own, not added or replaced by an extension. */
+    builtin: boolean;
+}
+/** The commands of a sheet, by name, for `useSheet().commands`. */
+export interface SheetCommands {
+    /**
+     * Runs a command. Returns `false` when it can't be run now (`enabled`
+     * says no) or it had nothing to do; `true` otherwise, also while an
+     * asynchronous one is still running. An unknown name is an error.
+     */
+    run: (name: string, arg?: unknown) => boolean;
+    /** Whether a command is there and can be run now. */
+    can: (name: string) => boolean;
+    /** Whether a command that turns something on and off is on. */
+    pressed: (name: string) => boolean;
+    /** A command's label, icon and shortcut, or `undefined` when there is none by that name. */
+    get: (name: string) => SheetCommandInfo | undefined;
+    /** Whether there is a command by that name. */
+    has: (name: string) => boolean;
+    /** The names of every command, built in and added. */
+    names: () => string[];
+}
+/**
+ * Puts the built-in commands and the extensions' together. An extension's
+ * command with a name already taken is an error, unless it says `override`
+ * and the name is a built-in one.
+ */
+export declare function mergeCommands(builtin: Readonly<Record<string, SheetCommand>>, added: readonly {
+    extension: string;
+    commands: Readonly<Record<string, SheetCommand>>;
+}[]): Map<string, SheetCommand<any>>;
+/** The `commands` of a context, over the commands by name. */
+export declare function createCommands(commands: () => ReadonlyMap<string, SheetCommand>, context: () => SheetContext, builtin?: Readonly<Record<string, SheetCommand>>): SheetCommands;

package/dist/types/core/comments.d.ts

@@ -0,0 +1,22 @@
+import type { SheetWorkbook } from './model';
+import { type SheetTransaction } from './transaction';
+/** Where a thread is: its sheet (by `id`, or name) and cell. */
+export interface SheetCommentAnchor {
+    sheet: string;
+    row: number;
+    col: number;
+    /** The cell as people write it, e.g. `B3`. */
+    address: string;
+}
+/** Every anchored thread in a workbook, by thread id. */
+export declare function sheetCommentAnchors(book: SheetWorkbook): Map<string, SheetCommentAnchor>;
+/**
+ * Puts back the threads `tr` took off their cells by restoring what the
+ * cells held before them, as undo and redo do. `before` is
+ * `sheetCommentAnchors` of the workbook `tr` started from. A thread `tr`
+ * itself puts on another cell (undoing a move) goes there instead, and one
+ * whose row, column or sheet `tr` removed stays off. The threads are put
+ * back in `into`, by default `tr` itself; give another transaction that
+ * starts where `tr` ended to keep them a separate change.
+ */
+export declare function keepCommentAnchors(before: ReadonlyMap<string, SheetCommentAnchor>, tr: SheetTransaction, into?: SheetTransaction): void;

package/dist/types/core/conditional.d.ts

@@ -0,0 +1,114 @@
+import type { Tone } from 'dou-ui';
+import { type SheetBounds } from './address';
+import type { SheetColor, SheetConditionalFormat, SheetRuleRange, SheetStyle } from './model';
+/** What the rules give a cell: a style, and a bar to draw from `from` to `to` (0–1 of its width). */
+export interface SheetLook {
+    style?: SheetStyle;
+    bar?: {
+        from: number;
+        to: number;
+        color: string;
+    };
+    /** The same for looks that are the same, to tell when a cell's look changed. */
+    key: string;
+}
+/** What working out the looks needs from the grid. */
+export interface SheetLookSource {
+    /** What a cell comes to: its formula's result, or its value. */
+    valueAt: (row: number, col: number) => unknown;
+    /** A cell's text as it shows. */
+    textAt: (row: number, col: number) => string;
+    /** Works out a formula as if it were in a cell of the sheet. */
+    evaluate: (formula: string) => unknown;
+    /**
+     * What a cell holds now, compared with `===`: the cell as written, or
+     * its formula's result. While every cell of a range holds the same, what
+     * a rule read of the range is kept from the looks before.
+     */
+    cellStamp?: (row: number, col: number) => unknown;
+    /** The workbook's named styles. */
+    styles?: Record<string, SheetStyle>;
+    /** How many rows and columns the sheet has, to keep whole rows and columns inside it. */
+    size: {
+        rows: number;
+        cols: number;
+    };
+    lang?: string;
+}
+/** A scale's color: a tone's soft fill, which follows the color mode, or the color itself. */
+export declare function fillColor(color: SheetColor): string;
+/** A bar's color: a tone's color, lighter so text stays readable over it, or the color itself. */
+export declare function barColor(color: SheetColor): string;
+/** A cell's own style with the look of its conditional formats over it. */
+export declare function layStyle(own: SheetStyle | undefined, look: SheetStyle): {
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strike?: boolean;
+    tone?: Tone;
+    fill?: Tone;
+    color?: string;
+    background?: string;
+    align?: "left" | "center" | "right";
+    valign?: "top" | "middle" | "bottom";
+    wrap?: boolean;
+    locked?: boolean;
+};
+/** The bounds of a range, kept inside the sheet; `null` when it isn't a range. */
+export declare function boundsIn(text: string, size: {
+    rows: number;
+    cols: number;
+}): SheetBounds | null;
+/** The ranges of a rule as a list. */
+export declare const rangesOf: (range: SheetRuleRange) => readonly string[];
+/** A rule's ranges as text, such as `'E2:E9, G2:J9'`. */
+export declare const ruleRangeText: (range: SheetRuleRange) => string;
+/**
+ * Reads ranges written as text, separated by commas or spaces: one range
+ * as a string, several as a list; `null` when one of them isn't a range.
+ */
+export declare function readRuleRange(text: string): SheetRuleRange | null;
+/**
+ * The bounds of a rule's ranges inside the sheet, leaving out those that
+ * aren't ranges or lie outside it, and the cell its formula is written for:
+ * the top left of the first range.
+ */
+export declare function areasIn(range: SheetRuleRange, size: {
+    rows: number;
+    cols: number;
+}): {
+    areas: SheetBounds[];
+    anchor: {
+        row: number;
+        col: number;
+    };
+};
+/**
+ * The looks a sheet's conditional formats give its cells. Make a new one
+ * when the workbook changes; within one, each cell is worked out once.
+ */
+export declare class SheetLooks {
+    private source;
+    private rules;
+    private looks;
+    private collator;
+    /**
+     * `previous`, the looks before a change, lends what its rules read of
+     * ranges whose rows are the same, so a change elsewhere doesn't read a
+     * large range again.
+     */
+    constructor(formats: readonly SheetConditionalFormat[] | undefined, source: SheetLookSource, previous?: SheetLooks);
+    /** Whether the cells of an old rule's ranges hold what they did. */
+    private sameCells;
+    /** Whether there are any rules. */
+    get empty(): boolean;
+    /** The columns of a row that rules cover, as `[left, right]` pairs. */
+    spansIn(row: number): [number, number][];
+    /** What the rules give a cell, or `undefined` when none applies. */
+    lookAt(row: number, col: number): SheetLook | undefined;
+    private work;
+    private stats;
+    private meets;
+    private scaleAt;
+    private barAt;
+}

package/dist/types/core/csv.d.ts

@@ -0,0 +1,93 @@
+import { type SheetBounds, type SheetRange } from './address';
+import { type SheetCellInput, type SheetData, type SheetRow, type SheetValue } from './model';
+import { type SheetResult } from '../formula/values';
+/**
+ * The delimiter a text most likely uses: of `,`, `;`, tab and `|`, the one
+ * found most often outside quotes in its first lines, and the same number
+ * of times on each. A comma when none is found.
+ */
+export declare function detectDelimiter(text: string): string;
+/**
+ * Splits delimited text into rows of fields, reading quoted fields; a
+ * byte order mark at the start is dropped. `delimiter` defaults to the one
+ * `detectDelimiter` finds.
+ */
+export declare function parseCSV(text: string, delimiter?: string): string[][];
+export interface SheetCSVReadOptions {
+    /** `,`, `;`, a tab…; found from the text when left out. */
+    delimiter?: string;
+    /**
+     * Reads numbers, dates, times, percentages and `TRUE` / `FALSE` as such,
+     * the way typing them does; `false` keeps every field as text. Fields
+     * that look like codes, `007` or a long card number, stay text either way.
+     */
+    typed?: boolean;
+    /**
+     * The decimal mark of numbers: `,` reads `1,5` as 1.5 and `1.280,5` as
+     * 1280.5. Defaults to `,` when fields are split by `;`, as files written
+     * with a decimal comma are, otherwise `.`.
+     */
+    decimal?: '.' | ',';
+    /** Reads fields starting with `=` as formulas; by default they are text. */
+    formulas?: boolean;
+}
+/** The cells of a CSV, row by row, ready for a sheet's `cells` or `tr.setCells`. */
+export declare function readCSV(text: string, options?: SheetCSVReadOptions): SheetRow[];
+export interface SheetCSVWriteOptions {
+    /** `,` by default. */
+    delimiter?: string;
+    /** Only these cells, such as `'A1:D20'`; by default up to the last row and column with data. */
+    range?: string | SheetRange;
+    /**
+     * Writes what each cell shows, with its format (`¥1,280.00`,
+     * `2026年3月5日`), instead of values a spreadsheet can sort and add up
+     * (`1280`, `2026-03-05`, what formulas come to). Off by default.
+     */
+    text?: boolean;
+    /**
+     * Writes formulas as written (`=A1+B1`) instead of what they come to,
+     * to read back with `readCSV(text, { formulas: true })`. Ignored with
+     * `text`. Off by default.
+     */
+    formulas?: boolean;
+    /** The language dates are shown in, with `text`. */
+    locale?: string;
+    /**
+     * What a formula comes to, by its row and column in the sheet, e.g. from
+     * `SheetFormulaEngine.result`. Without it a formula is written as text,
+     * with a `'` before it unless `escapeFormulas` is off; for formulas a
+     * spreadsheet can work out, use `formulas`.
+     */
+    result?: (row: number, col: number) => SheetResult;
+    /**
+     * With `text`: a cell's text, e.g. as its cell type shows it; `undefined`
+     * uses its format. `value` is its value, or its formula's result; `row`
+     * and `col` are where it is in the sheet.
+     */
+    cellText?: (input: SheetCellInput, value: SheetValue, row: number, col: number) => string | undefined;
+    /**
+     * Without `text`: the value to write for a cell, as a cell type's `plain`
+     * gives it; `null` writes nothing, `undefined` writes its value, or its
+     * formula's result. Not asked for formulas written with `formulas`.
+     */
+    cellPlain?: (input: SheetCellInput, value: SheetValue, row: number, col: number) => SheetValue | undefined;
+    /** Line breaks between rows; `\r\n` by default, as the format asks. */
+    newline?: string;
+    /**
+     * Starts with a byte order mark, so programs that guess the encoding read
+     * it as UTF-8. On by default.
+     */
+    bom?: boolean;
+    /**
+     * Puts a `'` before text starting with `=`, `+`, `-`, `@`, a tab or a
+     * carriage return, so a spreadsheet program opening the file doesn't run
+     * it as a formula. Numbers are written as they are, and so are this grid's
+     * formulas with `formulas`. On by default; `false` writes such text as
+     * it is.
+     */
+    escapeFormulas?: boolean;
+}
+/** Where a sheet has data: up to its last row and column with something in them. */
+export declare function dataBounds(sheet: SheetData): SheetBounds | null;
+/** A sheet, or part of it, as CSV. */
+export declare function sheetToCSV(sheet: SheetData, options?: SheetCSVWriteOptions): string;

package/dist/types/core/data.d.ts

@@ -0,0 +1,26 @@
+import type { SheetCondition, SheetFilterRule, SheetSortOrder } from './model';
+/** One column to sort by, the first deciding most. */
+export interface SheetSortKey {
+    /** The column, by number. */
+    col: number;
+    order?: SheetSortOrder;
+}
+/** Whether a value counts as empty: empty cells sort last, either way. */
+export declare const isEmptyValue: (value: unknown) => value is "" | null | undefined;
+/** Compares text the way people of `lang` read it: numbers inside by size, case ignored. */
+export declare function textCollator(lang?: string): Intl.Collator;
+/**
+ * Compares two values for sorting from small to large: numbers first, then
+ * text, then `FALSE` and `TRUE`, then errors. Empty values are not compared
+ * here; they go last whatever the order.
+ */
+export declare function compareForSort(a: unknown, b: unknown, collator?: Intl.Collator): number;
+/**
+ * The order to put rows in, sorted by `keys`: a list of the given rows.
+ * Equal rows keep their order; empty values go last in either order.
+ */
+export declare function sortRows(rows: readonly number[], keys: readonly SheetSortKey[], valueAt: (row: number, col: number) => unknown, collator?: Intl.Collator): number[];
+/** Whether a cell meets a condition, given what it comes to and how it shows. */
+export declare function meetsCondition(condition: SheetCondition, value: unknown, text: string, collator?: Intl.Collator): boolean;
+/** Whether a cell is kept by a column's filter rule. */
+export declare function meetsRule(rule: SheetFilterRule, value: unknown, text: string, collator?: Intl.Collator): boolean;

package/dist/types/core/document.d.ts

@@ -0,0 +1,49 @@
+import { type SheetExtension } from './extension';
+import type { SheetWorkbook } from './model';
+/** A workbook with no sheets, to start from when nothing is saved yet. */
+export declare const emptyWorkbook: () => SheetWorkbook;
+export interface WorkbookProblem {
+    code: 'version' | 'shape' | 'missing-name' | 'duplicate-name' | 'duplicate-id' | 'unknown-style' | 'unknown-type' | 'bad-merge';
+    /** The name of the sheet at fault; none for the workbook's own problems. */
+    sheet?: string;
+    /**
+     * Where the problem is, as a path into the workbook, e.g. `sheets[1]`,
+     * `sheets[0].cells[3][2]` or `types.status`; `version` for the version.
+     */
+    path: string;
+    /** The name, style, type or range at fault, for the editor's message. */
+    text: string;
+    /** An English description, for logs. */
+    message: string;
+}
+export interface CheckWorkbookOptions {
+    /**
+     * The sheet's `extensions`, for the cell types they add. Without them only
+     * the built-in types (`date`, `select`, `checkbox`) and the workbook's own
+     * `types` are known.
+     */
+    extensions?: readonly (SheetExtension | readonly SheetExtension[])[];
+}
+/**
+ * The problems of a workbook, before it is saved or shown: an unknown
+ * version, sheets without a name or sharing a name or id, cells using a
+ * style or type nobody defined, and merges that are not ranges or overlap
+ * another.
+ */
+export declare function checkWorkbook(workbook: SheetWorkbook, options?: CheckWorkbookOptions): WorkbookProblem[];
+/**
+ * Brings a saved workbook up to the current version, and fills what an
+ * older or hand-written one may lack (`version`, `sheets`, each sheet's
+ * `cells`). Sheets that are not objects are dropped; anything else is kept
+ * as it is. Throws for data that is not an object
+ * (an array, `null`, a string) and for a version it does not know.
+ */
+export declare function migrateWorkbook(input: unknown): SheetWorkbook;
+/**
+ * The `v-model` as the sheet reads it. A workbook of the wrong shape (not
+ * an object, without `sheets`, without a known `version`) gets a warning in
+ * development and is read with what is missing left empty and the version
+ * as 1, so the sheet still opens and what it writes back carries
+ * `version: 1`.
+ */
+export declare function readWorkbook(value: unknown): SheetWorkbook;

package/dist/types/core/extension.d.ts

@@ -0,0 +1,177 @@
+import type { CommentAction, CommentThread } from 'dou-ui';
+import type { Component, Ref } from 'vue';
+import type { SheetContext } from '../context';
+import type { SheetMenuContext, SheetMenuItem, SheetToolbarItem } from '../types';
+import type { SheetCommand } from './commands';
+import type { SheetExporter, SheetImporter } from './file';
+import type { SheetFunction } from '../formula/functions';
+import type { SheetCellType } from './cell-type';
+import type { SheetClip } from './clipboard';
+import type { SheetWorkbook } from './model';
+import type { SheetTransaction } from './transaction';
+/** What an extension's hooks receive; the same as `useSheet()`. */
+export type SheetExtensionContext = SheetContext;
+/**
+ * A key handler: return `false` to let the key through to the next handler
+ * and the grid's own keys; anything else means it was handled.
+ */
+export type SheetKeyHandler = (event: KeyboardEvent) => boolean | void;
+/** An undo history used instead of the grid's own, e.g. one that only takes back this user's changes. */
+export interface SheetHistoryHandler {
+    /** `false` when there was nothing to undo. */
+    undo: () => boolean;
+    redo: () => boolean;
+    canUndo: () => boolean;
+    canRedo: () => boolean;
+}
+/** A change the grid has made, as an extension's `update` sees it. */
+export interface SheetUpdate {
+    /** The workbook before the change. */
+    before: SheetWorkbook;
+    /** The workbook now. */
+    doc: SheetWorkbook;
+    /**
+     * The change: typing, commands, undo and redo, `transact` and other
+     * people's changes. `transaction.meta.action` says what made it, and
+     * other people's changes in collaboration have `meta.origin` `'remote'`.
+     * `null` when a new workbook came in through `v-model`.
+     */
+    transaction: SheetTransaction | null;
+}
+/** Where the comment threads live, when not in `v-model:comments`. */
+export interface SheetCommentsProvider {
+    /** The threads, kept up to date. */
+    threads: Readonly<Ref<readonly CommentThread[]>>;
+    /** Make a change this user asked for. */
+    apply: (action: CommentAction) => void;
+}
+/**
+ * A piece of the sheet: cell types, keys, menu items, panels drawn over
+ * the grid, and a say in every change.
+ */
+export interface SheetExtension {
+    name: string;
+    /** Higher runs first: its keys and hooks come before others. Defaults to 100. */
+    priority?: number;
+    /** Cell types cells can name with `type`; one with a built-in name replaces it. */
+    cellTypes?: SheetCellType[];
+    /**
+     * Functions formulas can call (see `defineSheetFunction`); one with a
+     * built-in name replaces it.
+     */
+    functions?: SheetFunction[];
+    /**
+     * Commands, by name: things toolbar items, menu items and keys can refer
+     * to. Start the names with the extension's, e.g. `xlsx.export`. A name the
+     * sheet already has replaces that command only with `override: true`.
+     */
+    commands?: Record<string, SheetCommand>;
+    /**
+     * Ways to write files, offered in the toolbar's export menu and by
+     * `exportFile`. One with a built-in name (`csv`, `png`, `svg`) replaces it.
+     */
+    exporters?: SheetExporter[];
+    /**
+     * Ways to read files, for the toolbar's import button, `importFile` and
+     * dropped files. They are asked before the built-in CSV one.
+     */
+    importers?: SheetImporter[];
+    /**
+     * Keys, written as in `useHotkey` (e.g. `mod+b`, `alt+arrowdown`), while the
+     * grid has focus and no cell is being edited: a handler, or the name of a
+     * command to run. They come before the grid's own.
+     */
+    keymap?: (context: SheetExtensionContext) => Record<string, SheetKeyHandler | string>;
+    /** Items for the right-click menu, put before the built-in ones. */
+    contextMenu?: (context: SheetExtensionContext, menu: SheetMenuContext) => SheetMenuItem[];
+    /**
+     * Items for `DouSheetToolbar`: after the built-in tools, or where its
+     * `tools` names them by `key`.
+     */
+    toolbar?: (context: SheetExtensionContext) => SheetToolbarItem[];
+    /**
+     * Components drawn over the grid, not scrolled with it, e.g. a panel or
+     * marks placed with `cellRect`. They can call `useSheet()`.
+     */
+    overlays?: Component[];
+    /**
+     * Components drawn over the cells, kept out of the headers: `below`
+     * under the grid's own marks, such as the copied range and formula
+     * references, `above` over them; the editor stays on top. They place marks with
+     * `useSheet()`'s `cellRect` and `rangeRect`, which follow the scroll, and
+     * take no clicks.
+     */
+    layers?: {
+        below?: Component[];
+        above?: Component[];
+    };
+    /**
+     * Keeps the comment threads somewhere else than `v-model:comments`, e.g.
+     * in a shared document; `v-model:comments` then only mirrors them. Only
+     * one extension may.
+     */
+    comments?: (context: SheetExtensionContext) => SheetCommentsProvider;
+    /** Replaces the grid's undo history; the first extension that has one wins. */
+    history?: (context: SheetExtensionContext) => SheetHistoryHandler;
+    /** Runs once the grid is mounted. Return a function to run when it unmounts. */
+    setup?: (context: SheetExtensionContext) => void | (() => void);
+    /**
+     * Sees every change made in the grid or with `transact` before it is
+     * applied, in priority order, and may add steps to it. Undo takes back
+     * the added steps with the rest.
+     */
+    transaction?: (tr: SheetTransaction, context: SheetExtensionContext) => void;
+    /**
+     * Runs after every change, with the workbook already updated: changes in
+     * the grid, `transact`, undo and redo, other people's changes and a new
+     * `v-model` workbook. For keeping something else in step, such as a save
+     * reminder; to change the change itself use `transaction`.
+     */
+    update?: (update: SheetUpdate, context: SheetExtensionContext) => void;
+    /**
+     * Rewrites cells before they are pasted, or imported at the active cell,
+     * in priority order; return `null` to stop it. A paste's `paste` event
+     * comes after, with what the extensions made of it; an import has none.
+     * Cut cells that come back rewritten still leave their place, in the
+     * same step, but formulas pointing at them don't follow.
+     */
+    transformPaste?: (clip: SheetClip, context: SheetExtensionContext) => SheetClip | null;
+}
+/** Declares an extension; only gives it a type. */
+export declare function defineSheetExtension(extension: SheetExtension): SheetExtension;
+/** Everything the extensions contribute, gathered once per list. */
+export interface ResolvedSheetExtensions {
+    extensions: SheetExtension[];
+    cellTypes: SheetCellType[];
+    functions: SheetFunction[];
+    commands: {
+        extension: string;
+        commands: Record<string, SheetCommand>;
+    }[];
+    exporters: {
+        extension: string;
+        exporter: SheetExporter;
+    }[];
+    importers: {
+        extension: string;
+        importer: SheetImporter;
+    }[];
+    keymaps: NonNullable<SheetExtension['keymap']>[];
+    toolbars: NonNullable<SheetExtension['toolbar']>[];
+    menus: NonNullable<SheetExtension['contextMenu']>[];
+    setups: NonNullable<SheetExtension['setup']>[];
+    transactions: NonNullable<SheetExtension['transaction']>[];
+    updates: NonNullable<SheetExtension['update']>[];
+    pasteTransforms: NonNullable<SheetExtension['transformPaste']>[];
+    overlays: Component[];
+    layers: {
+        below: Component[];
+        above: Component[];
+    };
+    history?: SheetExtension['history'];
+    comments?: SheetExtension['comments'];
+}
+type ExtensionList = readonly (SheetExtension | readonly SheetExtension[])[];
+/** Sorts the extensions by priority and collects what they add. */
+export declare function resolveSheetExtensions(list?: ExtensionList): ResolvedSheetExtensions;
+export {};