@xlcalc/vue 0.0.0-stage → 0.21.2

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

@@ -0,0 +1,104 @@
+import { type ComputedRef, type Ref } from 'vue';
+import type { Icon } from 'xlcalc/contract';
+import type { Editing, EditorState } from './editing.js';
+import type { Formula, Highlight } from './formula.js';
+import type { Geometry } from './geometry.js';
+import type { Navigation } from './navigation.js';
+import type { Selection } from './selection.js';
+import type { SheetState } from './state.js';
+import type { Viewport } from './viewport.js';
+import type { CellData, Windows } from './windows.js';
+/** A merged range as drawn: its size in the workbook (box height) and in drawn rows and columns (hidden ones are not in the DOM). */
+export interface MergeSpan {
+    rs: number;
+    cs: number;
+    rsDom: number;
+    csDom: number;
+}
+export type ContentKind = 'text' | 'fill' | 'overflow' | 'href' | 'place' | 'host' | 'dead' | 'icon';
+export interface CellView {
+    attrs: {
+        class: string[];
+        style: Record<string, string>;
+        title: string;
+        rowspan?: number;
+        colspan?: number;
+        'data-cell': string;
+    };
+    box: {
+        class: string[];
+        style: Record<string, string>;
+    };
+    kind: ContentKind;
+    text: string;
+    /** Underline and strikethrough, set on the element that holds the text. */
+    deco: Record<string, string>;
+    /** Overflow into empty neighbors: the pixels taken on the left and right, the text's position, its background (hides crossed gridlines, as in Excel). */
+    ov?: {
+        left: number;
+        right: number;
+        justify: string;
+        bg: string;
+    };
+    link?: CellData['link'];
+    /** A conditional format's icon, drawn at the left of the cell before its text. */
+    icon?: Icon;
+    /** The draft typed in the formula bar replaces `text`, drawn separately so typing does not redraw the grid; `fill`: the width Excel's Fill alignment repeats it across. */
+    draft?: {
+        fill?: number;
+    };
+}
+/** The frequently changing state that a drawn row's cells need, computed per row: a change redraws only the rows it affects. */
+export interface RowState {
+    /** The row's height in pixels. */
+    height: number;
+    /** The selection over the row: its columns, whether the row is its top, how many rows below this one it ends (counted only as far as the row's merges reach), several cells or one; null when it does not cross the row. */
+    sel: {
+        left: number;
+        right: number;
+        top: boolean;
+        below: number;
+        multi: boolean;
+    } | null;
+    /** The active cell's column in the row; 0 for none. */
+    active: number;
+    /** The formula's ranges over the row. */
+    hl: readonly Highlight[];
+    /** Columns of the search matches in the row, and of the current one (0: not in the row). */
+    hits: ReadonlySet<number> | undefined;
+    hitNow: number;
+    /** The columns of the range just jumped to, over the row. */
+    flash: {
+        left: number;
+        right: number;
+    } | null;
+    /** The editor open on a cell of the row: its column, and whether it is the formula bar's. */
+    editor: {
+        col: number;
+        bar: boolean;
+    } | null;
+}
+/** Whether two states of a row draw the same. */
+export declare function sameRowState(a: RowState, b: RowState): boolean;
+/** Links a browser may open on its own; anything else (`javascript:` and the like) goes to the host or is only displayed. */
+export declare const safeHref: (href: string | undefined) => boolean;
+interface CellViewDeps {
+    editor: Ref<EditorState | null>;
+    /** Search matches by `row:col`, and the current one. */
+    find: {
+        hitSet: ComputedRef<Set<string>>;
+        current: ComputedRef<string>;
+    };
+    /** Whether the host listens to `openLink`. */
+    hostLinks: () => boolean;
+    /** List mode's `openRows`: the first column's cells open their rows. */
+    openRows: () => boolean;
+}
+export declare function useCellView(s: SheetState, geo: Geometry, v: Viewport, w: Windows, sel: Selection, f: Formula, nav: Navigation, ed: Editing, deps: CellViewDeps): {
+    spanOf: (r: number, c: number) => MergeSpan | null | undefined;
+    coveredByMerge: (r: number, c: number) => boolean;
+    rowState: (d: number, r: number) => RowState;
+    cellView: (d: number, r: number, c: number, frozen: boolean, row: RowState) => CellView;
+};
+export type CellViews = ReturnType<typeof useCellView>;
+export {};

