@xlcalc/vue 0.21.2 → 0.23.1

package/dist/core/names.d.ts

@@ -0,0 +1,33 @@
+import type { CellRect } from 'xlcalc/contract';
+import type { CellUpdate, EditOutcome } from '../contract/source.js';
+import type { SheetName } from '../contract/workbook.js';
+import type { SheetState } from './state.js';
+/** The range a name refers to: a plain reference to a range of one sheet. */
+export interface NameRange {
+    sheet: string;
+    rect: CellRect;
+}
+export interface NamesDeps {
+    /** Reads the sheets and windows again, and the number of reloads started, to tell whether the source sent `reload` during a call. */
+    reload: () => Promise<void>;
+    reloads: () => number;
+    /** Cells whose values a change of names changed. */
+    apply: (changes: CellUpdate[]) => void;
+}
+/** A name's identity in the list: its scope and its name, case-insensitively, as Excel tells names apart. */
+export declare const nameKey: (n: SheetName) => string;
+export declare function useNames(s: SheetState, deps: NamesDeps): {
+    list: import("vue").ShallowRef<readonly SheetName[], readonly SheetName[]>;
+    available: import("vue").ComputedRef<boolean>;
+    editable: import("vue").ComputedRef<boolean>;
+    compare: (a: string, b: string) => number;
+    read: () => void;
+    rangeOf: (n: SheetName) => NameRange | null;
+    visibleOn: (sheet: string) => SheetName[];
+    find: (text: string, sheet: string) => SheetName | undefined;
+    formulaNames: import("vue").ComputedRef<string[]>;
+    boxNames: import("vue").ComputedRef<SheetName[]>;
+    nameOf: (rect: CellRect | null) => string | null;
+    save: (next: SheetName[]) => Promise<EditOutcome | null>;
+};
+export type Names = ReturnType<typeof useNames>;

package/dist/core/navigation.d.ts

@@ -1,5 +1,7 @@
 import type { CellRect, GridReference } from 'xlcalc/contract';
+import type { SheetName } from '../contract/workbook.js';
 import type { Formula } from './formula.js';
+import type { Names } from './names.js';
 import type { Selection } from './selection.js';
 import type { SheetState } from './state.js';
 /** A location to return to: sheet, selection and scroll. */
