@xlcalc/vue 0.21.2 → 0.23.1

package/dist/contract/messages.d.ts

@@ -1,4 +1,6 @@
-export interface SheetMessages {
+import type { ConditionalFormat, IconSetName } from 'xlcalc/contract';
+import type { QuickRule } from './conditional.js';
+export interface SheetMessages extends ConditionalMessages {
     back: string;
     backEmpty: string;
     address: string;
@@ -187,6 +189,11 @@ export interface SheetMessages {
     italic: string;
     underline: string;
     fontColor: string;
+    /** The Font and Font Size boxes, and Increase and Decrease Font Size. */
+    fontName: string;
+    fontSize: string;
+    fontSizeUp: string;
+    fontSizeDown: string;
     fillColor: string;
     pickColor: string;
     colorAuto: string;
@@ -199,8 +206,20 @@ export interface SheetMessages {
     alignLeft: string;
     alignCenter: string;
     alignRight: string;
+    alignTop: string;
+    alignMiddle: string;
+    alignBottom: string;
+    indentDecrease: string;
+    indentIncrease: string;
     wrapText: string;
     numberFormat: string;
+    /** Excel's Percent Style button, with its key. */
+    percentStyle: string;
+    /** Excel's Accounting Number Format, Comma Style, Increase Decimal and Decrease Decimal buttons. */
+    accountingStyle: string;
+    commaStyle: string;
+    decimalIncrease: string;
+    decimalDecrease: string;
     /** Excel's Format Cells dialog (`FormatDialog`): its tabs, inputs and the names of their options. */
     formatCells: string;
     formatCellsOpen: string;
@@ -257,4 +276,244 @@ export interface SheetMessages {
     mergeCells: string;
     unmergeCells: string;
     mergeWarning: string;
+    /** Excel's Go To dialog (F5, Ctrl+G): its title, the list's label, the Reference box, and its message for text that is not a reference. */
+    goToTitle: string;
+    goToList: string;
+    goToReference: string;
+    goToBad: string;
+    /** Excel's Symbol dialog: its title and tabs, the Subset box and its blocks, the recently used row, the Character code box, the Special Characters tab's names, Insert. */
+    symbolTitle: string;
+    symbolTab: (tab: 'symbols' | 'special') => string;
+    symbolSubsetLabel: string;
+    symbolSubset: (subset: SymbolSubset) => string;
+    symbolRecent: string;
+    symbolCode: string;
+    symbolCodeFrom: string;
+    symbolCharacter: string;
+    symbolSpecial: (character: SymbolSpecial) => string;
+    symbolInsert: string;
+    /** Defined names: the Name Box's list button, its messages for a typed name, the cell menu's Define Name, and a name in Formula AutoComplete. */
+    nameBoxList: string;
+    nameBoxBad: string;
+    nameNotRange: string;
+    menuDefineName: string;
+    nameItem: (name: string) => string;
+    /** Excel's New Name and Edit Name dialog and its fields; the scope that is not a sheet. */
+    nameNewTitle: string;
+    nameEditTitle: string;
+    nameLabel: string;
+    nameScope: string;
+    nameRefersTo: string;
+    nameWorkbook: string;
+    /** Excel's Name Manager: its title, buttons, the list's columns, Commit beside Refers to, and its questions before a deletion and before closing with an edited reference. */
+    nameManager: string;
+    nameNew: string;
+    nameEdit: string;
+    nameDelete: string;
+    nameColumn: (column: 'name' | 'refersTo' | 'scope') => string;
+    nameCommit: string;
+    nameDeleteAsk: (name: string) => string;
+    nameSaveAsk: string;
+    /** Excel's zoom on the status bar (Zoom Out, the slider, Zoom In, the percentage that opens the Zoom dialog), and the dialog's title, choices and limits. */
+    zoomOut: string;
+    zoomIn: string;
+    zoomSlider: string;
+    zoomLevel: string;
+    zoomTitle: string;
+    zoomFit: string;
+    zoomCustom: string;
+    zoomRange: string;
+    /** Excel's Watch Window: its title, Add Watch and Delete Watch, its columns, and the cap on the cells watched. */
+    watchTitle: string;
+    watchAdd: string;
+    watchDelete: string;
+    watchBook: string;
+    watchSheet: string;
+    watchName: string;
+    watchCell: string;
+    watchValue: string;
+    watchFormula: string;
+    watchTooMany: (max: number) => string;
+    /** Excel's Trace Dependents: the message when no formula refers to the active cell, and when the source could not be asked. */
+    traceNone: string;
+    traceFailed: string;
+    /** Excel's Create Table dialog, the range it refuses, the words a new table's and an unnamed column's names start with (`Table1`, `Column1`), and Convert to Range's question. */
+    tableCreate: string;
+    tableWhere: string;
+    tableHeaders: string;
+    tableRangeBad: string;
+    tableNamePrefix: string;
+    tableColumnPrefix: string;
+    tableConvert: string;
+    /** Excel's Spelling dialog: its title, boxes and buttons (Cancel is `cancel`), the message when the check is complete, and the one when it fails. */
+    spelling: string;
+    spellNotInDictionary: string;
+    spellSuggestions: string;
+    spellNoSuggestions: string;
+    spellIgnoreOnce: string;
+    spellIgnoreAll: string;
+    spellAdd: string;
+    spellChange: string;
+    spellChangeAll: string;
+    spellDone: string;
+    spellFailed: string;
+    /** Excel's hyperlink items in the cell menu and its Insert Hyperlink dialog (Edit Hyperlink on a cell with a link), with Excel's names. */
+    menuLink: string;
+    menuEditLink: string;
+    menuOpenLink: string;
+    menuRemoveLink: string;
+    linkInsertTitle: string;
+    linkEditTitle: string;
+    linkTo: string;
+    linkToFile: string;
+    linkToPlace: string;
+    linkText: string;
+    /** Text to Display over several cells or a formula, which the link does not change. */
+    linkSelection: string;
+    linkTip: string;
+    linkAddress: string;
+    linkRef: string;
+    linkPlaces: string;
+    linkCellReference: string;
+    linkDefinedNames: string;
+    linkRemove: string;
+    linkBadRef: string;
+    /** Excel's note items in the cell menu (New Note, Edit Note, Delete Note) and the note box's label. */
+    menuNewNote: string;
+    menuEditNote: string;
+    menuDeleteNote: string;
+    noteEditor: string;
+    /** Excel's Data Validation dialog: its title and tabs, the Settings tab's boxes by the rule's type and comparison, the Input Message and Error Alert tabs (the styles are `validationStyle`), Clear All, Excel's questions before it opens and its checks before OK. */
+    dataValidation: string;
+    dvTab: (tab: 'settings' | 'input' | 'error') => string;
+    dvCriteria: string;
+    dvAllow: string;
+    dvType: (type: 'any' | 'whole' | 'decimal' | 'list' | 'date' | 'time' | 'textLength' | 'custom') => string;
+    dvData: string;
+    dvOperator: (op: 'between' | 'notBetween' | 'equal' | 'notEqual' | 'greaterThan' | 'lessThan' | 'greaterThanOrEqual' | 'lessThanOrEqual') => string;
+    dvBox: (box: 'min' | 'max' | 'value' | 'length' | 'start' | 'end' | 'date' | 'startTime' | 'endTime' | 'time' | 'source' | 'formula') => string;
+    dvIgnoreBlank: string;
+    dvDropdown: string;
+    dvApplyAll: string;
+    dvShowPrompt: string;
+    dvPromptLead: string;
+    dvFieldTitle: string;
+    dvPromptText: string;
+    dvShowError: string;
+    dvErrorLead: string;
+    dvStyle: string;
+    dvErrorText: string;
+    dvClearAll: string;
+    dvMany: string;
+    dvExtend: string;
+    /** OK refused: an empty box, a box whose value is not one, a maximum below the minimum; with the boxes' names from `dvBox`. */
+    dvEmpty: (box: string) => string;
+    dvInvalid: (box: string) => string;
+    dvOrder: (min: string, max: string) => string;
 }
+/** The Symbol dialog's Subset list: Unicode blocks by Excel's names (`basicLatin` is Basic Latin, `latin1` Latin-1 Supplement). */
+export type SymbolSubset = 'basicLatin' | 'latin1' | 'latinExtA' | 'latinExtB' | 'ipa' | 'spacingModifiers' | 'combiningMarks' | 'greek' | 'cyrillic' | 'cyrillicSupplement' | 'phoneticExt' | 'latinExtAdditional' | 'greekExt' | 'punctuation' | 'superSub' | 'currency' | 'letterlike' | 'numberForms' | 'arrows' | 'math' | 'technical' | 'enclosed' | 'boxDrawing' | 'blocks' | 'geometric' | 'miscSymbols' | 'dingbats' | 'latinExtC' | 'presentationForms' | 'specials';
+/** The characters of the Symbol dialog's Special Characters tab, in Excel's order. */
+export type SymbolSpecial = 'emDash' | 'enDash' | 'nonBreakingHyphen' | 'optionalHyphen' | 'emSpace' | 'enSpace' | 'quarterEmSpace' | 'nonBreakingSpace' | 'copyright' | 'registered' | 'trademark' | 'section' | 'paragraph' | 'ellipsis' | 'singleOpeningQuote' | 'singleClosingQuote' | 'doubleOpeningQuote' | 'doubleClosingQuote' | 'noWidthOptionalBreak' | 'noWidthNonBreak';
+type CfOperator = Extract<ConditionalFormat, {
+    type: 'cellIs';
+}>['operator'];
+type CfTextType = 'containsText' | 'notContainsText' | 'beginsWith' | 'endsWith';
+type CfPeriod = Extract<ConditionalFormat, {
+    type: 'timePeriod';
+}>['period'];
+type CfValueType = 'min' | 'max' | 'num' | 'percent' | 'formula' | 'percentile' | 'autoMin' | 'autoMax';
+/** Excel's conditional formatting dialogs: the quick rules' dialogs, the Rules Manager, New and Edit Formatting Rule, a rule's Format Cells. */
+export interface ConditionalMessages {
+    /** A quick rule's dialog: its title, the label above its box, and the "with" box's formats, Custom Format last. */
+    cfQuickTitle: (kind: QuickRule) => string;
+    cfQuickLabel: (kind: QuickRule) => string;
+    cfWith: string;
+    cfAnd: string;
+    cfValuesWith: string;
+    cfForRange: string;
+    cfPreset: (preset: 'lightRedDarkRed' | 'yellowDarkYellow' | 'greenDarkGreen' | 'lightRed' | 'redText' | 'redBorder') => string;
+    cfCustomFormat: string;
+    cfPeriod: (period: CfPeriod) => string;
+    cfDuplicate: (unique: boolean) => string;
+    /** Why OK does not write the rule. */
+    cfValueMissing: string;
+    cfRankRange: (max: number) => string;
+    cfPercentRange: string;
+    cfRelative: string;
+    cfAppliesBad: string;
+    /** The Rules Manager: its list's choice, buttons, columns and the rules' descriptions. */
+    cfManager: string;
+    cfShowFor: string;
+    cfShowSelection: string;
+    cfShowSheet: string;
+    cfNewRule: string;
+    cfEditRule: string;
+    cfDeleteRule: string;
+    cfDuplicateRule: string;
+    cfMoveUp: string;
+    cfMoveDown: string;
+    cfColRule: string;
+    cfColFormat: string;
+    cfColApplies: string;
+    cfColStop: string;
+    cfApply: string;
+    cfLoading: string;
+    cfNoFormat: string;
+    cfSample: string;
+    cfDescCell: (operator: CfOperator, a: string, b?: string) => string;
+    cfDescFormula: (formula: string) => string;
+    cfDescText: (type: CfTextType, text: string) => string;
+    cfDescBlanks: (type: 'containsBlanks' | 'notContainsBlanks' | 'containsErrors' | 'notContainsErrors') => string;
+    cfDescTop: (rank: number, percent: boolean, bottom: boolean) => string;
+    cfDescAverage: (below: boolean, equal: boolean, stdDev?: number) => string;
+    cfDescDuplicate: (unique: boolean) => string;
+    cfDescScale: string;
+    cfDescBar: string;
+    cfDescIcons: string;
+    /** New Formatting Rule and Edit Formatting Rule: the rule types and each one's inputs. */
+    cfNewTitle: string;
+    cfEditTitle: string;
+    cfSelectType: string;
+    cfType: (kind: 'values' | 'contain' | 'rank' | 'average' | 'unique' | 'formula') => string;
+    cfEditDescription: string;
+    cfFormatStyle: string;
+    cfStyleKind: (style: 'scale2' | 'scale3' | 'dataBar' | 'iconSet') => string;
+    cfPoint: (which: 'min' | 'mid' | 'max') => string;
+    cfTypeLabel: string;
+    cfValueLabel: string;
+    cfColorLabel: string;
+    cfValueType: (type: CfValueType) => string;
+    cfBarAppearance: string;
+    cfBarFill: (gradient: boolean) => string;
+    cfBarBorder: (on: boolean) => string;
+    cfShowBarOnly: string;
+    cfDirection: string;
+    cfDirectionKind: (d: 'context' | 'leftToRight' | 'rightToLeft') => string;
+    cfIconStyle: string;
+    cfIconSet: (set: IconSetName) => string;
+    cfReverse: string;
+    cfShowIconOnly: string;
+    cfIconRules: string;
+    cfWhenValue: string;
+    cfIconLast: string;
+    cfFormatOnly: string;
+    cfContain: (kind: 'cellValue' | 'text' | 'dates' | 'blanks' | 'noBlanks' | 'errors' | 'noErrors') => string;
+    cfOperator: (operator: CfOperator) => string;
+    cfTextOp: (type: CfTextType) => string;
+    cfRankLabel: string;
+    cfTopBottom: (top: boolean) => string;
+    cfPercentOf: string;
+    cfAverageLabel: string;
+    cfAverageKind: (kind: 'above' | 'below' | 'equalAbove' | 'equalBelow' | 'std1Above' | 'std2Above' | 'std3Above' | 'std1Below' | 'std2Below' | 'std3Below') => string;
+    cfAverageOf: string;
+    cfUniqueLabel: string;
+    cfInRange: string;
+    cfFormulaLabel: string;
+    cfPreview: string;
+    cfFormatButton: string;
+    /** A rule's Format Cells: no choice in a list, and Clear. */
+    cfNotSet: string;
+    cfClear: string;
+}
+export {};

package/dist/contract/source.d.ts

@@ -5,6 +5,7 @@
  * is read-only, without `find` there is no search, and so on.
  */
 import type { CellStyle, CellValue, ConditionalAppearance, FunctionSignature, NumberFormat, StructureOp, StylePatch } from 'xlcalc/contract';
+import type { ClearKind, SheetDependents, SheetLink, SheetName, SheetNote, SheetRules, SpellingHit, SpellingRequest, TableOp } from './workbook.js';
 /** The sheet's data source; the component accesses its data only through this interface. */
 export interface SheetSource {
     /** The workbook's sheets in order; read again after a structure change and on a `reload` event. */
@@ -93,6 +94,30 @@ export interface SheetSource {
         }[];
         more: number;
     }>;
+    /** Excel's Clear Formats and Clear All over ranges, as a single undo step; Delete clears contents through `edit`. Without it neither is offered. */
+    clear?(sheet: string, ranges: string[], what: ClearKind): Promise<EditOutcome>;
+    /** Excel's Insert Link over a range (null: Remove Hyperlinks), the cells' contents kept; a single undo step. Without it links can be followed but not edited. */
+    link?(sheet: string, range: string, link: SheetLink | null): Promise<EditOutcome>;
+    /** Excel's New Note and Edit Note on a cell (null: Delete Note); a single undo step. Without it notes are shown but not edited. */
+    note?(sheet: string, cell: string, note: SheetNote | null): Promise<EditOutcome>;
+    /** The workbook's defined names, for the Name Box, Go To, Formula AutoComplete and the Name Manager. */
+    names?(signal?: AbortSignal): Promise<SheetName[]>;
+    /** Replaces the workbook's defined names (Excel's Name Manager and Define Name), as a single undo step; a name Excel rejects is refused with its message. */
+    setNames?(names: SheetName[]): Promise<EditOutcome>;
+    /** The cells whose formulas refer directly to a range, for Excel's Trace Dependents. Without it there are no arrows. */
+    dependents?(sheet: string, range: string, signal?: AbortSignal): Promise<SheetDependents>;
+    /** A sheet's conditional formatting and data validation rules, for their dialogs. */
+    rules?(sheet: string, signal?: AbortSignal): Promise<SheetRules>;
+    /** Replaces a sheet's conditional formatting rules, its data validation rules, or both, as a single undo step. Without it the rules are applied but not edited. */
+    setRules?(sheet: string, rules: Partial<SheetRules>): Promise<EditOutcome>;
+    /** Excel's table commands. Without it there is no Format as Table. */
+    table?(op: TableOp): Promise<EditOutcome>;
+    /** Excel's Spelling: the next misspelt word from `req.after` on, wrapping around once, or null when there is none. Without it there is no Spelling. */
+    spelling?(req: SpellingRequest, signal?: AbortSignal): Promise<SpellingHit | null>;
+    /** Excel's Add to Dictionary in the Spelling dialog: the word is the user's own from now on. */
+    learnWord?(word: string): Promise<void>;
+    /** Excel's AutoSum (Alt+=) at a cell: the range it offers and its `SUM`; null when the source cannot guess one. Without it there is no AutoSum. */
+    autoSum?(sheet: string, cell: string, signal?: AbortSignal): Promise<SheetAutoSum | null>;
     /** The maximum number of cells in one window, 20,000 by default. */
     readonly maxCells?: number;
     /** The number of steps `undo` and `redo` can take, as of the last completed call: a toolbar enables its buttons by them. */
@@ -101,6 +126,15 @@ export interface SheetSource {
         readonly redo: number;
     };
 }
+/**
+ * Excel's AutoSum at a cell: the range it offers to sum (the run of numbers above the cell, else to its left, up to a
+ * subtotal; the subtotals alone when the nearest is one), null without numbers, and the formula it enters, as the source
+ * displays formulas, without `=` (`SUM(B2:B9)`, `СУММ(B2:B9)` in ru-RU, `SUM()` without a range).
+ */
+export interface SheetAutoSum {
+    range: string | null;
+    formula: string;
+}
 /** A function's signature as returned by a source, with what Excel's Insert Function displays under the syntax: a one-line description of the function, in the source's locale. */
 export type SheetFunctionSignature = FunctionSignature & {
     description?: string;
@@ -158,6 +192,13 @@ export interface SheetInfo {
     totals?: (string | null)[];
     /** Excel's outline (Data > Group): the sheet's groups of rows and columns; a sheet without groups has none. */
     outline?: SheetOutline;
+    /** The workbook's default font (its Normal style), in which a cell without a font of its own is drawn; the component's `--xs-font` without it. */
+    font?: {
+        name: string;
+        size: number;
+    };
+    /** The sheet's saved zoom in percent (xlsx `zoomScale`), with which the sheet opens; 100 without it. */
+    zoom?: number;
 }
 /** A sheet's groups as Excel draws them in the bars next to the row numbers and above the column letters. */
 export interface SheetOutline {

package/dist/contract/view.d.ts

@@ -1,12 +1,14 @@
-import type { CellStyle } from 'xlcalc/contract';
+import type { CellStyle, CellValue, IconSetName } from 'xlcalc/contract';
+import type { ClearRulesFrom, ColorScalePreset, DataBarColor, QuickRule } from './conditional.js';
 import type { SheetMessages } from './messages.js';
 import type { EditOutcome, FormatPatch, OutlineChange, SheetOp, SheetSource, SheetWindow } from './source.js';
+import type { ClearKind } from './workbook.js';
 /** Properties of `SheetView`. */
 export interface SheetViewProps {
     source: SheetSource;
     /** Interface texts; a partial set overrides the English defaults. */
     messages?: Partial<SheetMessages>;
-    /** Key in the browser's storage for the frozen panes display choice and column widths; without it they last as long as the component. */
+    /** Key in the browser's storage for the frozen panes display choice, Show Formulas and column widths; without it they last as long as the component. */
     storageKey?: string;
     /** A location to show: `Sheet!B12:D15`, `B7`, `Sheet`; each new object is a new jump. */
     focus?: {
@@ -29,6 +31,20 @@ export interface SheetViewProps {
     openRows?: boolean;
     /** The host opens links itself through `openLink`: for a host whose listener the component cannot see, such as a custom element's. */
     hostLinks?: boolean;
+    /**
+     * Excel's zoom by sheet name, in percent (10 to 400), as the host kept it from the `zoom` event; a sheet without one opens
+     * at the workbook's saved zoom (`SheetInfo.zoom`), otherwise 100%. A new object applies its changed entries, to the active sheet at once.
+     */
+    zoom?: Record<string, number>;
+    /** Excel's Watch Window list, as the host kept it from the `watches` event; a new array replaces the list. */
+    watches?: SheetWatch[];
+    /** The author's name for a new note, which Excel writes in bold on its first line (Excel takes the user name from its Options); without it a new note has no author. */
+    noteAuthor?: string;
+}
+/** A cell in Excel's Watch Window: its sheet and address (`B12`). */
+export interface SheetWatch {
+    sheet: string;
+    cell: string;
 }
 /** Why the workbook cannot be displayed: the source's error and its text. */
 export interface SheetFailure {
@@ -45,10 +61,28 @@ export interface SheetViewState {
     style?: CellStyle;
     /** The active cell's number format code, from a source whose windows include them; absent for General. */
     numberFormat?: string;
+    /** The active cell's value from the loaded window (absent for an empty cell), for a toolbar's Increase and Decrease Decimal. */
+    cellValue?: CellValue;
+    /** The width of the active cell's column as the workbook stores it (xlcalc's `ColumnInput.width`), absent for the default: Increase Decimal on General depends on it. */
+    columnWidth?: number;
     /** The merged range containing the active cell (`A1:B2`), from the loaded windows: Excel's Merge & Center shows as pressed on it. */
     merged?: string;
     /** The merge commands are available (`SheetViewApi.merge`): the source has `structure`, the sheet is editable, and no display filter is on. */
     canMerge?: true;
+    /** Excel's Show Formulas is on for the displayed sheet (Ctrl+` or `SheetViewApi.showFormulas`): a ribbon shows its button pressed. */
+    showFormulas?: true;
+    /** The sheet's zoom in percent; absent at 100%. */
+    zoom?: number;
+    /** The workbook's default font (`SheetInfo.font`), which a cell without a font of its own displays: a toolbar's Font and Font Size boxes show it for such a cell. */
+    font?: {
+        name: string;
+        size: number;
+    };
+}
+/** The `zoom` event: the user changed a sheet's zoom (Ctrl+wheel, a pinch, the status bar, the Zoom dialog), in percent. */
+export interface SheetZoomEvent {
+    sheet: string;
+    zoom: number;
 }
 /** A hyperlink the component does not open itself, with the cell it belongs to. */
 export type SheetLinkEvent = NonNullable<SheetWindow['links']>[string] & {
@@ -90,6 +124,87 @@ export interface SheetViewApi {
      * in the warning.
      */
     merge(command: MergeCommand): Promise<EditOutcome | null>;
+    /** Opens Excel's Go To dialog (F5, Ctrl+G) with the locations its jumps have left; false while no sheet is displayed. */
+    goTo(): boolean;
+    /**
+     * Opens Excel's Symbol dialog (Insert > Symbol): Insert puts the character at the caret of an open edit, otherwise starts
+     * editing the active cell with it, as typing does; false on a read-only sheet or without an active cell.
+     */
+    insertSymbol(): boolean;
+    /**
+     * Excel's Fill Down (Ctrl+D): the selection's top row copied over its other rows through the source's `structure`
+     * (`copyRange`, relative references shifted), or the row above it into a selection one row tall, as a single undo step.
+     * null when nothing was sent: no `structure`, a read-only sheet, a display filter, row 1 alone, or a locked cell.
+     */
+    fillDown(): Promise<EditOutcome | null>;
+    /** Excel's Fill Right (Ctrl+R): `fillDown` along the columns, from the selection's left column or the column to its left. */
+    fillRight(): Promise<EditOutcome | null>;
+    /** Excel's Show Formulas (Ctrl+`) on the displayed sheet, toggled without `on`: a view setting kept as the frozen panes choice is, the workbook unchanged; whether it is on afterwards. */
+    showFormulas(on?: boolean): boolean;
+    /** Excel's Define Name: the New Name dialog for the selection; false when names cannot be defined (no `names` or `setNames`, a read-only sheet) or a cell is being edited. */
+    defineName(): boolean;
+    /** Excel's Name Manager (Ctrl+F3); false when the source has no `names` or a cell is being edited. Without `setNames` or on a read-only sheet it only lists the names. */
+    nameManager(): boolean;
+    /**
+     * Excel's zoom of the active sheet: a percentage (rounded and kept within 10 to 400), or `selection` for Zoom to Selection,
+     * which fits the selection into the viewport and scrolls it to the top-left corner. Returns the zoom set; it is not
+     * reported by the `zoom` event, which reports the user's changes.
+     */
+    setZoom(zoom: number | 'selection'): number;
+    /** Opens Excel's Watch Window over the sheet (`true`, the default), or closes it (`false`); returns whether it is open. */
+    watchWindow(open?: boolean): boolean;
+    /**
+     * Excel's Trace Dependents through the source's `dependents`: arrows from the active cell to the cells whose formulas refer
+     * to it, and with each further call the next level; false when nothing was added (no `dependents`, no further level).
+     */
+    traceDependents(): Promise<boolean>;
+    /** Excel's Remove Arrows: every tracer arrow; false when there were none. */
+    removeArrows(): boolean;
+    /** Excel's Insert Table and Format as Table (Ctrl+T, Ctrl+L): the Create Table dialog for the selection or the data around the active cell; false without the source's `table`, or on a read-only sheet. */
+    insertTable(): Promise<boolean>;
+    /** Excel's Convert to Range on the table at the active cell, after Excel's question; null when nothing was sent (no table there, no `table`, No). */
+    convertToRange(): Promise<EditOutcome | null>;
+    /** Delete Table: the table at the active cell with its cells; null when nothing was sent. */
+    deleteTable(): Promise<EditOutcome | null>;
+    /** Excel's Spelling (F7) through the source's `spelling`: the dialog from the active cell, within a selection of several cells; false without `spelling`. */
+    checkSpelling(): boolean;
+    /**
+     * Excel's AutoSum (Alt+=) through the source's `autoSum`: the active cell's edit opens with `=SUM(range)`, the range
+     * selected, so Enter enters it and typing or the arrows replace it; false without `autoSum`, on a read-only sheet,
+     * while a cell is being edited or when the source guesses nothing.
+     */
+    autoSum(): Promise<boolean>;
+    /**
+     * Excel's Home > Clear > Clear Formats (`formats`) or Clear All (`all`) over the selection through the source's `clear`, as a
+     * single undo step (under a display filter, over its visible rows), after which the windows over it are read again. null when
+     * nothing was sent: no `clear`, a read-only sheet, or a locked cell in the selection.
+     */
+    clear(what: ClearKind): Promise<EditOutcome | null>;
+    /**
+     * Excel's Insert Link (Ctrl+K) over the selection: opens its dialog, as Edit Hyperlink when the active cell has a link; OK
+     * writes the link through the source's `link`. false when links cannot be edited: no `link`, a read-only sheet, a locked cell.
+     */
+    insertLink(): boolean;
+    /**
+     * Opens Excel's Data Validation dialog (Data > Data Validation) for the selection over the source's `rules` and `setRules`,
+     * after Excel's question when the selection holds rules of more than one kind or cells without the rule; false when the
+     * sheet is read-only or the source lacks either method.
+     */
+    dataValidation(): boolean;
+    /** Opens a quick rule's dialog (Highlight Cells Rules, Top/Bottom Rules) for the selection; OK adds the rule first in priority. */
+    quickRule(kind: QuickRule): boolean;
+    /** Adds Excel's data bar of that color over the selection, with a gradient fill (the default) or a solid one. */
+    dataBars(color: DataBarColor, fill?: 'gradient' | 'solid'): Promise<EditOutcome | null>;
+    /** Adds the color scale of Excel's gallery over the selection. */
+    colorScale(preset: ColorScalePreset): Promise<EditOutcome | null>;
+    /** Adds the icon set over the selection, with Excel's default thresholds: equal shares in percent. */
+    iconSet(icons: IconSetName): Promise<EditOutcome | null>;
+    /** Excel's Clear Rules from Selected Cells (a rule keeps the rest of its cells) or from Entire Sheet; null when there is nothing to clear. */
+    clearRules(from: ClearRulesFrom): Promise<EditOutcome | null>;
+    /** Opens Excel's New Formatting Rule dialog for the selection. */
+    newRule(): boolean;
+    /** Opens Excel's Conditional Formatting Rules Manager. */
+    manageRules(): boolean;
 }
 /** A patch for `SheetView.format`: applied to its own range, or to the selection without one. */
 export type SheetFormatPatch = Omit<FormatPatch, 'range'> & {

package/dist/contract/workbook.d.ts

@@ -0,0 +1,73 @@
+/**
+ * What a workbook holds beside its cells' values, as `SheetSource` reads and writes it for Excel's dialogs: hyperlinks,
+ * notes, defined names, conditional formatting and data validation rules, tables, formula dependents and spelling.
+ * Formulas in these types are written as the source displays formulas, in its locale and without `=`.
+ */
+import type { ConditionalFormat, DataValidation, StructureOp } from 'xlcalc/contract';
+/** What `SheetSource.clear` clears: Excel's Clear Formats (styles, number formats and the conditional formats over the cells) or Clear All (also the contents, hyperlinks, notes and data validation rules). */
+export type ClearKind = 'formats' | 'all';
+/** A hyperlink as Excel's Insert Link writes it: an address outside the workbook (`href`), a place in it (`location`: `'Sheet 2'!B12`, a defined name), or both, and its ScreenTip. */
+export interface SheetLink {
+    href?: string;
+    location?: string;
+    tooltip?: string;
+}
+/** A cell's note (Excel's New Note), with its author's name as Excel shows it above the text. */
+export interface SheetNote {
+    author?: string;
+    text: string;
+}
+/** A defined name as Excel's Name Manager lists it: what it refers to (a formula, in the source's locale, without `=`) and the sheet it is visible on, the workbook without `scope`. */
+export interface SheetName {
+    name: string;
+    ref: string;
+    scope?: string;
+}
+/** A cell whose formula refers to the range `dependents` was asked about, for Excel's Trace Dependents arrows. */
+export interface SheetDependent {
+    sheet: string;
+    cell: string;
+}
+/** The direct dependents of a range: at most as many as the source returns in one response, `more` when it left some out. */
+export interface SheetDependents {
+    cells: SheetDependent[];
+    more: boolean;
+}
+/** A sheet's rules as Excel's Conditional Formatting Rules Manager and Data Validation edit them; their formulas in the source's locale. */
+export interface SheetRules {
+    /** In priority order, highest first. */
+    conditionalFormats: ConditionalFormat[];
+    validations: DataValidation[];
+}
+/** Excel's table commands: Format as Table and Insert Table (`addTable`), Rename, Delete Table and Convert to Range. */
+export type TableOp = Extract<StructureOp, {
+    op: 'addTable' | 'renameTable' | 'deleteTable' | 'convertTable';
+}>;
+/**
+ * Where Excel's Spelling looks next: within `range` or the entire sheet, from the active cell (`after`, from position `from` of its
+ * text, after Ignore Once on a word of it) on, by rows, skipping the words of Ignore All. As Excel's defaults, words in uppercase and
+ * words with digits are not checked.
+ */
+export interface SpellingRequest {
+    sheet: string;
+    range?: string;
+    after?: string;
+    from?: number;
+    ignore?: string[];
+}
+/** A misspelt word in a cell's text constant (formulas are not checked): its position in the cell's text and the checker's suggestions, best first. */
+export interface SpellingHit {
+    cell: string;
+    word: string;
+    at: number;
+    suggestions: string[];
+}
+/** A word checker the host supplies (a dictionary such as hunspell's, and the user's own words): `memorySource` and `@xlcalc/vue/local` check spelling with it. */
+export interface SpellChecker {
+    /** Whether the word is spelt correctly. */
+    check(word: string): boolean;
+    /** Corrections for a misspelt word, best first. */
+    suggest(word: string): string[];
+    /** Excel's Add to Dictionary: the word is kept as the user's own. */
+    add?(word: string): void;
+}

package/dist/contract.d.ts

@@ -1,9 +1,11 @@
 /**
  * The package's contract: every public type, in modules by area, with no code. `source` is the sheet source contract a
- * host implements, `view` the sheet's props, state, events and methods, `memory` memorySource's types, `messages` the
- * interface texts' keys. The `@xlcalc/vue/local` entry's types are in src/local/types.ts.
+ * host implements, `workbook` what it reads and writes beside cell values (links, notes, names, rules, tables), `view` the sheet's props, state, events and methods, `memory` memorySource's types, `messages` the
+ * interface texts' keys, `conditional` the commands of Excel's Conditional Formatting menu. The `@xlcalc/vue/local` entry's types are in src/local/types.ts.
  */
 export type * from './contract/source.js';
+export type * from './contract/workbook.js';
 export type * from './contract/view.js';
 export type * from './contract/memory.js';
 export type * from './contract/messages.js';
+export type * from './contract/conditional.js';

package/dist/core/autocomplete.d.ts

@@ -4,6 +4,11 @@ import type { SheetSource } from '../contract/source.js';
 import type { EditorState } from './editing.js';
 /** Items the list displays at once; Page Up and Page Down move by them. */
 export declare const FUNCTION_ROWS = 8;
+/** An item of the list: a function, or a defined name, which Excel lists with its own icon and inserts without a parenthesis. */
+export interface CompletionItem {
+    text: string;
+    kind: 'function' | 'name';
+}
 export interface AutocompleteDeps {
     source: () => SheetSource;
     editor: Ref<EditorState | null>;
@@ -13,10 +18,13 @@ export interface AutocompleteDeps {
     show: () => void;
     /** How the workbook's formula text is parsed (its list separator); null while its locale loads. */
     scan: () => ScanOptions | null;
+    /** The defined names visible on the sheet in alphabetical order, and that order, in which they join the functions; none without them. */
+    names?: () => readonly string[];
+    nameOrder?: (a: string, b: string) => number;
 }
 /** The list's state over the editor's draft: what it displays, the highlighted item, the keys it handles, the name it inserts. */
 export declare function useAutocomplete(deps: AutocompleteDeps): {
-    items: import("vue").ShallowRef<readonly string[], readonly string[]>;
+    items: import("vue").ShallowRef<readonly CompletionItem[], readonly CompletionItem[]>;
     index: Ref<number, number>;
     open: import("vue").ComputedRef<boolean>;
     update: (text: string, caret: number | null) => void;

package/dist/core/autosum.d.ts

@@ -0,0 +1,11 @@
+import type { Editing } from './editing.js';
+import type { SheetState } from './state.js';
+export interface AutoSumDeps {
+    /** Whether a cell is being edited: AutoSum starts a new edit only from the grid. */
+    editing: () => boolean;
+}
+export declare function useAutoSum(s: SheetState, ed: Editing, deps: AutoSumDeps): {
+    run: () => Promise<boolean>;
+    key: (e: KeyboardEvent) => boolean;
+};
+export type AutoSum = ReturnType<typeof useAutoSum>;

package/dist/core/cell-style.d.ts

@@ -21,6 +21,11 @@ export interface CssLine {
 export declare function borderCss(line: BorderLine | undefined): CssLine | undefined;
 /** Puts a line on one side of a cell's CSS. */
 export declare function setSide(css: Record<string, string>, side: 'Top' | 'Right' | 'Bottom' | 'Left', line: CssLine): void;
+/** The workbook's default font (`SheetInfo.font`) as CSS for the grid, which the cells without a font of their own inherit. */
+export declare const defaultFontCss: (font: {
+    name: string;
+    size: number;
+}) => Record<string, string>;
 /** A cell's font, color and fill; `section` is the color from the number format's section, which takes precedence over the font's. */
 export declare function fontCss(style: CellStyle | undefined, section: string | undefined): Record<string, string>;
 /** Underline and strikethrough, for the element that holds the text: decorations do not reach an absolutely positioned overflow run. A link is underlined anyway. */