package/dist/core/clip.d.ts

@@ -0,0 +1,43 @@
+import { type Ref } from 'vue';
+import type { CellRect } from 'xlcalc/contract';
+import type { Commands } from './commands.js';
+import type { Editing, EditorState } from './editing.js';
+import type { Selection } from './selection.js';
+import type { SheetState } from './state.js';
+import { type Totals } from './totals.js';
+import type { Viewport } from './viewport.js';
+import type { Windows } from './windows.js';
+/** The range copied or cut on the grid, as Excel's copy mode holds it; `text` is what went to the clipboard, null while it is read. */
+export interface ClipMark {
+    sheet: string;
+    rect: CellRect;
+    text: string | null;
+    cut: boolean;
+    /** The displayed text the copy event put on the clipboard, when the source's own copy text replaced it there: pasting either counts as this copy. */
+    shown?: string;
+}
+export interface ClipDeps {
+    notify: (text: string) => void;
+    editor: Ref<EditorState | null>;
+    /** Whether a column is visible: Excel omits hidden ones from a copy. */
+    colShown: (col: number) => boolean;
+}
+export declare function useClip(s: SheetState, w: Windows, sel: Selection, v: Viewport, ed: Editing, cmd: Commands, totals: Totals, deps: ClipDeps): {
+    mark: import("vue").ShallowRef<ClipMark | null, 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>;
+};
+export type Clip = ReturnType<typeof useClip>;

package/dist/core/commands.d.ts

@@ -0,0 +1,47 @@
+import type { CellStyle } from 'xlcalc/contract';
+import type { EditOutcome, LayoutChange, OutlineChange, SheetOp } from '../contract/source.js';
+import type { Editing } from './editing.js';
+import type { FreezeMode, SheetFormatPatch } from '../contract/view.js';
+import type { Selection } from './selection.js';
+import type { SheetState } from './state.js';
+/** The sheet to display once the sheets are read again: by name, keeping the selection or starting over on it. */
+export interface SheetTarget {
+    name: string;
+    keep: boolean;
+}
+export interface CommandsDeps {
+    /** Reads the sheets and windows again; counters of reloads started and of `repaint` events received, to tell whether the source sent either during a call. */
+    reload: () => Promise<void>;
+    reloads: () => number;
+    repaints: () => number;
+    /** The sheet the next read displays. */
+    target: (t: SheetTarget | null) => void;
+    /** The active cell's displayed style. */
+    activeStyle: () => CellStyle | undefined;
+    /** Whether the workbook freezes panes on the displayed sheet, the panes Excel freezes with A1 active, and the view after a freeze. */
+    frozen: () => boolean;
+    middlePanes: () => {
+        rows: number;
+        cols: number;
+    };
+    showFreeze: (sheet: string, on: boolean) => void;
+    /** A structure operation succeeded: rows or columns may have moved, so what the sheet stores by row or column number no longer holds. */
+    structured: () => void;
+}
+/** The source's methods that change the workbook beyond cells. */
+type ChangeMethod = 'format' | 'structure' | 'layout' | 'outline' | 'freeze';
+export declare function useCommands(s: SheetState, sel: Selection, ed: Editing, deps: CommandsDeps): {
+    can: (name: ChangeMethod) => boolean;
+    canRanges: import("vue").ComputedRef<boolean>;
+    format: (patches: SheetFormatPatch[]) => Promise<EditOutcome | null>;
+    structure: (op: SheetOp, endsCopy?: boolean) => Promise<EditOutcome | null>;
+    layout: (edit: LayoutChange) => Promise<EditOutcome | null>;
+    outline: (command: OutlineChange) => Promise<EditOutcome | null>;
+    freeze: (mode?: FreezeMode) => Promise<EditOutcome | null>;
+    fontKey: (e: KeyboardEvent) => boolean;
+    formatOpen: import("vue").Ref<boolean, boolean>;
+    openFormat: () => boolean;
+    closeFormat: () => void;
+};
+export type Commands = ReturnType<typeof useCommands>;
+export {};

