@xlcalc/vue 0.21.2 → 0.23.1

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

@@ -93,6 +93,8 @@ interface CellViewDeps {
     hostLinks: () => boolean;
     /** List mode's `openRows`: the first column's cells open their rows. */
     openRows: () => boolean;
+    /** What a cell shows under Excel's Show Formulas. */
+    formulaText: (data: CellData) => string;
 }
 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;

package/dist/core/cf-commands.d.ts

@@ -0,0 +1,70 @@
+import type { ConditionalFormat, ConditionalStyle, IconSetName, Locale, ScanOptions } from 'xlcalc/contract';
+import type { ClearRulesFrom, ColorScalePreset, DataBarColor, QuickRule } from '../contract/conditional.js';
+import type { EditOutcome } from '../contract/source.js';
+import { type QuickInput } from './cf-presets.js';
+import type { Editing } from './editing.js';
+import type { Selection } from './selection.js';
+import type { SheetState } from './state.js';
+import type { Windows } from './windows.js';
+/** Where a dialog's rule goes: the sheet, its ranges, and the active cell that typed formulas are relative to, as in Excel. */
+export interface RuleTarget {
+    sheet: string;
+    ranges: string[];
+    active: {
+        row: number;
+        col: number;
+    };
+}
+/** The New or Edit Formatting Rule dialog: its target, the rule edited (null for a new one), and what OK does with the rule. */
+export interface RuleDialog extends RuleTarget {
+    base: ConditionalFormat | null;
+    done: (rule: ConditionalFormat) => void;
+}
+/** A rule's Format Cells: the format it opens with, what OK does with the new one, and what Cancel does. */
+export interface StyleDialog {
+    style: ConditionalStyle;
+    done: (style: ConditionalStyle) => void;
+    cancel?: () => void;
+}
+/** The Rules Manager: the sheet, the selection it lists rules for, and the sheet's rules once read. */
+export interface ManagerState extends RuleTarget {
+    rules: ConditionalFormat[] | null;
+}
+export interface ConditionalDeps {
+    notify: (text: string) => void;
+    /** How the workbook's formula text is parsed (its locale); null while the locale loads. */
+    scan: () => ScanOptions | null;
+}
+export declare function useConditional(s: SheetState, sel: Selection, w: Windows, ed: Editing, deps: ConditionalDeps): {
+    api: {
+        quickRule: (kind: QuickRule) => boolean;
+        dataBars: (color: DataBarColor, fill?: "gradient" | "solid") => Promise<EditOutcome | null>;
+        colorScale: (preset: ColorScalePreset) => Promise<EditOutcome | null>;
+        iconSet: (icons: IconSetName) => Promise<EditOutcome | null>;
+        clearRules: (from: ClearRulesFrom) => Promise<EditOutcome | null>;
+        newRule: () => boolean;
+        manageRules: () => boolean;
+    };
+    quick: import("vue").ShallowRef<(RuleTarget & {
+        kind: QuickRule;
+    }) | null, (RuleTarget & {
+        kind: QuickRule;
+    }) | null>;
+    rule: import("vue").ShallowRef<RuleDialog | null, RuleDialog | null>;
+    style: import("vue").ShallowRef<StyleDialog | null, StyleDialog | null>;
+    manager: import("vue").ShallowRef<ManagerState | null, ManagerState | null>;
+    locale: () => Locale | undefined;
+    stored: (t: RuleTarget, ranges?: string[]) => (formula: string) => string;
+    shown: (t: RuleTarget, ranges: string[]) => (formula: string) => string;
+    activeAddress: (t: RuleTarget) => string;
+    quickOk: (q: QuickInput) => void;
+    quickClose: () => void;
+    openRule: (d: RuleDialog) => void;
+    ruleClose: () => void;
+    openStyle: (d: StyleDialog) => StyleDialog;
+    styleClose: (made: ConditionalStyle | null) => void;
+    managerWrite: (next: ConditionalFormat[], close: boolean) => Promise<void>;
+    managerClose: () => void;
+    closeAll: () => void;
+};
+export type Conditional = ReturnType<typeof useConditional>;

package/dist/core/cf-describe.d.ts

@@ -0,0 +1,4 @@
+import type { ConditionalFormat } from 'xlcalc/contract';
+import type { SheetMessages } from '../contract/messages.js';
+/** The Rule column's text for a rule; `shown` gives a formula relative to the active cell. */
+export declare function describeRule(rule: ConditionalFormat, m: SheetMessages, shown: (formula: string) => string): string;