@@ -13,6 +15,8 @@ export interface Place {
 export interface NavigationDeps {
     pickSheet: (index: number) => Promise<void>;
     notify: (text: string) => void;
+    /** The workbook's defined names, which the Name Box goes to, lists, shows and defines. */
+    names: Names;
 }
 export declare function useNavigation(s: SheetState, sel: Selection, f: Formula, deps: NavigationDeps): {
     history: import("vue").Ref<{
@@ -63,6 +67,8 @@ export declare function useNavigation(s: SheetState, sel: Selection, f: Formula,
     goBack: () => Promise<void>;
     goPlace: (text: string) => Promise<boolean>;
     goRef: (r: GridReference) => Promise<void>;
+    goName: (name: SheetName) => Promise<boolean>;
+    boxText: import("vue").ComputedRef<string>;
     addressDraft: import("vue").Ref<string, string>;
     addressFocused: import("vue").Ref<boolean, boolean>;
     goAddress: () => Promise<boolean>;

package/dist/core/notes.d.ts

@@ -0,0 +1,44 @@
+import type { Extras } from './extras.js';
+import type { MenuItem } from './menu.js';
+import type { SheetState } from './state.js';
+import type { Windows } from './windows.js';
+/** The note being edited: its cell, its author (shown in bold above the text), its text and the text it opened with. */
+export interface NoteDraft {
+    sheet: string;
+    row: number;
+    col: number;
+    author?: string;
+    text: string;
+    initial: string;
+    /** A new note (New Note): saved even unchanged, as Excel keeps a note once it is inserted, unless it has neither author nor text. */
+    fresh: boolean;
+}
+export interface NotesDeps {
+    /** The author's name for a new note: the sheet's `noteAuthor` prop. */
+    author: () => string | undefined;
+}
+export declare function useNotes(s: SheetState, w: Windows, extras: Extras, deps: NotesDeps): {
+    draft: import("vue").Ref<{
+        sheet: string;
+        row: number;
+        col: number;
+        author?: string | undefined;
+        text: string;
+        initial: string;
+        fresh: boolean;
+    } | null, NoteDraft | {
+        sheet: string;
+        row: number;
+        col: number;
+        author?: string | undefined;
+        text: string;
+        initial: string;
+        fresh: boolean;
+    } | null>;
+    available: import("vue").ComputedRef<boolean>;
+    open: () => boolean;
+    save: (refocus?: boolean) => Promise<void>;
+    remove: () => Promise<void>;
+    items: () => MenuItem[];
+};
+export type Notes = ReturnType<typeof useNotes>;

package/dist/core/place.d.ts

@@ -0,0 +1,10 @@
+import type { CellRect } from 'xlcalc/contract';
+/** A location from the Name Box, a hyperlink or `focus`: a range with its sheet (`B12`, `'Sheet 2'!C7:D9`, `B:B`) or a sheet alone; null for anything else (`B12+C1`). */
+export declare function parsePlace(text: string): {
+    sheet?: string;
+    range?: CellRect;
+} | null;
+/** A range as Excel's Define Name writes the selection: absolute (`$B$2:$D$9`, `$B:$B`, `$2:$5`). */
+export declare function absoluteRange(rect: CellRect): string;
+/** A reference to a range of a sheet as a name's formula (without `=`): `'Sheet 2'!$B$2:$D$9`. */
+export declare const rangeRef: (sheet: string, rect: CellRect) => string;

package/dist/core/range-read.d.ts

@@ -0,0 +1,11 @@
+import type { CellRect, CellValue } from 'xlcalc/contract';
+import type { SheetSource } from '../contract/source.js';
+/** A cell as a window gives it: its displayed text, value, formula and edit text. */
+export interface ReadCell {
+    text: string;
+    value: CellValue;
+    formula?: string;
+    editText?: string;
+}
+/** The cells of `r` by address (empty ones without text, value or formula left out); null when a window cannot be read or the workbook is still recalculating. */
+export declare function readRange(source: SheetSource, sheet: string, r: CellRect, signal?: AbortSignal): Promise<Map<string, ReadCell> | null>;

package/dist/core/sheet.d.ts

@@ -1,6 +1,6 @@
 import type { CellStyle } from 'xlcalc/contract';
 import type { SheetInfo, SheetWindow } from '../contract/source.js';
-import type { ListSort, SheetLinkEvent, SheetViewApi, SheetViewProps, SheetViewState } from '../contract/view.js';
+import type { ListSort, SheetLinkEvent, SheetViewApi, SheetViewProps, SheetViewState, SheetWatch, SheetZoomEvent } from '../contract/view.js';
 import { type EditorState } from './editing.js';
 export interface SheetEmit {
     (e: 'state', state: SheetViewState | null): void;
@@ -14,10 +14,14 @@ export interface SheetEmit {
         sheet: string;
         row: number;
     }): void;
+    (e: 'zoom', change: SheetZoomEvent): void;
+    (e: 'watches', list: SheetWatch[]): void;
 }
 export declare function useSheet(props: SheetViewProps, emit: SheetEmit, hostLinks: () => boolean): {
     geo: {
         widthOf: (c: number) => number;
+        baseWidthOf: (c: number) => number;
+        widthScale: () => number;
         heightOf: (d: number) => number;
         offsets: import("vue").ComputedRef<Float64Array<ArrayBufferLike>>;
         setHeights: (rows: Iterable<readonly [number, number | undefined]>) => boolean;
@@ -33,6 +37,8 @@ export declare function useSheet(props: SheetViewProps, emit: SheetEmit, hostLin
     };
     v: {
         showNums: import("vue").ComputedRef<boolean>;
+        line: import("vue").ComputedRef<number>;
+        lineOf: (px: number) => number;
         narrow: import("vue").ComputedRef<boolean>;
         touch: import("vue").ComputedRef<boolean>;
         numW: import("vue").ComputedRef<number>;
@@ -93,6 +99,15 @@ export declare function useSheet(props: SheetViewProps, emit: SheetEmit, hostLin
             x: number;
             y: number;
         };
+        cellAtPoint: (clientX: number, clientY: number, box: {
+            left: number;
+            top: number;
+        }) => {
+            d: number;
+            col: number;
+            x: number;
+            y: number;
+        };
     };
     w: {
         slots: Record<import("./windows.js").SlotKind, import("vue").ShallowRef<import("./windows.js").Slot>>;
@@ -113,6 +128,8 @@ export declare function useSheet(props: SheetViewProps, emit: SheetEmit, hostLin
             style?: CellStyle;
             numberFormat?: string;
         } | null;
+        linkOfRow: (r: number, col: number) => import("./windows.js").CellData["link"];
+        noteOfRow: (r: number, col: number) => import("./windows.js").CellData["note"];
         merges: import("vue").ComputedRef<import("xlcalc").CellRect[]>;
         tables: import("vue").ComputedRef<import("./windows.js").SheetTable[]>;
         notice: import("vue").ComputedRef<string>;
@@ -250,6 +267,8 @@ export declare function useSheet(props: SheetViewProps, emit: SheetEmit, hostLin
         goBack: () => Promise<void>;
         goPlace: (text: string) => Promise<boolean>;
         goRef: (r: import("xlcalc").GridReference) => Promise<void>;
+        goName: (name: import("../index.js").SheetName) => Promise<boolean>;
+        boxText: import("vue").ComputedRef<string>;
         addressDraft: import("vue").Ref<string, string>;
         addressFocused: import("vue").Ref<boolean, boolean>;
         goAddress: () => Promise<boolean>;
@@ -268,12 +287,14 @@ export declare function useSheet(props: SheetViewProps, emit: SheetEmit, hostLin
             place?: "cell" | "bar";
             caret?: number;
             caretEnd?: number;
+            focus?: boolean;
         }) => boolean;
         inputOf: () => HTMLTextAreaElement | null;
         focusEditor: () => void;
         insertFunction: (name: string) => void;
+        insertText: (piece: string) => boolean;
         ac: {
-            items: import("vue").ShallowRef<readonly string[], readonly string[]>;
+            items: import("vue").ShallowRef<readonly import("./autocomplete.js").CompletionItem[], readonly import("./autocomplete.js").CompletionItem[]>;
             index: import("vue").Ref<number, number>;
             open: import("vue").ComputedRef<boolean>;
             update: (text: string, caret: number | null) => void;
@@ -436,6 +457,84 @@ export declare function useSheet(props: SheetViewProps, emit: SheetEmit, hostLin
         close: () => void;
         refresh: () => void;
     };
+    trace: {
+        available: import("vue").ComputedRef<boolean>;
+        drawn: import("vue").ComputedRef<import("./trace.js").DrawnArrow[]>;
+        traceDependents: () => Promise<boolean>;
+        removeArrows: () => boolean;
+    };
+    tables: {
+        available: import("vue").ComputedRef<boolean>;
+        canInsertHeader: import("vue").ComputedRef<boolean>;
+        activeTable: import("vue").ComputedRef<import("./windows.js").SheetTable | null>;
+        dialog: import("vue").Ref<{
+            kind: "create";
+            sheet: string;
+            draft: string;
+            headers: boolean;
+            error: string;
+        } | {
+            kind: "convert";
+            sheet: string;
+            table: string;
+        } | null, import("./tables.js").TableDialog | {
+            kind: "create";
+            sheet: string;
+            draft: string;
+            headers: boolean;
+            error: string;
+        } | {
+            kind: "convert";
+            sheet: string;
+            table: string;
+        } | null>;
+        openCreate: () => Promise<boolean>;
+        create: () => Promise<import("../index.js").EditOutcome | null>;
+        convert: () => Promise<import("../index.js").EditOutcome | null>;
+        remove: () => Promise<import("../index.js").EditOutcome | null>;
+        close: (yes?: boolean) => void;
+        key: (e: KeyboardEvent) => boolean;
+    };
+    spell: {
+        available: import("vue").ComputedRef<boolean>;
+        canChange: import("vue").ComputedRef<boolean>;
+        canLearn: import("vue").ComputedRef<boolean>;
+        shown: import("vue").Ref<{
+            hit: {
+                cell: string;
+                word: string;
+                at: number;
+                suggestions: string[];
+            };
+            at: {
+                row: number;
+                col: number;
+            };
+            text: string;
+            editText?: string | undefined;
+            choice: number;
+        } | null, import("./spell-check.js").SpellingShown | {
+            hit: {
+                cell: string;
+                word: string;
+                at: number;
+                suggestions: string[];
+            };
+            at: {
+                row: number;
+                col: number;
+            };
+            text: string;
+            editText?: string | undefined;
+            choice: number;
+        } | null>;
+        done: import("vue").Ref<boolean, boolean>;
+        busy: import("vue").Ref<boolean, boolean>;
+        check: () => boolean;
+        act: (kind: "ignoreOnce" | "ignoreAll" | "add" | "change" | "changeAll") => Promise<void>;
+        close: () => void;
+        key: (e: KeyboardEvent) => boolean;
+    };
     views: {
         spanOf: (r: number, c: number) => import("./cell-view.js").MergeSpan | null | undefined;
         coveredByMerge: (r: number, c: number) => boolean;
@@ -452,18 +551,98 @@ export declare function useSheet(props: SheetViewProps, emit: SheetEmit, hostLin
         totals: import("vue").ComputedRef<(string | null)[] | null>;
     };
     cmd: {
-        can: (name: "outline" | "freeze" | "structure" | "layout" | "format") => boolean;
+        can: (name: "outline" | "freeze" | "table" | "structure" | "layout" | "format") => boolean;
         canRanges: import("vue").ComputedRef<boolean>;
         format: (patches: import("../index.js").SheetFormatPatch[]) => Promise<import("../index.js").EditOutcome | null>;
         structure: (op: import("../index.js").SheetOp, endsCopy?: boolean) => Promise<import("../index.js").EditOutcome | null>;
         layout: (edit: import("../index.js").LayoutChange) => Promise<import("../index.js").EditOutcome | null>;
         outline: (command: import("../index.js").OutlineChange) => Promise<import("../index.js").EditOutcome | null>;
+        table: (op: import("../index.js").TableOp) => Promise<import("../index.js").EditOutcome | null>;
         freeze: (mode?: import("../index.js").FreezeMode) => Promise<import("../index.js").EditOutcome | null>;
-        fontKey: (e: KeyboardEvent) => boolean;
+        formatKey: (e: KeyboardEvent) => boolean;
         formatOpen: import("vue").Ref<boolean, boolean>;
         openFormat: () => boolean;
         closeFormat: () => void;
     };
+    extras: {
+        method: <K extends "note" | "clear" | "link">(name: K) => NonNullable<import("../index.js").SheetSource[K]> | null;
+        change: (call: () => Promise<import("../index.js").EditOutcome>, sheet: string, ranges: string[]) => Promise<import("../index.js").EditOutcome>;
+        locked: (rect: import("xlcalc").CellRect | null) => boolean;
+        clear: (what: import("../index.js").ClearKind) => Promise<import("../index.js").EditOutcome | null>;
+    };
+    links: {
+        draft: import("vue").Ref<{
+            sheet: string;
+            range: string;
+            cell: string;
+            old: {
+                href?: string | undefined;
+                location?: string | undefined;
+                tooltip?: string | undefined;
+            } | null;
+            tab: import("./links.js").LinkTab;
+            text: string | null;
+            shown: string;
+            textTyped: boolean;
+            address: string;
+            ref: string;
+            place: string;
+            tooltip: string;
+            error: string;
+        } | null, import("./links.js").LinkDraft | {
+            sheet: string;
+            range: string;
+            cell: string;
+            old: {
+                href?: string | undefined;
+                location?: string | undefined;
+                tooltip?: string | undefined;
+            } | null;
+            tab: import("./links.js").LinkTab;
+            text: string | null;
+            shown: string;
+            textTyped: boolean;
+            address: string;
+            ref: string;
+            place: string;
+            tooltip: string;
+            error: string;
+        } | null>;
+        available: import("vue").ComputedRef<boolean>;
+        places: import("vue").ComputedRef<import("./links.js").LinkPlaceGroup[]>;
+        refOn: import("vue").ComputedRef<boolean>;
+        follow: () => void;
+        open: () => boolean;
+        close: () => void;
+        apply: () => Promise<void>;
+        remove: (range?: string) => Promise<void>;
+        openLink: (link: NonNullable<SheetWindow["links"]>[string], row: number, col: number, viaClick?: boolean) => boolean;
+        items: () => import("./menu.js").MenuItem[];
+    };
+    notes: {
+        draft: import("vue").Ref<{
+            sheet: string;
+            row: number;
+            col: number;
+            author?: string | undefined;
+            text: string;
+            initial: string;
+            fresh: boolean;
+        } | null, import("./notes.js").NoteDraft | {
+            sheet: string;
+            row: number;
+            col: number;
+            author?: string | undefined;
+            text: string;
+            initial: string;
+            fresh: boolean;
+        } | null>;
+        available: import("vue").ComputedRef<boolean>;
+        open: () => boolean;
+        save: (refocus?: boolean) => Promise<void>;
+        remove: () => Promise<void>;
+        items: () => import("./menu.js").MenuItem[];
+    };
     api: SheetViewApi;
     clip: {
         mark: import("vue").ShallowRef<import("./clip.js").ClipMark | null, import("./clip.js").ClipMark | null>;
@@ -504,6 +683,14 @@ export declare function useSheet(props: SheetViewProps, emit: SheetEmit, hostLin
         onUp: (e: PointerEvent) => void;
         onCancel: () => void;
         autofill: () => Promise<void>;
+        fillFrom: (direction: "down" | "right") => Promise<import("../index.js").EditOutcome | null>;
+        key: (e: KeyboardEvent) => boolean;
+    };
+    formulaView: {
+        read: () => void;
+        show: (on?: boolean) => boolean;
+        key: (e: KeyboardEvent) => boolean;
+        textOf: (data: import("./windows.js").CellData) => string;
     };
     viewState: import("vue").ComputedRef<SheetViewState | null>;
     validation: {
@@ -523,6 +710,13 @@ export declare function useSheet(props: SheetViewProps, emit: SheetEmit, hostLin
         choose: (i?: number) => boolean;
         onKey: (e: KeyboardEvent) => boolean;
     };
+    rules: {
+        state: import("vue").ShallowRef<import("./validation-dialog.js").ValidationDialogState | null, import("./validation-dialog.js").ValidationDialogState | null>;
+        available: () => boolean;
+        open: () => boolean;
+        close: () => void;
+        apply: (rule: import("../validation-rules.js").RuleSettings | null, applyAll: boolean) => Promise<string | null>;
+    };
     alerts: {
         alert: import("vue").ShallowRef<import("./validation.js").SheetAlert | null, import("./validation.js").SheetAlert | null>;
         ask: (next: import("./validation.js").SheetAlert) => Promise<import("./validation.js").AlertAnswer>;
@@ -625,6 +819,137 @@ export declare function useSheet(props: SheetViewProps, emit: SheetEmit, hostLin
             context: (e: MouseEvent) => boolean;
         };
     };
+    goto: {
+        open: import("vue").Ref<boolean, boolean>;
+        places: import("vue").Ref<string[], string[]>;
+        items: import("vue").ComputedRef<string[]>;
+        jump: (text: string) => Promise<boolean>;
+        openGoTo: () => boolean;
+        go: (text: string) => Promise<boolean>;
+        close: () => void;
+        key: (e: KeyboardEvent) => boolean;
+    };
+    symbolOpen: import("vue").Ref<boolean, boolean>;
+    closeSymbol: () => void;
+    names: {
+        list: import("vue").ShallowRef<readonly import("../index.js").SheetName[], readonly import("../index.js").SheetName[]>;
+        available: import("vue").ComputedRef<boolean>;
+        editable: import("vue").ComputedRef<boolean>;
+        compare: (a: string, b: string) => number;
+        read: () => void;
+        rangeOf: (n: import("../index.js").SheetName) => import("./names.js").NameRange | null;
+        visibleOn: (sheet: string) => import("../index.js").SheetName[];
+        find: (text: string, sheet: string) => import("../index.js").SheetName | undefined;
+        formulaNames: import("vue").ComputedRef<string[]>;
+        boxNames: import("vue").ComputedRef<import("../index.js").SheetName[]>;
+        nameOf: (rect: import("xlcalc").CellRect | null) => string | null;
+        save: (next: import("../index.js").SheetName[]) => Promise<import("../index.js").EditOutcome | null>;
+    };
+    nameDialogs: {
+        draft: import("vue").Ref<{
+            editing: string | null;
+            name: string;
+            scope: string;
+            ref: string;
+        } | null, import("./name-dialogs.js").NameDraft | {
+            editing: string | null;
+            name: string;
+            scope: string;
+            ref: string;
+        } | null>;
+        manager: import("vue").Ref<{
+            selected: string | null;
+            ref: string | null;
+        } | null, import("./name-dialogs.js").NameManagerState | {
+            selected: string | null;
+            ref: string | null;
+        } | null>;
+        ask: import("vue").ShallowRef<import("./name-dialogs.js").NameAsk | null, import("./name-dialogs.js").NameAsk | null>;
+        answer: (yes: boolean) => void;
+        busy: import("vue").Ref<boolean, boolean>;
+        rows: import("vue").ComputedRef<import("../index.js").SheetName[]>;
+        selected: import("vue").ComputedRef<import("../index.js").SheetName | null>;
+        refText: import("vue").ComputedRef<string>;
+        refChanged: import("vue").ComputedRef<boolean>;
+        define: () => boolean;
+        openManager: () => boolean;
+        select: (n: import("../index.js").SheetName) => void;
+        edit: () => void;
+        submit: () => Promise<void>;
+        closeDraft: () => void;
+        remove: () => Promise<void>;
+        editRef: (text: string) => void;
+        commitRef: () => Promise<boolean>;
+        cancelRef: () => void;
+        closeManager: () => Promise<void>;
+    };
+    zoomer: {
+        percent: import("vue").ComputedRef<number>;
+        apply: (pct: number, focus?: {
+            x: number;
+            y: number;
+        }) => number;
+        choose: (pct: number) => number;
+        fitSelection: (user?: boolean) => number;
+        enter: () => void;
+        onWheel: (e: WheelEvent) => void;
+        onTouchStart: (e: TouchEvent) => void;
+        onTouchMove: (e: TouchEvent) => void;
+        onTouchEnd: (e: TouchEvent) => void;
+        onGesture: (e: Event & {
+            scale?: number;
+            clientX?: number;
+            clientY?: number;
+        }) => void;
+        dialogOpen: import("vue").Ref<boolean, boolean>;
+    };
+    watches: {
+        list: import("vue").ShallowRef<SheetWatch[], SheetWatch[]>;
+        open: import("vue").Ref<boolean, boolean>;
+        chosen: import("vue").ShallowRef<Set<number>, Set<number>>;
+        valueOf: (w: SheetWatch) => import("./watch.js").WatchShown | null;
+        add: () => void;
+        remove: () => void;
+        choose: (i: number, how?: {
+            add?: boolean;
+            range?: boolean;
+        }) => void;
+        go: (i: number) => Promise<void>;
+        setOpen: (on?: boolean) => boolean;
+        canAdd: import("vue").ComputedRef<boolean>;
+    };
+    cf: {
+        api: {
+            quickRule: (kind: import("../index.js").QuickRule) => boolean;
+            dataBars: (color: import("../index.js").DataBarColor, fill?: "gradient" | "solid") => Promise<import("../index.js").EditOutcome | null>;
+            colorScale: (preset: import("../index.js").ColorScalePreset) => Promise<import("../index.js").EditOutcome | null>;
+            iconSet: (icons: import("xlcalc").IconSetName) => Promise<import("../index.js").EditOutcome | null>;
+            clearRules: (from: import("../index.js").ClearRulesFrom) => Promise<import("../index.js").EditOutcome | null>;
+            newRule: () => boolean;
+            manageRules: () => boolean;
+        };
+        quick: import("vue").ShallowRef<(import("./cf-commands.js").RuleTarget & {
+            kind: import("../index.js").QuickRule;
+        }) | null, (import("./cf-commands.js").RuleTarget & {
+            kind: import("../index.js").QuickRule;
+        }) | null>;
+        rule: import("vue").ShallowRef<import("./cf-commands.js").RuleDialog | null, import("./cf-commands.js").RuleDialog | null>;
+        style: import("vue").ShallowRef<import("./cf-commands.js").StyleDialog | null, import("./cf-commands.js").StyleDialog | null>;
+        manager: import("vue").ShallowRef<import("./cf-commands.js").ManagerState | null, import("./cf-commands.js").ManagerState | null>;
+        locale: () => import("xlcalc").Locale | undefined;
+        stored: (t: import("./cf-commands.js").RuleTarget, ranges?: string[]) => (formula: string) => string;
+        shown: (t: import("./cf-commands.js").RuleTarget, ranges: string[]) => (formula: string) => string;
+        activeAddress: (t: import("./cf-commands.js").RuleTarget) => string;
+        quickOk: (q: import("./cf-presets.js").QuickInput) => void;
+        quickClose: () => void;
+        openRule: (d: import("./cf-commands.js").RuleDialog) => void;
+        ruleClose: () => void;
+        openStyle: (d: import("./cf-commands.js").StyleDialog) => import("./cf-commands.js").StyleDialog;
+        styleClose: (made: import("xlcalc").ConditionalStyle | null) => void;
+        managerWrite: (next: import("xlcalc").ConditionalFormat[], close: boolean) => Promise<void>;
+        managerClose: () => void;
+        closeAll: () => void;
+    };
     editor: import("vue").Ref<{
         sheet: string;
         row: number;
@@ -689,6 +1014,11 @@ export declare function useSheet(props: SheetViewProps, emit: SheetEmit, hostLin
     active: import("vue").Ref<number, number>;
     sheet: import("vue").ComputedRef<SheetInfo | null>;
     sheetName: import("vue").ComputedRef<string>;
+    defaultFont: import("vue").ComputedRef<{
+        name: string;
+        size: number;
+    } | null>;
+    defaultFontStyle: import("vue").ComputedRef<Record<string, string> | null>;
     grown: import("vue").Ref<{
         rows: number;
         cols: number;
@@ -733,6 +1063,7 @@ export declare function useSheet(props: SheetViewProps, emit: SheetEmit, hostLin
     failureOf: (error: unknown) => import("../index.js").SheetFailure;
     loading: import("vue").Ref<boolean, boolean>;
     scroller: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+    zoom: import("vue").Ref<number, number>;
     scrollTop: import("vue").Ref<number, number>;
     scrollLeft: import("vue").Ref<number, number>;
     viewH: import("vue").Ref<number, number>;
@@ -765,6 +1096,8 @@ export declare function useSheet(props: SheetViewProps, emit: SheetEmit, hostLin
     hooks: {
         unfilter: (_row: number) => void;
         changing: () => void;
+        stepped: () => void;
+        changed: () => void;
     };
     focusGrid: () => void;
     scrollGridTo: (top: number, left: number) => void;

package/dist/core/spell-check.d.ts

@@ -0,0 +1,54 @@
+import type { CellPosition } from 'xlcalc/contract';
+import type { SpellingHit } from '../contract/workbook.js';
+import type { Editing } from './editing.js';
+import type { Selection } from './selection.js';
+import { type SheetState } from './state.js';
+/** The word shown in the dialog: the hit, its cell's text (and edit text) and the suggestion chosen for Change. */
+export interface SpellingShown {
+    hit: SpellingHit;
+    at: CellPosition;
+    text: string;
+    editText?: string;
+    choice: number;
+}
+export declare function useSpellCheck(s: SheetState, sel: Selection, ed: Editing, notify: (text: string) => void): {
+    available: import("vue").ComputedRef<boolean>;
+    canChange: import("vue").ComputedRef<boolean>;
+    canLearn: import("vue").ComputedRef<boolean>;
+    shown: import("vue").Ref<{
+        hit: {
+            cell: string;
+            word: string;
+            at: number;
+            suggestions: string[];
+        };
+        at: {
+            row: number;
+            col: number;
+        };
+        text: string;
+        editText?: string | undefined;
+        choice: number;
+    } | null, SpellingShown | {
+        hit: {
+            cell: string;
+            word: string;
+            at: number;
+            suggestions: string[];
+        };
+        at: {
+            row: number;
+            col: number;
+        };
+        text: string;
+        editText?: string | undefined;
+        choice: number;
+    } | null>;
+    done: import("vue").Ref<boolean, boolean>;
+    busy: import("vue").Ref<boolean, boolean>;
+    check: () => boolean;
+    act: (kind: "ignoreOnce" | "ignoreAll" | "add" | "change" | "changeAll") => Promise<void>;
+    close: () => void;
+    key: (e: KeyboardEvent) => boolean;
+};
+export type SpellCheck = ReturnType<typeof useSpellCheck>;