@xlcalc/vue 0.0.0-stage → 0.21.2

package/dist/core/sheet.d.ts

@@ -0,0 +1,774 @@
+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 EditorState } from './editing.js';
+export interface SheetEmit {
+    (e: 'state', state: SheetViewState | null): void;
+    (e: 'openLink', link: SheetLinkEvent): void;
+    (e: 'sort', sort: ListSort): void;
+    (e: 'cellDrill', cell: {
+        sheet: string;
+        cell: string;
+    }): void;
+    (e: 'rowOpen', row: {
+        sheet: string;
+        row: number;
+    }): void;
+}
+export declare function useSheet(props: SheetViewProps, emit: SheetEmit, hostLinks: () => boolean): {
+    geo: {
+        widthOf: (c: number) => number;
+        heightOf: (d: number) => number;
+        offsets: import("vue").ComputedRef<Float64Array<ArrayBufferLike>>;
+        setHeights: (rows: Iterable<readonly [number, number | undefined]>) => boolean;
+        rowOffsets: import("vue").ComputedRef<Float64Array<ArrayBufferLike>>;
+        colAt: (x: number) => number;
+        rowAt: (y: number) => number;
+        nextRow: (d: number, dir: 1 | -1) => number;
+        nextCol: (c: number, dir: 1 | -1) => number;
+        hasRow: (d: number, dir: 1 | -1) => boolean;
+        hasCol: (c: number, dir: 1 | -1) => boolean;
+        spanHeight: (d: number, rs?: number) => number;
+        spanWidth: (c: number, cs?: number) => number;
+    };
+    v: {
+        showNums: import("vue").ComputedRef<boolean>;
+        narrow: import("vue").ComputedRef<boolean>;
+        touch: import("vue").ComputedRef<boolean>;
+        numW: import("vue").ComputedRef<number>;
+        outlineSlots: import("vue").ComputedRef<{
+            rows: number;
+            cols: number;
+        }>;
+        slotPx: import("vue").ComputedRef<16 | 22>;
+        barW: import("vue").ComputedRef<number>;
+        barH: import("vue").ComputedRef<number>;
+        headH: import("vue").ComputedRef<number>;
+        footH: import("vue").ComputedRef<0 | 24>;
+        leadW: import("vue").ComputedRef<number>;
+        bookFreeze: import("vue").ComputedRef<boolean>;
+        freezeOn: import("vue").ComputedRef<boolean>;
+        readFreeze: () => boolean | null;
+        toggleFreeze: () => void;
+        showFreeze: (sheet: string, on: boolean) => void;
+        middlePanes: () => {
+            rows: number;
+            cols: number;
+        };
+        frozenRows: import("vue").ComputedRef<number>;
+        frozenCols: import("vue").ComputedRef<number>;
+        frozenH: import("vue").ComputedRef<number>;
+        frozenW: import("vue").ComputedRef<number>;
+        frozenRowList: import("vue").ComputedRef<number[]>;
+        frozenColList: import("vue").ComputedRef<number[]>;
+        stickyTop: (d: number) => string;
+        stickyLeft: (c: number) => string;
+        firstRow: import("vue").ComputedRef<number>;
+        lastRow: import("vue").ComputedRef<number>;
+        firstCol: import("vue").ComputedRef<number>;
+        lastCol: import("vue").ComputedRef<number>;
+        shownRows: import("vue").ComputedRef<number[]>;
+        shownCols: import("vue").ComputedRef<number[]>;
+        topPad: import("vue").ComputedRef<number>;
+        bottomPad: import("vue").ComputedRef<number>;
+        leftPad: import("vue").ComputedRef<number>;
+        rightPad: import("vue").ComputedRef<number>;
+        tableWidth: import("vue").ComputedRef<number>;
+        boxOf: (d1: number, c1: number, d2: number, c2: number) => {
+            top: number;
+            left: number;
+            width: number;
+            height: number;
+            frozen: boolean;
+        };
+        viewBox: import("vue").ComputedRef<{
+            top: number;
+            left: number;
+            width: number;
+            height: number;
+        }>;
+        cellAt: (px: number, py: number) => {
+            d: number;
+            col: number;
+            x: number;
+            y: number;
+        };
+    };
+    w: {
+        slots: Record<import("./windows.js").SlotKind, import("vue").ShallowRef<import("./windows.js").Slot>>;
+        viewKey: () => string;
+        revision: import("vue").ShallowRef<number, number>;
+        slotAt: (d: number, col: number) => import("./windows.js").Slot | null;
+        textAt: (d: number, col: number) => string;
+        styleAt: (d: number, col: number, addr: string) => CellStyle | undefined;
+        cellData: (d: number, col: number, addr: string) => import("./windows.js").CellData;
+        emptyAt: (d: number, col: number) => boolean;
+        textOfRow: (r: number, col: number) => string;
+        drillOfRow: (r: number, col: number) => boolean;
+        valueOfRow: (r: number, col: number) => import("xlcalc").CellValue | undefined;
+        formulaOfRow: (r: number, col: number) => string | undefined;
+        emptyAtRow: (r: number, col: number) => boolean;
+        editTextOfRow: (r: number, col: number) => string | undefined;
+        lookOfRow: (r: number, col: number) => {
+            style?: CellStyle;
+            numberFormat?: string;
+        } | null;
+        merges: import("vue").ComputedRef<import("xlcalc").CellRect[]>;
+        tables: import("vue").ComputedRef<import("./windows.js").SheetTable[]>;
+        notice: import("vue").ComputedRef<string>;
+        wait: import("vue").Ref<{
+            since: number;
+            elapsedMs: number;
+        } | null, {
+            since: number;
+            elapsedMs: number;
+        } | {
+            since: number;
+            elapsedMs: number;
+        } | null>;
+        waitSeconds: import("vue").Ref<number, number>;
+        ensure: () => void;
+        reset: () => void;
+        resetSizes: () => void;
+        applyChanges: (changes: import("../index.js").CellUpdate[]) => void;
+        repaint: (ranges: {
+            sheet: string;
+            range: string;
+        }[]) => void;
+    };
+    sel: {
+        fullRect: import("vue").ComputedRef<import("xlcalc").CellRect | null>;
+        selRect: import("vue").ComputedRef<import("xlcalc").CellRect | null>;
+        wholeColumns: import("vue").ComputedRef<{
+            first: number;
+            last: number;
+        } | null>;
+        wholeRows: import("vue").ComputedRef<{
+            first: number;
+            last: number;
+        } | null>;
+        linesOf: (whole: {
+            first: number;
+            last: number;
+        } | null, line: number) => {
+            first: number;
+            last: number;
+        };
+        multi: import("vue").ComputedRef<boolean>;
+        selectionRef: import("vue").ComputedRef<string>;
+        gridRef: import("vue").ComputedRef<string>;
+        isActive: (row: number, col: number) => boolean;
+        pickCell: (row: number, col: number, extend?: boolean) => void;
+        pickColumn: (col: number, extend?: boolean) => void;
+        pickRow: (row: number, extend?: boolean) => void;
+        selectAll: () => void;
+        stretchTo: (r: import("xlcalc").CellRect) => void;
+        selectRect: (r: import("xlcalc").CellRect) => void;
+        onCellDown: (e: PointerEvent, row: number, col: number) => void;
+        onCellTap: (e: MouseEvent, row: number, col: number) => boolean;
+        onGridMove: (e: PointerEvent) => void;
+        onGridUp: () => void;
+        revealCell: (row: number, col: number) => void;
+        measure: () => void;
+        navKey: (e: KeyboardEvent) => boolean;
+        keyTarget: (a: import("xlcalc").CellPosition, e: KeyboardEvent) => import("xlcalc").CellPosition | Promise<import("xlcalc").CellPosition | null> | null;
+        step: (dr: -1 | 0 | 1, dc: -1 | 0 | 1) => void;
+    };
+    f: {
+        formulaAt: (row: number, col: number) => string | undefined;
+        selectedFormula: import("vue").ComputedRef<string>;
+        selectedValue: import("vue").ComputedRef<string>;
+        shownFormula: import("vue").ComputedRef<string>;
+        scanOptions: () => import("xlcalc").ScanOptions | null;
+        formulaParts: import("vue").ComputedRef<import("./formula.js").FormulaPart[]>;
+        refSheet: (ref: {
+            sheet?: string;
+        }) => number;
+        sheetIndexByName: (name: string) => number;
+        highlights: import("vue").ComputedRef<{
+            ref: import("xlcalc").GridReference;
+            color: string;
+            bottom: number;
+            right: number;
+            top: string;
+            under: string;
+            start: string;
+            end: string;
+            tint: string;
+        }[]>;
+        highlightAt: (row: number, col: number, hl?: readonly import("./formula.js").Highlight[]) => {
+            edges: string[];
+            tints: string[];
+        } | null;
+    };
+    nav: {
+        history: import("vue").Ref<{
+            sheet: number;
+            selected: {
+                row: number;
+                col: number;
+            } | null;
+            extent: {
+                row: number;
+                col: number;
+            } | null;
+            scrollTop: number;
+            scrollLeft: number;
+        }[], import("./navigation.js").Place[] | {
+            sheet: number;
+            selected: {
+                row: number;
+                col: number;
+            } | null;
+            extent: {
+                row: number;
+                col: number;
+            } | null;
+            scrollTop: number;
+            scrollLeft: number;
+        }[]>;
+        flash: import("vue").Ref<{
+            sheet: string;
+            rect: {
+                top: number;
+                left: number;
+                bottom: number;
+                right: number;
+            };
+        } | null, {
+            sheet: string;
+            rect: import("xlcalc").CellRect;
+        } | {
+            sheet: string;
+            rect: {
+                top: number;
+                left: number;
+                bottom: number;
+                right: number;
+            };
+        } | null>;
+        goBack: () => Promise<void>;
+        goPlace: (text: string) => Promise<boolean>;
+        goRef: (r: import("xlcalc").GridReference) => Promise<void>;
+        addressDraft: import("vue").Ref<string, string>;
+        addressFocused: import("vue").Ref<boolean, boolean>;
+        goAddress: () => Promise<boolean>;
+        takePendingFocus: () => string | null;
+        copyCellLink: () => Promise<void>;
+    };
+    ed: {
+        pendingAt: (row: number, col: number) => string | null | undefined;
+        forget: () => void;
+        lockIn: (rect: import("xlcalc").CellRect) => string | null;
+        lockAt: (row: number, col: number) => string | null;
+        editText: (row: number, col: number) => string;
+        startEdit: (opts: {
+            text?: string;
+            mode: "enter" | "edit";
+            place?: "cell" | "bar";
+            caret?: number;
+            caretEnd?: number;
+        }) => boolean;
+        inputOf: () => HTMLTextAreaElement | null;
+        focusEditor: () => void;
+        insertFunction: (name: string) => void;
+        ac: {
+            items: import("vue").ShallowRef<readonly string[], readonly string[]>;
+            index: import("vue").Ref<number, number>;
+            open: import("vue").ComputedRef<boolean>;
+            update: (text: string, caret: number | null) => void;
+            follow: () => void;
+            accept: (i?: number) => boolean;
+            close: () => void;
+            onKey: (e: KeyboardEvent) => boolean;
+        };
+        tip: {
+            parts: import("vue").ComputedRef<import("./function-tip.js").TipPart[] | null>;
+            update: (text: string, caret: number | null) => void;
+            follow: () => void;
+            close: () => void;
+            signature: (name: string) => Promise<import("../index.js").SheetFunctionSignature | null>;
+        };
+        onEditorInput: (e: Event) => void;
+        onEditorClick: () => void;
+        commit: (dr: -1 | 0 | 1, dc: -1 | 0 | 1, refocus?: boolean) => void;
+        cancel: () => void;
+        send: (entries: import("../index.js").CellEntry[], draft: EditorState | null, opts?: import("../index.js").EditOptions, retype?: (text: string) => Promise<import("../index.js").EditOutcome | undefined>) => Promise<import("../index.js").EditOutcome | undefined>;
+        run: (call: (opts?: import("../index.js").EditOptions) => Promise<import("../index.js").EditOutcome>, marks: import("../index.js").CellEntry[], draft: EditorState | null, extent: import("xlcalc").CellPosition | null, endsCopy?: boolean, retype?: (text: string) => Promise<import("../index.js").EditOutcome | undefined>) => Promise<import("../index.js").EditOutcome>;
+        stepHistory: (kind: "undo" | "redo") => Promise<import("../index.js").EditOutcome | null>;
+        pasteText: (text: string) => void;
+        onGridKey: (e: KeyboardEvent) => void;
+        onEditorKey: (e: KeyboardEvent) => void;
+        onEditorBlur: (e: FocusEvent, place: "cell" | "bar") => void;
+    };
+    point: {
+        down: (e: PointerEvent, at: {
+            kind: import("./point.js").PointKind;
+            row: number;
+            col: number;
+        } | null) => boolean;
+        move: (e: PointerEvent) => void;
+        up: () => void;
+        key: (e: KeyboardEvent) => boolean;
+        onMouseDown: (e: MouseEvent) => void;
+        took: () => boolean;
+    };
+    totals: {
+        statsText: import("vue").ComputedRef<string>;
+        shownRows: (r1: number, r2: number) => import("./totals.js").ShownRows;
+        inWindows: (ds: import("./totals.js").ShownRows, c1: number, c2: number) => boolean;
+    };
+    filter: {
+        cols: import("vue").Ref<Record<number, {
+            values?: string[];
+            text?: string;
+        }>, Record<number, {
+            values?: string[];
+            text?: string;
+        }>>;
+        sort: import("vue").Ref<{
+            col: number;
+            dir: "asc" | "desc";
+        } | null, {
+            col: number;
+            dir: "asc" | "desc";
+        } | {
+            col: number;
+            dir: "asc" | "desc";
+        } | null>;
+        available: import("vue").ComputedRef<boolean>;
+        head: import("vue").ComputedRef<number>;
+        active: import("vue").ComputedRef<boolean>;
+        spec: import("vue").ComputedRef<import("../index.js").SheetFilter | null>;
+        status: import("vue").ComputedRef<string>;
+        restore: () => void;
+        refresh: () => Promise<void>;
+        reapply: () => Promise<boolean>;
+        clear: () => void;
+        open: import("vue").Ref<number | null, number | null>;
+        pos: import("vue").Ref<{
+            left: number;
+            top: number;
+        }, {
+            left: number;
+            top: number;
+        } | {
+            left: number;
+            top: number;
+        }>;
+        values: import("vue").Ref<{
+            text: string;
+            count: number;
+        }[], {
+            text: string;
+            count: number;
+        }[] | {
+            text: string;
+            count: number;
+        }[]>;
+        more: import("vue").Ref<number, number>;
+        busy: import("vue").Ref<boolean, boolean>;
+        draftText: import("vue").Ref<string, string>;
+        draftSearch: import("vue").Ref<string, string>;
+        title: import("vue").ComputedRef<string>;
+        shownValues: import("vue").ComputedRef<{
+            text: string;
+            count: number;
+        }[]>;
+        isChecked: (text: string) => boolean;
+        allChecked: import("vue").ComputedRef<boolean>;
+        openFunnel: (col: number, anchor?: DOMRect) => Promise<void>;
+        close: () => void;
+        toggleValue: (text: string) => void;
+        toggleAll: () => void;
+        applyDraft: () => void;
+        clearColumn: (c: number) => void;
+        sortBy: (c: number, dir: "asc" | "desc") => void;
+        onFunnelKey: (e: KeyboardEvent) => void;
+    };
+    find: {
+        available: import("vue").ComputedRef<boolean>;
+        canReplace: import("vue").ComputedRef<boolean>;
+        isOpen: import("vue").Ref<boolean, boolean>;
+        replacing: import("vue").Ref<boolean, boolean>;
+        optionsOpen: import("vue").Ref<boolean, boolean>;
+        text: import("vue").Ref<string, string>;
+        by: import("vue").Ref<string, string>;
+        options: {
+            matchCase: boolean;
+            wholeCell: boolean;
+            lookIn: "formulas" | "values";
+            byColumns: boolean;
+        };
+        lookIn: import("vue").ComputedRef<"formulas" | "values">;
+        scope: import("vue").Ref<string | null, string | null>;
+        hits: import("vue").Ref<{
+            row: number;
+            col: number;
+        }[], import("xlcalc").CellPosition[] | {
+            row: number;
+            col: number;
+        }[]>;
+        total: import("vue").Ref<number, number>;
+        index: import("vue").ComputedRef<number>;
+        busy: import("vue").Ref<boolean, boolean>;
+        writing: import("vue").Ref<boolean, boolean>;
+        input: import("vue").Ref<HTMLInputElement | null, HTMLInputElement | null>;
+        hitSet: import("vue").ComputedRef<Set<string>>;
+        current: import("vue").ComputedRef<string>;
+        openFind: () => void;
+        openReplace: () => void;
+        closeFind: () => void;
+        step: (dir: 1 | -1) => void;
+        replaceOne: (run: import("./find.js").FindRunner) => Promise<void>;
+        replaceAll: (run: import("./find.js").FindRunner) => Promise<void>;
+        onFindKey: (e: KeyboardEvent) => void;
+        status: import("vue").ComputedRef<string>;
+    };
+    explain: {
+        available: import("vue").ComputedRef<boolean>;
+        open: import("vue").Ref<boolean, boolean>;
+        place: import("vue").Ref<string, string>;
+        lines: import("vue").ShallowRef<import("./explain.js").ExplainLine[], import("./explain.js").ExplainLine[]>;
+        busy: import("vue").Ref<boolean, boolean>;
+        failed: import("vue").Ref<boolean, boolean>;
+        show: () => boolean;
+        close: () => void;
+        refresh: () => void;
+    };
+    views: {
+        spanOf: (r: number, c: number) => import("./cell-view.js").MergeSpan | null | undefined;
+        coveredByMerge: (r: number, c: number) => boolean;
+        rowState: (d: number, r: number) => import("./cell-view.js").RowState;
+        cellView: (d: number, r: number, c: number, frozen: boolean, row: import("./cell-view.js").RowState) => import("./cell-view.js").CellView;
+    };
+    list: {
+        sortable: (c: number) => boolean;
+        sortOf: (c: number) => ListSort["dir"] | null;
+        toggleSort: (c: number) => void;
+        alignOf: (c: number) => "left" | "right" | "center" | undefined;
+        click: (r: number, c: number) => boolean;
+        key: (e: KeyboardEvent) => boolean;
+        totals: import("vue").ComputedRef<(string | null)[] | null>;
+    };
+    cmd: {
+        can: (name: "outline" | "freeze" | "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>;
+        freeze: (mode?: import("../index.js").FreezeMode) => Promise<import("../index.js").EditOutcome | null>;
+        fontKey: (e: KeyboardEvent) => boolean;
+        formatOpen: import("vue").Ref<boolean, boolean>;
+        openFormat: () => boolean;
+        closeFormat: () => void;
+    };
+    api: SheetViewApi;
+    clip: {
+        mark: import("vue").ShallowRef<import("./clip.js").ClipMark | null, import("./clip.js").ClipMark | null>;
+        ants: import("vue").ComputedRef<{
+            top: number;
+            left: number;
+            width: number;
+            height: number;
+            frozen: boolean;
+        } | null>;
+        canCut: import("vue").ComputedRef<boolean>;
+        canPaste: import("vue").ComputedRef<boolean>;
+        clear: () => void;
+        onCopy: (e: ClipboardEvent) => void;
+        onCut: (e: ClipboardEvent) => void;
+        onPaste: (e: ClipboardEvent) => void;
+        copy: (cut: boolean) => void;
+        paste: () => Promise<void>;
+    };
+    fill: {
+        source: import("vue").ComputedRef<import("xlcalc").CellRect | null>;
+        drag: import("vue").ShallowRef<import("./fill.js").FillDrag | null, import("./fill.js").FillDrag | null>;
+        handle: import("vue").ComputedRef<{
+            x: number;
+            y: number;
+            frozen: boolean;
+            dragging: boolean;
+        } | null>;
+        frame: import("vue").ComputedRef<{
+            top: number;
+            left: number;
+            width: number;
+            height: number;
+            frozen: boolean;
+        } | null>;
+        onDown: (e: PointerEvent) => void;
+        onMove: (e: PointerEvent) => void;
+        onUp: (e: PointerEvent) => void;
+        onCancel: () => void;
+        autofill: () => Promise<void>;
+    };
+    viewState: import("vue").ComputedRef<SheetViewState | null>;
+    validation: {
+        current: import("vue").ShallowRef<import("../index.js").SheetValidation | null, import("../index.js").SheetValidation | null>;
+        place: import("vue").ShallowRef<import("./validation.js").ValidationPlace | null, import("./validation.js").ValidationPlace | null>;
+        list: import("vue").ComputedRef<string[] | null>;
+        prompt: import("vue").ComputedRef<{
+            title?: string;
+            text: string;
+        } | null>;
+        open: import("vue").Ref<boolean, boolean>;
+        index: import("vue").Ref<number, number>;
+        refresh: (wait?: number) => void;
+        openList: () => boolean;
+        close: () => void;
+        toggle: () => boolean | void;
+        choose: (i?: number) => boolean;
+        onKey: (e: KeyboardEvent) => boolean;
+    };
+    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>;
+        answer: (a: import("./validation.js").AlertAnswer) => void;
+    };
+    outline: {
+        outline: import("vue").ComputedRef<import("../index.js").SheetOutline | null>;
+        can: import("vue").ComputedRef<boolean>;
+        marks: (axis: import("./outline.js").OutlineAxis, line: number) => import("./outline.js").OutlineMark[];
+        at: (level: number) => number;
+        toggle: (axis: import("./outline.js").OutlineAxis, g: import("../index.js").OutlineGroup) => void;
+        showLevel: (axis: import("./outline.js").OutlineAxis, level: number) => void;
+        lines: (op: import("./outline.js").OutlineOp, axis: import("./outline.js").OutlineAxis, first: number, last: number) => void;
+        key: (e: KeyboardEvent) => boolean;
+        tap: (e: MouseEvent) => void;
+    };
+    menu: {
+        open: import("vue").ShallowRef<import("./menu.js").OpenMenu | null, import("./menu.js").OpenMenu | null>;
+        items: import("vue").ComputedRef<import("./menu.js").MenuItem[]>;
+        caption: import("vue").ComputedRef<string>;
+        dialog: import("vue").Ref<{
+            kind: "size";
+            axis: "columns" | "rows";
+            first: number;
+            last: number;
+            draft: string;
+            error: string;
+        } | {
+            kind: "deleteSheet";
+            sheet: string;
+        } | {
+            kind: "unhide";
+            sheets: string[];
+        } | {
+            kind: "outline";
+            op: import("./outline.js").OutlineOp;
+            axis: import("./outline.js").OutlineAxis;
+            rect: {
+                top: number;
+                left: number;
+                bottom: number;
+                right: number;
+            };
+        } | null, import("./menu.js").MenuDialog | {
+            kind: "size";
+            axis: "columns" | "rows";
+            first: number;
+            last: number;
+            draft: string;
+            error: string;
+        } | {
+            kind: "deleteSheet";
+            sheet: string;
+        } | {
+            kind: "unhide";
+            sheets: string[];
+        } | {
+            kind: "outline";
+            op: import("./outline.js").OutlineOp;
+            axis: import("./outline.js").OutlineAxis;
+            rect: {
+                top: number;
+                left: number;
+                bottom: number;
+                right: number;
+            };
+        } | null>;
+        renaming: import("vue").Ref<{
+            index: number;
+            draft: string;
+        } | null, {
+            index: number;
+            draft: string;
+        } | {
+            index: number;
+            draft: string;
+        } | null>;
+        renameInput: import("vue").Ref<HTMLInputElement | null, HTMLInputElement | null>;
+        close: () => null;
+        choose: (item: import("./menu.js").MenuItem) => void;
+        openLines: (kind: "rows" | "columns", line: number, x: number, y: number) => boolean;
+        openSheet: (index: number, x: number, y: number) => Promise<boolean>;
+        openCells: (row: number, col: number, x: number, y: number) => void;
+        linesAvailable: import("vue").ComputedRef<boolean>;
+        applySize: () => void;
+        askOutline: (op: import("./outline.js").OutlineOp) => void;
+        applyOutline: () => void;
+        addSheet: () => Promise<import("../index.js").EditOutcome | null>;
+        confirmDelete: () => void;
+        unhide: (name: string) => void;
+        startRename: (index: number) => void;
+        commitRename: (left?: boolean) => Promise<void>;
+        cancelRename: () => null;
+        press: {
+            start: (e: PointerEvent, open: (x: number, y: number) => void) => void;
+            move: (e: PointerEvent) => void;
+            cancel: () => void;
+            after: () => boolean;
+            pressing: () => boolean;
+            context: (e: MouseEvent) => boolean;
+        };
+    };
+    editor: import("vue").Ref<{
+        sheet: string;
+        row: number;
+        col: number;
+        text: string;
+        initial: string;
+        mode: "enter" | "edit";
+        place: "cell" | "bar";
+        caret: number | null;
+        caretEnd?: number | undefined;
+        inPlace: boolean;
+    } | null, EditorState | {
+        sheet: string;
+        row: number;
+        col: number;
+        text: string;
+        initial: string;
+        mode: "enter" | "edit";
+        place: "cell" | "bar";
+        caret: number | null;
+        caretEnd?: number | undefined;
+        inPlace: boolean;
+    } | null>;
+    message: import("vue").Ref<string | null, string | null>;
+    notify: (text: string) => void;
+    dismiss: () => null;
+    cellInput: import("vue").Ref<HTMLTextAreaElement | null, HTMLTextAreaElement | null>;
+    barInput: import("vue").Ref<HTMLTextAreaElement | null, HTMLTextAreaElement | null>;
+    barOpen: import("vue").Ref<boolean, boolean>;
+    toggleBar: () => boolean;
+    tabs: import("vue").ComputedRef<{
+        sheet: SheetInfo;
+        i: number;
+    }[]>;
+    showTabs: import("vue").ComputedRef<boolean>;
+    pickSheet: (index: number) => Promise<void>;
+    reload: () => Promise<void>;
+    retry: () => void;
+    startResize: (e: PointerEvent, col: number) => void;
+    onResizeMove: (e: PointerEvent) => void;
+    endResize: () => void;
+    rowsResizable: import("vue").ComputedRef<boolean>;
+    startRowResize: (e: PointerEvent, row: number) => void;
+    onRowResizeMove: (e: PointerEvent) => void;
+    endRowResize: () => Promise<void>;
+    onRowEdgeDouble: (row: number) => void;
+    fitsOnEdge: import("vue").ComputedRef<boolean>;
+    onEdgeDouble: (col: number) => void;
+    onLink: (e: MouseEvent, link: NonNullable<SheetWindow["links"]>[string], row: number, col: number) => void;
+    onScroll: () => void;
+    onGridKey: (e: KeyboardEvent) => void;
+    props: SheetViewProps;
+    source: () => import("../index.js").SheetSource;
+    sourceMethod: <K extends import("./state.js").SourceMethod>(name: K) => NonNullable<import("../index.js").SheetSource[K]> | null;
+    outdated: () => () => boolean;
+    endWorkbook: () => undefined;
+    messages: import("vue").ComputedRef<import("../index.js").SheetMessages>;
+    locale: import("vue").ComputedRef<string>;
+    memory: import("./storage.js").Memory;
+    editable: import("vue").ComputedRef<boolean>;
+    sheets: import("vue").ShallowRef<SheetInfo[], SheetInfo[]>;
+    active: import("vue").Ref<number, number>;
+    sheet: import("vue").ComputedRef<SheetInfo | null>;
+    sheetName: import("vue").ComputedRef<string>;
+    grown: import("vue").Ref<{
+        rows: number;
+        cols: number;
+    }, {
+        rows: number;
+        cols: number;
+    } | {
+        rows: number;
+        cols: number;
+    }>;
+    reach: import("vue").Ref<{
+        rows: number;
+        cols: number;
+    }, {
+        rows: number;
+        cols: number;
+    } | {
+        rows: number;
+        cols: number;
+    }>;
+    dataRows: import("vue").ComputedRef<number>;
+    dataCols: import("vue").ComputedRef<number>;
+    visible: import("vue").ShallowRef<{
+        key: string;
+        spec: import("../index.js").SheetFilter;
+        rows: Int32Array;
+        index: Int32Array;
+    } | null, {
+        key: string;
+        spec: import("../index.js").SheetFilter;
+        rows: Int32Array;
+        index: Int32Array;
+    } | null>;
+    filterWait: import("vue").Ref<boolean, boolean>;
+    rowOf: (d: number) => number;
+    indexOf: (r: number) => number | undefined;
+    dataShown: import("vue").ComputedRef<number>;
+    rowCount: import("vue").ComputedRef<number>;
+    lastRow: import("vue").ComputedRef<number>;
+    colCount: import("vue").ComputedRef<number>;
+    failure: import("vue").ShallowRef<import("../index.js").SheetFailure | null, import("../index.js").SheetFailure | null>;
+    failureOf: (error: unknown) => import("../index.js").SheetFailure;
+    loading: import("vue").Ref<boolean, boolean>;
+    scroller: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+    scrollTop: import("vue").Ref<number, number>;
+    scrollLeft: import("vue").Ref<number, number>;
+    viewH: import("vue").Ref<number, number>;
+    viewW: import("vue").Ref<number, number>;
+    bookWidths: import("vue").ShallowRef<Map<number, number | null>, Map<number, number | null>>;
+    userWidths: import("vue").ShallowRef<Record<number, number>, Record<number, number>>;
+    heights: import("vue").ShallowRef<Map<number, number>, Map<number, number>>;
+    defaultRowPx: import("vue").Ref<number, number>;
+    selected: import("vue").Ref<{
+        row: number;
+        col: number;
+    } | null, import("xlcalc").CellPosition | {
+        row: number;
+        col: number;
+    } | null>;
+    extent: import("vue").Ref<{
+        row: number;
+        col: number;
+    } | null, import("xlcalc").CellPosition | {
+        row: number;
+        col: number;
+    } | null>;
+    anchor: import("vue").Ref<{
+        row: number;
+        col: number;
+    } | null, import("xlcalc").CellPosition | {
+        row: number;
+        col: number;
+    } | null>;
+    hooks: {
+        unfilter: (_row: number) => void;
+        changing: () => void;
+    };
+    focusGrid: () => void;
+    scrollGridTo: (top: number, left: number) => void;
+    grow: (row: number, col: number) => void;
+    stretch: (row: number, col: number) => void;
+};
+export type SheetContext = ReturnType<typeof useSheet>;