package/dist/core/cf-draft.d.ts

@@ -0,0 +1,114 @@
+import type { ConditionalFormat, ConditionalStyle, ConditionalValue, IconSetName, Locale, TimePeriodFormat, TextFormat, CellIsFormat } from 'xlcalc/contract';
+import type { Entry } from '../entry.js';
+export type RuleKind = 'values' | 'contain' | 'rank' | 'average' | 'unique' | 'formula';
+/** The rule types in the order of Excel's list. */
+export declare const RULE_KINDS: readonly RuleKind[];
+export type ValuesStyle = 'scale2' | 'scale3' | 'dataBar' | 'iconSet';
+export declare const VALUES_STYLES: readonly ValuesStyle[];
+export type ContainKind = 'cellValue' | 'text' | 'dates' | 'blanks' | 'noBlanks' | 'errors' | 'noErrors';
+export declare const CONTAIN_KINDS: readonly ContainKind[];
+export type Operator = CellIsFormat['operator'];
+export declare const OPERATORS: readonly Operator[];
+export type TextOp = TextFormat['type'];
+export declare const TEXT_OPS: readonly TextOp[];
+export type Period = TimePeriodFormat['period'];
+/** The periods in the order of Excel's list. */
+export declare const PERIODS: readonly Period[];
+export type AverageKind = 'above' | 'below' | 'equalAbove' | 'equalBelow' | 'std1Above' | 'std2Above' | 'std3Above' | 'std1Below' | 'std2Below' | 'std3Below';
+export declare const AVERAGE_KINDS: readonly AverageKind[];
+export type ValueType = ConditionalValue['type'];
+/** The threshold types each box offers: a scale's lowest and highest point, its midpoint, a data bar's bounds, an icon's threshold. */
+export declare const LOW_TYPES: readonly ValueType[];
+export declare const MID_TYPES: readonly ValueType[];
+export declare const HIGH_TYPES: readonly ValueType[];
+export declare const BAR_LOW_TYPES: readonly ValueType[];
+export declare const BAR_HIGH_TYPES: readonly ValueType[];
+export declare const ICON_TYPES: readonly ValueType[];
+/** Excel's icon sets in the order of its Icon Style list. */
+export declare const ICON_SETS: readonly IconSetName[];
+export interface PointDraft {
+    type: ValueType;
+    /** The box's text: a number, or a formula after `=`. */
+    value: string;
+    color: string;
+}
+export interface IconPointDraft {
+    gte: boolean;
+    type: ValueType;
+    value: string;
+}
+/** The dialog's inputs for every rule type, so switching types keeps what was typed. */
+export interface RuleDraft {
+    kind: RuleKind;
+    values: ValuesStyle;
+    scale2: PointDraft[];
+    scale3: PointDraft[];
+    barMin: PointDraft;
+    barMax: PointDraft;
+    barColor: string;
+    barGradient: boolean;
+    barBorder: boolean;
+    barBorderColor: string;
+    barOnly: boolean;
+    barDirection: 'context' | 'leftToRight' | 'rightToLeft';
+    iconSet: IconSetName;
+    iconReverse: boolean;
+    iconOnly: boolean;
+    /** The thresholds of the icons after the first, from the lowest. */
+    iconPoints: IconPointDraft[];
+    contain: ContainKind;
+    operator: Operator;
+    value1: string;
+    value2: string;
+    textOp: TextOp;
+    text: string;
+    period: Period;
+    top: boolean;
+    rank: string;
+    percent: boolean;
+    average: AverageKind;
+    unique: boolean;
+    formula: string;
+    style: ConditionalStyle;
+}
+/** A new rule's inputs, as Excel's dialog opens: a two-color scale from orange to yellow, the rest at Excel's defaults. */
+export declare function newDraft(): RuleDraft;
+/** A new set's thresholds, as Excel resets them when another icon style is picked. */
+export declare function pickIconSet(d: RuleDraft, set: IconSetName): void;
+/** The inputs as an existing rule fills them; `shown` gives a formula as the dialog shows it (relative to the active cell). */
+export declare function draftOf(rule: ConditionalFormat, shown: (formula: string) => string): RuleDraft;
+/** Why OK cannot write the rule: a box without a value, a formula that does not parse, a relative threshold, a number out of range. */
+export type DraftError = {
+    key: 'value';
+} | {
+    key: 'formula';
+    message?: string;
+} | {
+    key: 'relative';
+} | {
+    key: 'percent';
+} | {
+    key: 'rank';
+    max: number;
+};
+export type DraftResult = {
+    ok: true;
+    rule: ConditionalFormat;
+} | {
+    ok: false;
+    error: DraftError;
+};
+/** What OK needs besides the inputs: the rule's ranges, the locale, `xlcalc/entry`, and how a typed formula is written for the rule's first cell. */
+export interface DraftContext {
+    ranges: string[];
+    locale: Locale | undefined;
+    entry: Entry;
+    /** A formula typed relative to the active cell, rewritten for the rule's first cell. */
+    stored: (formula: string) => string;
+    /** The active cell's address, which a text rule's formula is typed for. */
+    active: string;
+}
+/** The rule OK writes from the inputs, or why it cannot; an edited rule keeps its Stop If True and the fields the dialog does not show. */
+export declare function ruleOf(d: RuleDraft, base: ConditionalFormat | null, c: DraftContext): DraftResult;
+/** A rule for the dialog's preview, from the inputs as they are: no thresholds checked, no formulas read. */
+export declare function previewOf(d: RuleDraft): ConditionalFormat;