package/dist/core/conditional.d.ts

@@ -0,0 +1,16 @@
+import type { BarLook, CellStyle, ConditionalStyle } from 'xlcalc/contract';
+/** A background layer of a cell: its image, size and position. */
+export interface Layer {
+    img: string;
+    size: string;
+    pos: string;
+}
+/** A rule's style on top of the cell's displayed style, as Excel applies a differential format: each field the rule sets replaces the cell's. */
+export declare function lookStyle(style: CellStyle | undefined, rule: ConditionalStyle | undefined): CellStyle | undefined;
+/**
+ * A data bar as background layers, top first: the axis, the fill, the border under it. Excel draws a bar 1 px inside the
+ * cell's sides, 1 px below its top and 3 px above its bottom line (1 and 2 points at 15 points tall); a gradient is the
+ * bar's color at its axis (or start) fading toward white, the border a 1 px line around the bar, the axis a dashed 1 px
+ * line across the entire cell.
+ */
+export declare function barLayers(bar: BarLook): Layer[];

package/dist/core/editing.d.ts

@@ -0,0 +1,85 @@
+import { type Ref } from 'vue';
+import type { CellPosition, CellRect } from 'xlcalc/contract';
+import type { CellEntry, EditOutcome, EditOptions } from '../contract/source.js';
+import type { AlertAnswer, SheetAlert } from './validation.js';
+import type { Formula } from './formula.js';
+import type { Selection } from './selection.js';
+import type { SheetState } from './state.js';
+import type { Windows } from './windows.js';
+/** The cell being edited and its draft. `enter` was started by typing (arrows insert references or commit), `edit` by F2 or a double click (arrows move the caret). */
+export interface EditorState {
+    sheet: string;
+    row: number;
+    col: number;
+    text: string;
+    initial: string;
+    mode: 'enter' | 'edit';
+    place: 'cell' | 'bar';
+    /** Where to put the caret once the editor shows; null after that. */
+    caret: number | null;
+    /** The other end of a selection to set with the caret (text dragged over in the formula bar), otherwise the caret alone. */
+    caretEnd?: number;
+    /** The editor opened with the cell's own text (F2, a double click, the formula bar), not with a key typed over the cell. */
+    inPlace: boolean;
+}
+export interface EditingDeps {
+    notify: (text: string) => void;
+    /** Reads the sheets and windows again (after a conflict). */
+    reload: () => Promise<void>;
+    /** Makes another sheet active: an outcome's selection on it. */
+    pickSheet: (index: number) => Promise<void>;
+    cellInput: Ref<HTMLTextAreaElement | null>;
+    barInput: Ref<HTMLTextAreaElement | null>;
+    /** A key that belongs to the sheet inside the editor too (Ctrl+Shift+U for the formula bar): true when handled. */
+    barKey?: (e: KeyboardEvent) => boolean;
+    /** Excel's Enter mode for a key in the editor: an arrow inserts a reference, enters the draft or does nothing (`refAt`); true when handled. */
+    point?: (e: KeyboardEvent) => boolean;
+    /** Excel's alert of a data validation rule for a rejected value, or the prompt for a formula that cannot be parsed, and the user's answer; without it the rejection goes to the message line. */
+    alert?: (alert: SheetAlert) => Promise<AlertAnswer>;
+}
+export declare function useEditing(s: SheetState, w: Windows, sel: Selection, f: Formula, editor: Ref<EditorState | null>, deps: EditingDeps): {
+    pendingAt: (row: number, col: number) => string | null | undefined;
+    forget: () => void;
+    lockIn: (rect: 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: 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: CellEntry[], draft: EditorState | null, opts?: EditOptions, retype?: (text: string) => Promise<EditOutcome | undefined>) => Promise<EditOutcome | undefined>;
+    run: (call: (opts?: EditOptions) => Promise<EditOutcome>, marks: CellEntry[], draft: EditorState | null, extent: CellPosition | null, endsCopy?: boolean, retype?: (text: string) => Promise<EditOutcome | undefined>) => Promise<EditOutcome>;
+    stepHistory: (kind: "undo" | "redo") => Promise<EditOutcome | null>;
+    pasteText: (text: string) => void;
+    onGridKey: (e: KeyboardEvent) => void;
+    onEditorKey: (e: KeyboardEvent) => void;
+    onEditorBlur: (e: FocusEvent, place: "cell" | "bar") => void;
+};
+export type Editing = ReturnType<typeof useEditing>;

