@xlcalc/vue 0.21.2 → 0.23.1

package/dist/core/state.d.ts

@@ -20,6 +20,11 @@ export declare function createState(props: SheetViewProps): {
     active: import("vue").Ref<number, number>;
     sheet: import("vue").ComputedRef<SheetInfo | null>;
     sheetName: import("vue").ComputedRef<string>;
+    defaultFont: import("vue").ComputedRef<{
+        name: string;
+        size: number;
+    } | null>;
+    defaultFontStyle: import("vue").ComputedRef<Record<string, string> | null>;
     grown: import("vue").Ref<{
         rows: number;
         cols: number;
@@ -64,6 +69,7 @@ export declare function createState(props: SheetViewProps): {
     failureOf: (error: unknown) => SheetFailure;
     loading: import("vue").Ref<boolean, boolean>;
     scroller: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+    zoom: import("vue").Ref<number, number>;
     scrollTop: import("vue").Ref<number, number>;
     scrollLeft: import("vue").Ref<number, number>;
     viewH: import("vue").Ref<number, number>;
@@ -72,6 +78,7 @@ export declare function createState(props: SheetViewProps): {
     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>;
+    formulaView: import("vue").Ref<boolean, boolean>;
     selected: import("vue").Ref<{
         row: number;
         col: number;
@@ -96,6 +103,8 @@ export declare function createState(props: SheetViewProps): {
     hooks: {
         unfilter: (_row: number) => void;
         changing: () => void;
+        stepped: () => void;
+        changed: () => void;
     };
     focusGrid: () => void;
     scrollGridTo: (top: number, left: number) => void;

package/dist/core/tables.d.ts

@@ -0,0 +1,63 @@
+import type { CellPosition, CellRect } from 'xlcalc/contract';
+import type { EditOutcome } from '../contract/source.js';
+import type { Commands } from './commands.js';
+import type { Selection } from './selection.js';
+import { type SheetState } from './state.js';
+import type { Windows } from './windows.js';
+/** The Create Table dialog: the range as typed (`=$A$1:$C$5`), My table has headers, and the reason the range was refused; or Convert to Range's question. */
+export type TableDialog = {
+    kind: 'create';
+    sheet: string;
+    draft: string;
+    headers: boolean;
+    error: string;
+} | {
+    kind: 'convert';
+    sheet: string;
+    table: string;
+};
+/** A range as Excel's Create Table box writes it: absolute, after `=` (`=$A$1:$C$5`). */
+export declare const absoluteRange: (r: CellRect) => string;
+/**
+ * Excel's current region around a cell (`Range.CurrentRegion`): the range grown, a row or column at a time, while the row or
+ * column just outside it, corners included, has a non-empty cell. `filled` answers within `area`; cells outside it count as empty.
+ */
+export declare function currentRegion(at: CellPosition, area: CellRect, filled: (row: number, col: number) => boolean): CellRect;
+/**
+ * Column names from the header cells' text, as Excel names them: an empty header `Column1` (the first number no other column
+ * uses), a name another column to the left already has with the next free number (`Qty`, `Qty2`), compared case-insensitively.
+ */
+export declare function columnNames(headers: string[], prefix: string): string[];
+export declare function useTables(s: SheetState, w: Windows, sel: Selection, cmd: Commands): {
+    available: import("vue").ComputedRef<boolean>;
+    canInsertHeader: import("vue").ComputedRef<boolean>;
+    activeTable: import("vue").ComputedRef<import("./windows.js").SheetTable | null>;
+    dialog: import("vue").Ref<{
+        kind: "create";
+        sheet: string;
+        draft: string;
+        headers: boolean;
+        error: string;
+    } | {
+        kind: "convert";
+        sheet: string;
+        table: string;
+    } | null, TableDialog | {
+        kind: "create";
+        sheet: string;
+        draft: string;
+        headers: boolean;
+        error: string;
+    } | {
+        kind: "convert";
+        sheet: string;
+        table: string;
+    } | null>;
+    openCreate: () => Promise<boolean>;
+    create: () => Promise<EditOutcome | null>;
+    convert: () => Promise<EditOutcome | null>;
+    remove: () => Promise<EditOutcome | null>;
+    close: (yes?: boolean) => void;
+    key: (e: KeyboardEvent) => boolean;
+};
+export type Tables = ReturnType<typeof useTables>;

package/dist/core/trace.d.ts

@@ -0,0 +1,26 @@
+import type { CellPosition } from 'xlcalc/contract';
+import { type SheetState } from './state.js';
+import type { Viewport } from './viewport.js';
+import type { Windows } from './windows.js';
+/** An arrow from a cell to its dependent on the sheet, or to the worksheet icon for dependents on other sheets (`to` null). */
+export interface TraceArrow {
+    from: CellPosition;
+    to: CellPosition | null;
+}
+/** An arrow as drawn, in the scroller's content coordinates: blue, red from a cell with an error, dashed to the worksheet icon; `frozen` when an end is in frozen panes. */
+export interface DrawnArrow {
+    key: string;
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    kind: 'cell' | 'error' | 'sheet';
+    frozen: boolean;
+}
+export declare function useTrace(s: SheetState, v: Viewport, w: Windows, notify: (text: string) => void): {
+    available: import("vue").ComputedRef<boolean>;
+    drawn: import("vue").ComputedRef<DrawnArrow[]>;
+    traceDependents: () => Promise<boolean>;
+    removeArrows: () => boolean;
+};
+export type Trace = ReturnType<typeof useTrace>;

package/dist/core/validation-dialog.d.ts

@@ -0,0 +1,33 @@
+import type { CellPosition, CellRect, DataValidation, ScanOptions } from 'xlcalc/contract';
+import { type RuleSettings, type RuleText, type ValidationDraft } from '../validation-rules.js';
+import type { Selection } from './selection.js';
+import { type SheetState } from './state.js';
+import type { AlertAnswer, SheetAlert } from './validation.js';
+import type { Windows } from './windows.js';
+export interface ValidationDialogDeps {
+    /** How the workbook's formula text is parsed; null while its locale loads. */
+    scan: () => ScanOptions | null;
+    ask: (alert: SheetAlert) => Promise<AlertAnswer>;
+    notify: (text: string) => void;
+    /** The active cell's rule changed: its dropdown and input message are requested again. */
+    changed: () => void;
+}
+/** The open dialog: the selection and active cell it was opened for, the sheet's rules then, the rule shown, and its first inputs. */
+export interface ValidationDialogState {
+    sheet: string;
+    sel: CellRect;
+    at: CellPosition;
+    rules: DataValidation[];
+    /** The rule whose settings the dialog opened with; null for Excel's defaults. */
+    shown: DataValidation | null;
+    draft: ValidationDraft;
+    text: RuleText;
+}
+export declare function useValidationDialog(s: SheetState, sel: Selection, w: Windows, deps: ValidationDialogDeps): {
+    state: import("vue").ShallowRef<ValidationDialogState | null, ValidationDialogState | null>;
+    available: () => boolean;
+    open: () => boolean;
+    close: () => void;
+    apply: (rule: RuleSettings | null, applyAll: boolean) => Promise<string | null>;
+};
+export type ValidationDialog = ReturnType<typeof useValidationDialog>;

package/dist/core/validation.d.ts

@@ -74,8 +74,22 @@ export interface ParenthesisAlert {
     sheet: string;
     cell: string;
 }
-/** What the alert displays: a rule's rejection, the prompt for a formula, Excel's correction of one and what is missing, or the warning before a merge. */
-export type SheetAlert = SheetValidationAlert | FormulaAlert | TypoAlert | ParenthesisAlert | MergeAlert;
+/** Excel's message with OK alone over a dialog, such as Go To's for a bad reference. */
+export interface NoticeAlert {
+    severity: 'notice';
+    title?: undefined;
+    message: string;
+}
+/** Excel's questions before Data Validation opens: rules of more than one kind in the selection (OK erases them, Cancel), or cells without the rule (Yes extends it, No starts afresh, Cancel). */
+export interface RulesAlert {
+    severity: 'rulesMany' | 'rulesExtend';
+    title?: undefined;
+    message: string;
+    sheet: string;
+    cell: string;
+}
+/** What the alert displays: a rule's rejection, the prompt for a formula, Excel's correction of one and what is missing, the warning before a merge, a dialog's message, or Data Validation's questions. */
+export type SheetAlert = SheetValidationAlert | FormulaAlert | TypoAlert | ParenthesisAlert | MergeAlert | NoticeAlert | RulesAlert;
 /** What the user's answer to an alert does with the rejected edit: send it again with `accept`, reopen the editor with the text, or leave the cell unchanged. */
 export type AlertAnswer = 'accept' | 'retry' | 'cancel';
 export type AlertButton = 'retry' | 'cancel' | 'yes' | 'no' | 'ok' | 'fix' | 'revert';
@@ -84,7 +98,7 @@ export declare const ALERT_BUTTONS: Record<SheetAlert['severity'], {
     button: AlertButton;
     answer: AlertAnswer;
 }[]>;
-/** The button an alert opens with, which Enter presses: Retry, No (a warning keeps a value only on a click on Yes), OK; Yes for Excel's correction. */
+/** The button an alert opens with, which Enter presses: Retry, No (a warning keeps a value only on a click on Yes), OK; Yes for Excel's correction and for extending a rule. */
 export declare const ALERT_DEFAULT: Record<SheetAlert['severity'], AlertButton>;
 /** The alert for a rejected value: shown until the user answers; one at a time, and a new one answers the old one with Cancel. */
 export declare function useValidationAlert(): {

package/dist/core/viewport.d.ts

@@ -14,10 +14,13 @@ interface ViewportInput {
     scrollLeft: Ref<number>;
     viewH: Ref<number>;
     viewW: Ref<number>;
+    zoom: Ref<number>;
     memory: Memory;
 }
 export declare function useViewport(i: ViewportInput, geo: Geometry): {
     showNums: ComputedRef<boolean>;
+    line: ComputedRef<number>;
+    lineOf: (px: number) => number;
     narrow: ComputedRef<boolean>;
     touch: ComputedRef<boolean>;
     numW: ComputedRef<number>;
@@ -78,6 +81,15 @@ export declare function useViewport(i: ViewportInput, geo: Geometry): {
         x: number;
         y: number;
     };
+    cellAtPoint: (clientX: number, clientY: number, box: {
+        left: number;
+        top: number;
+    }) => {
+        d: number;
+        col: number;
+        x: number;
+        y: number;
+    };
 };
 export type Viewport = ReturnType<typeof useViewport>;
 export {};

package/dist/core/watch.d.ts

@@ -0,0 +1,35 @@
+import type { SheetWatch } from '../contract/view.js';
+import type { Navigation } from './navigation.js';
+import type { Selection } from './selection.js';
+import type { SheetState } from './state.js';
+/** At most this many cells are watched; Add Watch over a larger selection adds its first cells. */
+export declare const WATCH_MAX = 1000;
+/** What a watched cell shows: its displayed value and its formula with `=`; null while it is read, or when its sheet is gone. */
+export interface WatchShown {
+    value: string;
+    formula: string;
+}
+interface WatchDeps {
+    /** The host's list (`SheetView`'s `watches`). */
+    given: () => SheetWatch[] | undefined;
+    /** The user changed the list: the `watches` event. */
+    changed: (list: SheetWatch[]) => void;
+    notify: (text: string) => void;
+}
+export declare function useWatch(s: SheetState, sel: Selection, nav: Navigation, deps: WatchDeps): {
+    list: import("vue").ShallowRef<SheetWatch[], SheetWatch[]>;
+    open: import("vue").Ref<boolean, boolean>;
+    chosen: import("vue").ShallowRef<Set<number>, Set<number>>;
+    valueOf: (w: SheetWatch) => WatchShown | null;
+    add: () => void;
+    remove: () => void;
+    choose: (i: number, how?: {
+        add?: boolean;
+        range?: boolean;
+    }) => void;
+    go: (i: number) => Promise<void>;
+    setOpen: (on?: boolean) => boolean;
+    canAdd: import("vue").ComputedRef<boolean>;
+};
+export type Watch = ReturnType<typeof useWatch>;
+export {};

package/dist/core/windows.d.ts

@@ -75,6 +75,8 @@ export declare function useWindows(s: SheetState, v: Viewport, geo: Geometry): {
         style?: CellStyle;
         numberFormat?: string;
     } | null;
+    linkOfRow: (r: number, col: number) => CellData["link"];
+    noteOfRow: (r: number, col: number) => CellData["note"];
     merges: import("vue").ComputedRef<CellRect[]>;
     tables: import("vue").ComputedRef<SheetTable[]>;
     notice: import("vue").ComputedRef<string>;

package/dist/core/zoom.d.ts

@@ -0,0 +1,44 @@
+import type { Selection } from './selection.js';
+import type { SheetState } from './state.js';
+import type { Viewport } from './viewport.js';
+export declare const MIN_ZOOM = 10;
+export declare const MAX_ZOOM = 400;
+/** A notch of Ctrl+wheel zooms by 15%. */
+export declare const WHEEL_STEP = 15;
+/** The status bar's − and + go to the next multiple of 10%. */
+export declare const BUTTON_STEP = 10;
+/** A zoom in whole percent within Excel's limits. */
+export declare const clampZoom: (pct: number) => number;
+/** The status bar's − and +: the next multiple of 10% below or above. */
+export declare const stepZoom: (pct: number, dir: 1 | -1) => number;
+/** Excel's zoom slider: its left half covers 10% to 100%, its right half 100% to 400%, so 100% is at the middle (`pos` 0 to 100). */
+export declare const zoomOfSlider: (pos: number) => number;
+export declare const sliderOfZoom: (pct: number) => number;
+interface ZoomDeps {
+    /** The host's zooms by sheet name (`SheetView`'s `zoom`). */
+    given: () => Record<string, number> | undefined;
+    /** The user changed a sheet's zoom: the `zoom` event. */
+    changed: (sheet: string, zoom: number) => void;
+}
+export declare function useZoom(s: SheetState, v: Viewport, sel: Selection, deps: ZoomDeps): {
+    percent: import("vue").ComputedRef<number>;
+    apply: (pct: number, focus?: {
+        x: number;
+        y: number;
+    }) => number;
+    choose: (pct: number) => number;
+    fitSelection: (user?: boolean) => number;
+    enter: () => void;
+    onWheel: (e: WheelEvent) => void;
+    onTouchStart: (e: TouchEvent) => void;
+    onTouchMove: (e: TouchEvent) => void;
+    onTouchEnd: (e: TouchEvent) => void;
+    onGesture: (e: Event & {
+        scale?: number;
+        clientX?: number;
+        clientY?: number;
+    }) => void;
+    dialogOpen: import("vue").Ref<boolean, boolean>;
+};
+export type Zoom = ReturnType<typeof useZoom>;
+export {};

package/dist/format-cells.d.ts

@@ -7,8 +7,6 @@ type Horizontal = NonNullable<AlignmentStyle['horizontal']>;
 type Vertical = NonNullable<AlignmentStyle['vertical']>;
 export declare const HORIZONTALS: readonly Horizontal[];
 export declare const VERTICALS: readonly Vertical[];
-/** Excel's indent applies with the left, right and distributed alignments. */
-export declare const INDENTED: ReadonlySet<string>;
 /** The line styles Excel's Border tab offers, in the order of its list. */
 export declare const LINE_STYLES: readonly BorderLine['style'][];
 type FontStyleKind = 'regular' | 'italic' | 'bold' | 'boldItalic';
@@ -16,10 +14,6 @@ type Underline = 'none' | NonNullable<FontStyle['underline']>;
 /** The font styles and underlines in the order of Excel's lists. */
 export declare const FONT_STYLES: readonly FontStyleKind[];
 export declare const UNDERLINES: readonly Underline[];
-/** Excel's font sizes in its list; any size from 1 to 409 may be typed. */
-export declare const FONT_SIZES: readonly number[];
-/** Fonts offered in the font input's list; any name may be typed. */
-export declare const FONT_NAMES: readonly string[];
 /** The dialog's inputs; text inputs hold what is typed until OK parses them. */
 export interface FormatDraft {
     /** The code the cells are displayed with: an item's from Excel's list, or a typed one (the box names its category). */

package/dist/formula-shift.d.ts

@@ -0,0 +1,3 @@
+import type { ScanOptions } from 'xlcalc/contract';
+/** `formula` (in the locale `opts` parses) with its relative references moved `rows` down and `cols` right; absolute parts, names and table references stay. */
+export declare function shiftFormula(formula: string, rows: number, cols: number, opts: ScanOptions): string;