package/dist/core/cf-formula.d.ts

@@ -0,0 +1,30 @@
+import type { ConditionalFormat, Locale, ScanOptions } from 'xlcalc/contract';
+import type { Entry } from '../entry.js';
+/** A formula with its relative references moved by `rows` and `cols`, as a copied formula's are; text in the scan's locale. */
+export declare function shiftFormula(formula: string, rows: number, cols: number, scan: ScanOptions): string;
+/** Whether a formula has a relative reference, which Excel does not allow in the thresholds of color scales, data bars and icon sets. */
+export declare function hasRelative(formula: string, scan: ScanOptions): boolean;
+/** A rule's own formulas (not its thresholds, which are absolute) passed through `fn`. */
+export declare function mapRuleFormulas(rule: ConditionalFormat, fn: (f: string) => string): ConditionalFormat;
+/** A rule with its formulas rewritten for a first cell `rows` and `cols` away, so each cell keeps its condition. */
+export declare const shiftRule: (rule: ConditionalFormat, rows: number, cols: number, scan: ScanOptions) => ConditionalFormat;
+/** What a value box gives: the formula to store (in the locale, without `=`), or the reason it cannot be stored. */
+export type BoxFormula = {
+    ok: true;
+    formula: string;
+} | {
+    ok: false;
+    message?: string;
+};
+/**
+ * A value box's text as Excel's dialogs store it: a formula after `=` (checked as a cell's), a number, date, time or
+ * percentage as its number, TRUE or FALSE, otherwise text in quotes. Empty text is refused.
+ */
+export declare function boxFormula(text: string, entry: Entry, locale: Locale | undefined): BoxFormula;
+/**
+ * The formula Excel writes for a text rule whose text is a reference or a formula (`=$A$1`), over the cell `at`: SEARCH for
+ * contains and does not contain, LEFT and RIGHT for begins and ends with. A text constant needs none: xlcalc writes Excel's.
+ */
+export declare function textRuleFormula(type: 'containsText' | 'notContainsText' | 'beginsWith' | 'endsWith', ref: string, at: string, locale: Locale | undefined): string;
+/** The scan options of a locale: stored text without one. */
+export declare const scanOf: (locale: Locale | undefined) => ScanOptions;

package/dist/core/cf-presets.d.ts