package/dist/core/explain.d.ts

@@ -0,0 +1,36 @@
+import type { GridReference } from 'xlcalc/contract';
+import type { Formula } from './formula.js';
+import type { SheetState } from './state.js';
+/** The pause after the active cell moves before the source is queried, so held-down keys do not request every cell they pass. */
+export declare const EXPLAIN_DELAY_MS = 150;
+/** A piece of a tree line: a reference with the sheet it is on, or text; `from` when it is after the node's arrow (its formula, where the value came from). */
+export interface ExplainPart {
+    text: string;
+    ref?: GridReference & {
+        sheet: string;
+    };
+    from?: boolean;
+}
+export interface ExplainLine {
+    depth: number;
+    parts: ExplainPart[];
+}
+/**
+ * The source's text as the tree's lines, as xlcalc's `explain` writes it: one node per line, each two-space indent one
+ * level, the node's reference first (`'Q 4'!A2 = 60  ← Data!A4*2`). References to cells, columns or rows on a single sheet
+ * become pieces, parsed as stored formula text, which parses addresses the same in every locale; one without a sheet name
+ * is on the sheet of its line's node, otherwise on `sheet`. Anything else (a table, a 3D reference, another workbook's) stays text.
+ */
+export declare function explainLines(text: string, sheet: string): ExplainLine[];
+export declare function useExplain(s: SheetState, f: Formula): {
+    available: import("vue").ComputedRef<boolean>;
+    open: import("vue").Ref<boolean, boolean>;
+    place: import("vue").Ref<string, string>;
+    lines: import("vue").ShallowRef<ExplainLine[], ExplainLine[]>;
+    busy: import("vue").Ref<boolean, boolean>;
+    failed: import("vue").Ref<boolean, boolean>;
+    show: () => boolean;
+    close: () => void;
+    refresh: () => void;
+};
+export type Explain = ReturnType<typeof useExplain>;

package/dist/core/fill.d.ts

@@ -0,0 +1,42 @@
+import { type Ref } from 'vue';
+import type { CellRect } from 'xlcalc/contract';
+import type { Commands } from './commands.js';
+import type { Editing, EditorState } from './editing.js';
+import type { Geometry } from './geometry.js';
+import type { Selection } from './selection.js';
+import { type SheetState } from './state.js';
+import type { Viewport } from './viewport.js';
+export interface FillDeps {
+    notify: (text: string) => void;
+    editor: Ref<EditorState | null>;
+}
+/** A drag of the handle: the selection it fills from, the cells added so far, the pointer. */
+export interface FillDrag {
+    from: CellRect;
+    to: CellRect | null;
+    pointer: number;
+    touch: boolean;
+}
+export declare function useFill(s: SheetState, geo: Geometry, v: Viewport, sel: Selection, ed: Editing, cmd: Commands, deps: FillDeps): {
+    source: import("vue").ComputedRef<CellRect | null>;
+    drag: import("vue").ShallowRef<FillDrag | null, 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>;
+};
+export type Fill = ReturnType<typeof useFill>;

package/dist/core/filter.d.ts

@@ -0,0 +1,72 @@
+import type { SheetFilter } from '../contract/source.js';
+import type { SheetState } from './state.js';
+import type { Windows } from './windows.js';
+export declare function useFilter(s: SheetState, w: Windows, notify: (text: string) => void): {
+    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<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;
+};
+export type Filter = ReturnType<typeof useFilter>;

package/dist/core/find.d.ts