@@ -0,0 +1,33 @@
+import type { ColorScaleFormat, ConditionalFormat, ConditionalStyle, DataBarFormat, IconSetFormat, IconSetName, TimePeriodFormat } from 'xlcalc/contract';
+import type { ColorScalePreset, DataBarColor, QuickRule } from '../contract/conditional.js';
+/** The formats of the quick dialogs' "with" box, in its order; Custom Format follows them. */
+export type StylePreset = 'lightRedDarkRed' | 'yellowDarkYellow' | 'greenDarkGreen' | 'lightRed' | 'redText' | 'redBorder';
+export declare const STYLE_PRESETS: readonly StylePreset[];
+/** The colors of Excel's Bad, Neutral and Good cell styles, which the presets use, as Excel writes them to a file's dxf. */
+export declare const PRESET_STYLES: Readonly<Record<StylePreset, ConditionalStyle>>;
+/** The colors of Excel's data bar gallery, the same for its gradient and solid fills. */
+export declare const DATA_BAR_COLORS: Readonly<Record<DataBarColor, string>>;
+/** Excel 2010's data bar: automatic bounds, red negative bars, a black axis; a gradient bar has a border of its own color. */
+export declare function dataBarRule(ranges: string[], color: DataBarColor, fill?: 'gradient' | 'solid'): DataBarFormat;
+/** The color scales of Excel's gallery, their colors from the lowest number to the highest. */
+export declare const COLOR_SCALES: Readonly<Record<ColorScalePreset, readonly string[]>>;
+/** A gallery color scale: the lowest and the highest number, and between them the 50th percentile of a three-color one. */
+export declare function colorScaleRule(ranges: string[], preset: ColorScalePreset): ColorScaleFormat;
+/** The number of icons in a set, which its name begins with. */
+export declare const iconCount: (set: IconSetName) => number;
+/** Excel's thresholds for an icon set: equal shares in percent (0, 33, 67 for three icons; 0, 25, 50, 75 for four; 0, 20, 40, 60, 80 for five). */
+export declare function iconSetRule(ranges: string[], icons: IconSetName): IconSetFormat;
+/** What a quick dialog was given: its boxes' formulas (stored, in the locale), the text or its formula, the period, Duplicate or Unique, the rank. */
+export interface QuickInput {
+    formulas?: string[];
+    text?: string;
+    textFormula?: string;
+    period?: TimePeriodFormat['period'];
+    unique?: boolean;
+    rank?: number;
+    style: ConditionalStyle;
+}
+/** The rule a quick dialog writes over `ranges`. */
+export declare function quickRuleOf(kind: QuickRule, ranges: string[], q: QuickInput): ConditionalFormat;
+/** The quick rules whose dialog has a rank box, with its largest value: 1,000 items or 100 percent. */
+export declare const rankMax: (kind: QuickRule) => number | null;

package/dist/core/cf-ranges.d.ts

@@ -0,0 +1,22 @@
+import type { CellRect, ConditionalFormat } from 'xlcalc/contract';
+/** The rectangles of a rule's ranges; a range that does not parse is left out. */
+export declare const rectsOf: (ranges: readonly string[]) => CellRect[];
+/** The top-left cell of the rectangle enclosing the ranges, which a rule's formulas are written for; null without ranges. */
+export declare function topLeftOf(ranges: readonly string[]): {
+    row: number;
+    col: number;
+} | null;
+/** Whether a rule applies to a cell of the rectangle, as the Rules Manager's Current Selection lists it. */
+export declare const ruleMeets: (rule: ConditionalFormat, rect: CellRect) => boolean;
+/** What is left of a rectangle with `cut` taken out: the rows above and below it across its width, then the parts to its left and right. */
+export declare function subtract(r: CellRect, cut: CellRect): CellRect[];
+/**
+ * Clear Rules from Selected Cells: each rule loses the cells of `cut` and keeps the rest of its ranges, and a rule with no
+ * cells left is removed. A rule whose first cell moved has its formulas rewritten for the new one (`shift`), so each cell
+ * left keeps the condition it had. Null when no rule applies to the selection.
+ */
+export declare function clearRulesIn(rules: readonly ConditionalFormat[], cut: CellRect, shift: (rule: ConditionalFormat, rows: number, cols: number) => ConditionalFormat): ConditionalFormat[] | null;
+/** The "Applies to" box's text: `=` and the ranges, separated by the locale's list separator (`,` in en-US, `;` in ru-RU). */
+export declare const appliesText: (ranges: readonly string[], separator: string) => string;
+/** The ranges typed into "Applies to", with or without `=` and `$`, on this sheet or naming it; null for anything else. */
+export declare function parseApplies(text: string, separator: string, sheet: string): string[] | null;

package/dist/core/commands.d.ts

@@ -1,5 +1,6 @@
 import type { CellStyle } from 'xlcalc/contract';
 import type { EditOutcome, LayoutChange, OutlineChange, SheetOp } from '../contract/source.js';
+import type { TableOp } from '../contract/workbook.js';
 import type { Editing } from './editing.js';
 import type { FreezeMode, SheetFormatPatch } from '../contract/view.js';
 import type { Selection } from './selection.js';