@@ -0,0 +1,53 @@
+import type { CellPosition } from 'xlcalc/contract';
+import type { EditOutcome } from '../contract/source.js';
+import type { Selection } from './selection.js';
+import type { SheetState } from './state.js';
+/** The options of Excel's Find dialog. */
+export interface FindOptions {
+    matchCase: boolean;
+    wholeCell: boolean;
+    lookIn: 'formulas' | 'values';
+    byColumns: boolean;
+}
+/** A change sent to the source as an edit is sent (`Editing.run`): its outcome applied to the windows, a rejection reported. */
+export type FindRunner = (call: () => Promise<EditOutcome>) => Promise<EditOutcome>;
+export declare function useFind(s: SheetState, sel: Selection, notify: (text: string) => void): {
+    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;
+    }[], 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: FindRunner) => Promise<void>;
+    replaceAll: (run: FindRunner) => Promise<void>;
+    onFindKey: (e: KeyboardEvent) => void;
+    status: import("vue").ComputedRef<string>;
+};
+export type Find = ReturnType<typeof useFind>;

package/dist/core/formula.d.ts

@@ -0,0 +1,41 @@
+import { type Ref } from 'vue';
+import type { GridReference, ScanOptions } from 'xlcalc/contract';
+import type { Selection } from './selection.js';
+import type { SheetState } from './state.js';
+import type { Windows } from './windows.js';
+/** A piece of a formula as the formula bar displays it; a reference carries its range and color. */
+export interface FormulaPart {
+    text: string;
+    ref?: GridReference;
+    color?: string;
+}
+export declare function useFormula(s: SheetState, w: Windows, sel: Selection, draft: Ref<string | null>): {
+    formulaAt: (row: number, col: number) => string | undefined;
+    selectedFormula: import("vue").ComputedRef<string>;
+    selectedValue: import("vue").ComputedRef<string>;
+    shownFormula: import("vue").ComputedRef<string>;
+    scanOptions: () => ScanOptions | null;
+    formulaParts: import("vue").ComputedRef<FormulaPart[]>;
+    refSheet: (ref: {
+        sheet?: string;
+    }) => number;
+    sheetIndexByName: (name: string) => number;
+    highlights: import("vue").ComputedRef<{
+        ref: GridReference;
+        color: string;
+        bottom: number;
+        right: number;
+        top: string;
+        under: string;
+        start: string;
+        end: string;
+        tint: string;
+    }[]>;
+    highlightAt: (row: number, col: number, hl?: readonly Highlight[]) => {
+        edges: string[];
+        tints: string[];
+    } | null;
+};
+export type Formula = ReturnType<typeof useFormula>;
+/** A highlighted range with its border sides and tint. */
+export type Highlight = Formula['highlights']['value'][number];

package/dist/core/function-tip.d.ts

@@ -0,0 +1,34 @@
+import { type Ref } from 'vue';
+import type { ScanOptions } from 'xlcalc/contract';
+import type { SheetFunctionSignature, SheetSource } from '../contract/source.js';
+import type { EditorState } from './editing.js';
+/** A piece of the tooltip's text; the argument at the caret is `current`. */
+export interface TipPart {
+    text: string;
+    current?: boolean;
+}
+/**
+ * The tooltip in pieces with the argument at `index` current; beyond the list, the repeating group continues with its
+ * numbers counted up until it includes the argument (`SUM(number1, [number2], [number3], ...)`), as Excel's tooltip does.
+ * A text that does not contain the names in order is displayed as a whole, with nothing current.
+ */
+export declare function tipParts(sig: SheetFunctionSignature, index: number): TipPart[];
+export interface FunctionTipDeps {
+    source: () => SheetSource;
+    editor: Ref<EditorState | null>;
+    /** The open editor's element, for its caret. */
+    input: () => HTMLTextAreaElement | null;
+    /** How the workbook's formula text is parsed; null while its locale loads. */
+    scan: () => ScanOptions | null;
+    /** The function list is open: it takes precedence, and the tooltip waits under it. */
+    listOpen: () => boolean;
+}
+/** The tooltip's state over the editor's draft: the signature of the call at the caret and its argument, requested once per name. */
+export declare function useFunctionTip(deps: FunctionTipDeps): {
+    parts: import("vue").ComputedRef<TipPart[] | null>;
+    update: (text: string, caret: number | null) => void;
+    follow: () => void;
+    close: () => void;
+    signature: (name: string) => Promise<SheetFunctionSignature | null>;
+};
+export type FunctionTip = ReturnType<typeof useFunctionTip>;