@@ -29,7 +30,7 @@ export interface CommandsDeps {
     structured: () => void;
 }
 /** The source's methods that change the workbook beyond cells. */
-type ChangeMethod = 'format' | 'structure' | 'layout' | 'outline' | 'freeze';
+type ChangeMethod = 'format' | 'structure' | 'layout' | 'outline' | 'freeze' | 'table';
 export declare function useCommands(s: SheetState, sel: Selection, ed: Editing, deps: CommandsDeps): {
     can: (name: ChangeMethod) => boolean;
     canRanges: import("vue").ComputedRef<boolean>;
@@ -37,8 +38,9 @@ export declare function useCommands(s: SheetState, sel: Selection, ed: Editing,
     structure: (op: SheetOp, endsCopy?: boolean) => Promise<EditOutcome | null>;
     layout: (edit: LayoutChange) => Promise<EditOutcome | null>;
     outline: (command: OutlineChange) => Promise<EditOutcome | null>;
+    table: (op: TableOp) => Promise<EditOutcome | null>;
     freeze: (mode?: FreezeMode) => Promise<EditOutcome | null>;
-    fontKey: (e: KeyboardEvent) => boolean;
+    formatKey: (e: KeyboardEvent) => boolean;
     formatOpen: import("vue").Ref<boolean, boolean>;
     openFormat: () => boolean;
     closeFormat: () => void;

package/dist/core/editing.d.ts

@@ -36,6 +36,9 @@ export interface EditingDeps {
     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>;
+    /** The defined names visible on the sheet, in alphabetical order, and their order, for Formula AutoComplete; none without it. */
+    names?: () => readonly string[];
+    nameOrder?: (a: string, b: string) => number;
 }
 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;
@@ -49,12 +52,14 @@ export declare function useEditing(s: SheetState, w: Windows, sel: Selection, f:
         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: Ref<number, number>;
         open: import("vue").ComputedRef<boolean>;
         update: (text: string, caret: number | null) => void;

package/dist/core/extras.d.ts

@@ -0,0 +1,22 @@
+import type { CellRect } from 'xlcalc/contract';
+import type { EditOutcome } from '../contract/source.js';
+import type { ClearKind } from '../contract/workbook.js';
+import type { Editing } from './editing.js';
+import type { Selection } from './selection.js';
+import type { SheetState } from './state.js';
+import type { Windows } from './windows.js';
+export interface ExtrasDeps {
+    notify: (text: string) => void;
+    /** A change succeeded that may have changed the cells' rules too (Clear All removes data validation). */
+    changed: () => void;
+}
+/** The source's methods for what cells hold beside their values. */
+type ExtraMethod = 'clear' | 'link' | 'note';
+export declare function useExtras(s: SheetState, sel: Selection, w: Windows, ed: Editing, deps: ExtrasDeps): {
+    method: <K extends ExtraMethod>(name: K) => NonNullable<import("../index.js").SheetSource[K]> | null;
+    change: (call: () => Promise<EditOutcome>, sheet: string, ranges: string[]) => Promise<EditOutcome>;
+    locked: (rect: CellRect | null) => boolean;
+    clear: (what: ClearKind) => Promise<EditOutcome | null>;
+};
+export type Extras = ReturnType<typeof useExtras>;
+export {};

package/dist/core/fill.d.ts

@@ -1,5 +1,6 @@
 import { type Ref } from 'vue';
 import type { CellRect } from 'xlcalc/contract';
+import type { EditOutcome } from '../contract/source.js';
 import type { Commands } from './commands.js';
 import type { Editing, EditorState } from './editing.js';
 import type { Geometry } from './geometry.js';
@@ -38,5 +39,7 @@ export declare function useFill(s: SheetState, geo: Geometry, v: Viewport, sel:
     onUp: (e: PointerEvent) => void;
     onCancel: () => void;
     autofill: () => Promise<void>;
+    fillFrom: (direction: "down" | "right") => Promise<EditOutcome | null>;
+    key: (e: KeyboardEvent) => boolean;
 };
 export type Fill = ReturnType<typeof useFill>;

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

@@ -0,0 +1,10 @@
+import type { Formula } from './formula.js';
+import type { SheetState } from './state.js';
+import type { CellData } from './windows.js';
+export declare function useFormulaView(s: SheetState, f: Formula): {
+    read: () => void;
+    show: (on?: boolean) => boolean;
+    key: (e: KeyboardEvent) => boolean;
+    textOf: (data: CellData) => string;
+};
+export type FormulaView = ReturnType<typeof useFormulaView>;

package/dist/core/geometry.d.ts

@@ -6,6 +6,8 @@ export declare const MAX_COL_PX = 900;
 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;
+/** How much wider Excel draws columns under Show Formulas. */
+export declare const FORMULA_VIEW_SCALE = 2;
 /** 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. */
@@ -29,6 +31,8 @@ interface GeometryInput {
     /** 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>;
+    /** Excel's Show Formulas: columns are drawn twice as wide, and the stored widths stay as they are. */
+    formulaView?: Readonly<Ref<boolean>>;
     /** 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. */
@@ -38,6 +42,8 @@ interface GeometryInput {
 /** 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;
+    baseWidthOf: (c: number) => number;
+    widthScale: () => number;
     heightOf: (d: number) => number;
     offsets: import("vue").ComputedRef<Float64Array<ArrayBufferLike>>;
     setHeights: (rows: Iterable<readonly [number, number | undefined]>) => boolean;

package/dist/core/goto.d.ts

@@ -0,0 +1,24 @@
+import type { AlertAnswer, SheetAlert } from './validation.js';
+import type { Names } from './names.js';
+import type { Navigation } from './navigation.js';
+import type { Selection } from './selection.js';
+import type { SheetState } from './state.js';
+/** How many locations the Go To list keeps, as Excel's does. */
+export declare const GOTO_PLACES = 4;
+/** A reference made absolute part by part, as Excel lists locations in Go To: `B2:D5` → `$B$2:$D$5`, `B:D` → `$B:$D`. */
+export declare function absoluteRef(ref: string): string;
+export interface GoToDeps {
+    ask: (alert: SheetAlert) => Promise<AlertAnswer>;
+    names: Names;
+}
+export declare function useGoTo(s: SheetState, sel: Selection, nav: Navigation, deps: GoToDeps): {
+    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;
+};
+export type GoTo = ReturnType<typeof useGoTo>;

package/dist/core/links.d.ts

@@ -0,0 +1,105 @@
+import type { SheetLinkEvent } from '../contract/view.js';
+import type { SheetWindow } from '../contract/source.js';
+import type { SheetLink } from '../contract/workbook.js';
+import type { Editing } from './editing.js';
+import type { Extras } from './extras.js';
+import type { Formula } from './formula.js';
+import type { MenuItem } from './menu.js';
+import type { Selection } from './selection.js';
+import type { SheetState } from './state.js';
+import type { Windows } from './windows.js';
+/** Excel's Link to: an address outside the workbook, or a place in it. */
+export type LinkTab = 'file' | 'place';
+/** A place in this document the dialog lists: a sheet, with the reference typed for it, or a defined name, which is the place itself. */
+export interface LinkPlace {
+    key: string;
+    label: string;
+}
+/** The dialog's list under its headings: Cell Reference (the sheets) and Defined Names. */
+export interface LinkPlaceGroup {
+    kind: 'sheets' | 'names';
+    label: string;
+    places: LinkPlace[];
+}
+/** The open dialog: what it links (the selection), its fields, and the link it edits (Edit Hyperlink). */
+export interface LinkDraft {
+    sheet: string;
+    range: string;
+    cell: string;
+    /** The link of the active cell when there is one: the dialog is then Edit Hyperlink, with Remove Link. */
+    old: SheetLink | null;
+    tab: LinkTab;
+    /** Text to Display: editable for a single cell without a formula; `null` shows Excel's `<<Selection in Document>>`. */
+    text: string | null;
+    /** The cell's displayed text when the dialog opened: the text is written only when it changed. */
+    shown: string;
+    /** The text was typed in: until then, for an empty cell, it follows the address as Excel's does. */
+    textTyped: boolean;
+    address: string;
+    ref: string;
+    place: string;
+    tooltip: string;
+    error: string;
+}
+export interface LinksDeps {
+    notify: (text: string) => void;
+    /** Whether the selection is the active cell alone, or the merged range it is in. */
+    single: () => boolean;
+    /** Goes to a location or a defined name, as a click on a hyperlink does. */
+    goPlace: (text: string) => Promise<boolean>;
+    /** The workbook's defined names that refer to ranges, for Place in This Document. */
+    names: () => string[];
+    /** Whether the host opens links through `openLink`, and the event to it. */
+    hostLinks: () => boolean;
+    openLink: (link: SheetLinkEvent) => void;
+}
+export declare function useLinks(s: SheetState, sel: Selection, w: Windows, f: Formula, ed: Editing, extras: Extras, deps: LinksDeps): {
+    draft: import("vue").Ref<{
+        sheet: string;
+        range: string;
+        cell: string;
+        old: {
+            href?: string | undefined;
+            location?: string | undefined;
+            tooltip?: string | undefined;
+        } | null;
+        tab: LinkTab;
+        text: string | null;
+        shown: string;
+        textTyped: boolean;
+        address: string;
+        ref: string;
+        place: string;
+        tooltip: string;
+        error: string;
+    } | null, LinkDraft | {
+        sheet: string;
+        range: string;
+        cell: string;
+        old: {
+            href?: string | undefined;
+            location?: string | undefined;
+            tooltip?: string | undefined;
+        } | null;
+        tab: 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<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: () => MenuItem[];
+};
+export type Links = ReturnType<typeof useLinks>;

package/dist/core/menu.d.ts

@@ -56,6 +56,14 @@ export interface MenuDeps {
     explain: Explain;
     /** Whether the workbook freezes panes on the displayed sheet: the first freeze item is then Unfreeze Panes, as in Excel. */
     frozen: () => boolean;
+    /** Excel's Define Name in the cell menu: offered where names can be defined. */
+    defineName?: {
+        available: () => boolean;
+        run: () => void;
+    };
+    /** The cell menu's items for notes and for hyperlinks, which Excel lists before and after Define Name at the menu's end. */
+    cellNotes: () => MenuItem[];
+    cellLinks: () => MenuItem[];
 }
 export declare function useMenu(s: SheetState, sel: Selection, cmd: Commands, deps: MenuDeps): {
     open: import("vue").ShallowRef<OpenMenu | null, OpenMenu | null>;

package/dist/core/name-dialogs.d.ts

@@ -0,0 +1,63 @@
+import type { SheetName } from '../contract/workbook.js';
+import { type Names } from './names.js';
+import type { Selection } from './selection.js';
+import type { SheetState } from './state.js';
+/** The New Name or Edit Name dialog's fields: the name, its scope (a sheet's name, '' for the workbook) and Refers to, with `=`. */
+export interface NameDraft {
+    /** The name being edited, by its key; null for a new one. */
+    editing: string | null;
+    name: string;
+    scope: string;
+    ref: string;
+}
+/** The Name Manager's state: the selected name by its key, and Refers to as edited in the box at the bottom (null: unchanged). */
+export interface NameManagerState {
+    selected: string | null;
+    ref: string | null;
+}
+/** An alert over the dialogs: a refusal (OK), the question before a deletion (OK, Cancel), before closing with an edited reference (Yes, No). */
+export interface NameAsk {
+    kind: 'refused' | 'delete' | 'save';
+    message: string;
+}
+export declare function useNameDialogs(s: SheetState, sel: Selection, names: Names, deps: {
+    editing: () => boolean;
+}): {
+    draft: import("vue").Ref<{
+        editing: string | null;
+        name: string;
+        scope: string;
+        ref: string;
+    } | null, NameDraft | {
+        editing: string | null;
+        name: string;
+        scope: string;
+        ref: string;
+    } | null>;
+    manager: import("vue").Ref<{
+        selected: string | null;
+        ref: string | null;
+    } | null, NameManagerState | {
+        selected: string | null;
+        ref: string | null;
+    } | null>;
+    ask: import("vue").ShallowRef<NameAsk | null, NameAsk | null>;
+    answer: (yes: boolean) => void;
+    busy: import("vue").Ref<boolean, boolean>;
+    rows: import("vue").ComputedRef<SheetName[]>;
+    selected: import("vue").ComputedRef<SheetName | null>;
+    refText: import("vue").ComputedRef<string>;
+    refChanged: import("vue").ComputedRef<boolean>;
+    define: () => boolean;
+    openManager: () => boolean;
+    select: (n: SheetName) => void;
+    edit: () => void;
+    submit: () => Promise<void>;
+    closeDraft: () => void;
+    remove: () => Promise<void>;
+    editRef: (text: string) => void;
+    commitRef: () => Promise<boolean>;
+    cancelRef: () => void;
+    closeManager: () => Promise<void>;
+};
+export type NameDialogs = ReturnType<typeof useNameDialogs>;