package/dist/core/geometry.d.ts

@@ -0,0 +1,55 @@
+import { type Ref, type ShallowRef } from 'vue';
+/** A column's resizing limits, in pixels. */
+export declare const MIN_COL_PX = 20;
+export declare const MAX_COL_PX = 900;
+/** A column width as xlsx stores it, in whole pixels in the library's geometry (Excel for Mac's, 53 points without a width), the one xlcalc uses to lay out `####`, overflow and wrapping. */
+export declare function colPx(width: number | null | undefined): number;
+/** Pixels back to the stored width, in whole points as the library stores them. */
+export declare const widthFromPx: (px: number) => number;
+/** Points to pixels at 96 dpi. */
+export declare const rowPx: (pt: number) => number;
+/** A row dragged by its edge: down to 2 px, up to Excel's tallest row. */
+export declare const MIN_ROW_PX = 2;
+export declare const MAX_ROW_PX: number;
+/** Pixels back to points, rounded to Excel's quarter point. */
+export declare const ptFromPx: (px: number) => number;
+/** A font size in points to the grid's pixels: 11 pt is the grid's base 12.5 px, the rest in proportion. */
+export declare const fontPx: (pt: number) => number;
+/** Prefix sums: out[i] is the far edge of item i (out[0] = 0). */
+export declare function prefixSums(count: number, sizeOf: (i: number) => number): Float64Array;
+/** The item under an offset, by binary search over prefix sums; clamped to 1..count. */
+export declare function indexAt(offsets: Float64Array, count: number, x: number): number;
+interface GeometryInput {
+    rowCount: Readonly<Ref<number>>;
+    colCount: Readonly<Ref<number>>;
+    /** Column widths as the workbook stores them (null: the default). */
+    bookWidths: ShallowRef<Map<number, number | null>>;
+    /** Widths set with the mouse, in pixels by column; they take precedence over the workbook's. */
+    userWidths: ShallowRef<Record<number, number>>;
+    /** Row heights in pixels that differ from the default (0 hides a row): changed in place through `setHeights`, or replaced as a whole. */
+    heights: ShallowRef<Map<number, number>>;
+    defaultRowPx: Ref<number>;
+    /** The display filter in effect: another one is another order of rows. */
+    visible: Readonly<Ref<unknown>>;
+    /** The sheet row displayed at a display index (heights are the sheet rows') and back. */
+    rowOf: (d: number) => number;
+    indexOf: (r: number) => number | undefined;
+}
+/** Offsets of columns and rows, and the item under an offset; rows are display indexes (`d`). */
+export declare function useGeometry(i: GeometryInput): {
+    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;
+};
+export type Geometry = ReturnType<typeof useGeometry>;
+export {};

package/dist/core/keys.d.ts

@@ -0,0 +1,8 @@
+/** A shortcut's Latin letter: the key's own, otherwise its position on the keyboard (`KeyB` under Russian `и`); '' for anything else. */
+export declare function shortcutLetter(e: KeyboardEvent): string;
+/** Whether it is a Mac, where Excel ends a copy's text without a line break (Windows with CRLF), drags a series with Option and names Cmd in tooltips. */
+export declare const onMac: () => boolean;
+/** Ctrl or Cmd held: Excel's shortcuts accept either, Cmd on a Mac. */
+export declare const isMod: (e: KeyboardEvent | MouseEvent) => boolean;
+/** A shortcut and not a character: Ctrl alone or Cmd; AltGr arrives as Ctrl+Alt and types characters (`@`, `[` on many layouts). */
+export declare const isShortcut: (e: KeyboardEvent) => boolean;

package/dist/core/list-keys.d.ts

@@ -0,0 +1,4 @@
+/** How far a key moves a list's highlight: one item, a page of `page` items, or the entire list (Home, End); null for another key. */
+export declare function listStep(key: string, count: number, page: number): number | null;
+/** The item `by` steps from `index` among `count` (at least one), clamped to the list; from none (-1), Down goes to the first and Up to the last. */
+export declare function stepIndex(index: number, by: number, count: number): number;