@xlcalc/vue 0.0.0-stage → 0.21.2

package/dist/core/state.d.ts

@@ -0,0 +1,107 @@
+import type { CellPosition } from 'xlcalc/contract';
+import type { SheetMessages } from '../contract/messages.js';
+import type { SheetFilter, SheetInfo, SheetSource } from '../contract/source.js';
+import type { SheetFailure, SheetViewProps } from '../contract/view.js';
+/** The source's methods by name, optional ones too. */
+export type SourceMethod = {
+    [K in keyof SheetSource]-?: NonNullable<SheetSource[K]> extends (...args: never[]) => unknown ? K : never;
+}[keyof SheetSource];
+export declare function createState(props: SheetViewProps): {
+    props: SheetViewProps;
+    source: () => SheetSource;
+    sourceMethod: <K extends SourceMethod>(name: K) => NonNullable<SheetSource[K]> | null;
+    outdated: () => () => boolean;
+    endWorkbook: () => undefined;
+    messages: import("vue").ComputedRef<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: SheetFilter;
+        rows: Int32Array;
+        index: Int32Array;
+    } | null, {
+        key: string;
+        spec: 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<SheetFailure | null, SheetFailure | null>;
+    failureOf: (error: unknown) => 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, CellPosition | {
+        row: number;
+        col: number;
+    } | null>;
+    extent: import("vue").Ref<{
+        row: number;
+        col: number;
+    } | null, CellPosition | {
+        row: number;
+        col: number;
+    } | null>;
+    anchor: import("vue").Ref<{
+        row: number;
+        col: number;
+    } | null, 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 SheetState = ReturnType<typeof createState>;
+/** Signals for reads of the displayed sheet (a series of windows): each new one aborts the previous, and so do another sheet and unmounting the sheet. */
+export declare function useSheetReads(s: SheetState): () => AbortSignal;

package/dist/core/storage.d.ts

@@ -0,0 +1,6 @@
+export interface Memory {
+    recall<T>(name: string): T | null;
+    remember(name: string, value: unknown): void;
+}
+/** Storage over `localStorage` under `storageKey()`, or an in-memory map when the host provides no key. */
+export declare function createMemory(storageKey: () => string | undefined): Memory;

package/dist/core/totals.d.ts

@@ -0,0 +1,16 @@
+import type { Selection } from './selection.js';
+import type { SheetState } from './state.js';
+import type { Windows } from './windows.js';
+/** A selection's display rows: a run of them without a filter (an entire column is a million), otherwise the filter's list. */
+export type ShownRows = {
+    from: number;
+    to: number;
+} | number[];
+/** The rows as a list, for what needs each one (a copy's text). */
+export declare const listOf: (ds: ShownRows) => number[];
+export declare function useTotals(s: SheetState, w: Windows, sel: Selection): {
+    statsText: import("vue").ComputedRef<string>;
+    shownRows: (r1: number, r2: number) => ShownRows;
+    inWindows: (ds: ShownRows, c1: number, c2: number) => boolean;
+};
+export type Totals = ReturnType<typeof useTotals>;

package/dist/core/validation.d.ts

@@ -0,0 +1,95 @@
+import type { SheetSource, SheetValidation, SheetValidationAlert } from '../contract/source.js';
+/** How long the active cell stays before its rule is requested: holding an arrow key down a column requests once, at the end. */
+export declare const VALIDATION_DELAY_MS = 60;
+/** Items the list displays at once, as in Excel; Page Up and Page Down move by them. */
+export declare const LIST_ROWS = 8;
+export interface ValidationPlace {
+    sheet: string;
+    cell: string;
+}
+export interface ValidationDeps {
+    source: () => SheetSource;
+    sheet: () => string;
+    /** The active cell; null for none. */
+    active: () => {
+        row: number;
+        col: number;
+    } | null;
+    /** The active cell's displayed text: the list opens at the item equal to it. */
+    text?: () => string;
+    /** An item chosen from the list (a click, Enter), by its text and position in the list: the sheet enters it into the cell. */
+    pick: (text: string, place: ValidationPlace, item: number) => void;
+}
+/** The active cell's rule as Excel displays it: requested from the source once the cell stays, an older response discarded, and the list's state. */
+export declare function useValidation(deps: ValidationDeps): {
+    current: import("vue").ShallowRef<SheetValidation | null, SheetValidation | null>;
+    place: import("vue").ShallowRef<ValidationPlace | null, 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;
+};
+export type Validation = ReturnType<typeof useValidation>;
+/** The sheet's own prompt for a formula that cannot be parsed: Fix reopens the editor, Restore leaves the cell unchanged, so Enter or a click elsewhere is a way out. */
+export interface FormulaAlert {
+    severity: 'formula';
+    title?: undefined;
+    /** The source's reason. */
+    message: string;
+    sheet: string;
+    cell: string;
+}
+/** Excel's warning before cells containing more than one value are merged: OK merges, Cancel leaves them. */
+export interface MergeAlert {
+    severity: 'merge';
+    title?: undefined;
+    /** The warning's text. */
+    message: string;
+    sheet: string;
+    cell: string;
+}
+/** Excel's dialog for an unclosed formula that it offers to correct: Yes enters the correction, No (or Esc) says what is missing. */
+export interface TypoAlert {
+    severity: 'typo';
+    title?: undefined;
+    /** The question with the correction. */
+    message: string;
+    sheet: string;
+    cell: string;
+}
+/** Excel's message after No to a correction, with OK only: the editor reopens with the typed text. */
+export interface ParenthesisAlert {
+    severity: 'parenthesis';
+    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, or the warning before a merge. */
+export type SheetAlert = SheetValidationAlert | FormulaAlert | TypoAlert | ParenthesisAlert | MergeAlert;
+/** 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';
+/** Excel's alert buttons by style, in Excel's order, and the answer each gives (Help is omitted); the formula prompt's buttons after them. */
+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. */
+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(): {
+    alert: import("vue").ShallowRef<SheetAlert | null, SheetAlert | null>;
+    ask: (next: SheetAlert) => Promise<AlertAnswer>;
+    answer: (a: AlertAnswer) => void;
+};
+export type ValidationAlertState = ReturnType<typeof useValidationAlert>;

package/dist/core/viewport.d.ts

@@ -0,0 +1,83 @@
+import { type ComputedRef, type Ref } from 'vue';
+import type { SheetInfo } from '../contract/source.js';
+import type { Geometry } from './geometry.js';
+import type { Memory } from './storage.js';
+/** The height of the column letters row (fixed in CSS); frozen rows stick below it. */
+export declare const HEAD_H = 24;
+interface ViewportInput {
+    sheet: ComputedRef<SheetInfo | null>;
+    /** The display filter in effect: its rows are not the sheet's rows in order, so the row outline bar is not drawn. */
+    visible: Readonly<Ref<object | null>>;
+    rowCount: ComputedRef<number>;
+    colCount: ComputedRef<number>;
+    scrollTop: Ref<number>;
+    scrollLeft: Ref<number>;
+    viewH: Ref<number>;
+    viewW: Ref<number>;
+    memory: Memory;
+}
+export declare function useViewport(i: ViewportInput, geo: Geometry): {
+    showNums: ComputedRef<boolean>;
+    narrow: ComputedRef<boolean>;
+    touch: ComputedRef<boolean>;
+    numW: ComputedRef<number>;
+    outlineSlots: ComputedRef<{
+        rows: number;
+        cols: number;
+    }>;
+    slotPx: ComputedRef<16 | 22>;
+    barW: ComputedRef<number>;
+    barH: ComputedRef<number>;
+    headH: ComputedRef<number>;
+    footH: ComputedRef<0 | 24>;
+    leadW: ComputedRef<number>;
+    bookFreeze: ComputedRef<boolean>;
+    freezeOn: ComputedRef<boolean>;
+    readFreeze: () => boolean | null;
+    toggleFreeze: () => void;
+    showFreeze: (sheet: string, on: boolean) => void;
+    middlePanes: () => {
+        rows: number;
+        cols: number;
+    };
+    frozenRows: ComputedRef<number>;
+    frozenCols: ComputedRef<number>;
+    frozenH: ComputedRef<number>;
+    frozenW: ComputedRef<number>;
+    frozenRowList: ComputedRef<number[]>;
+    frozenColList: ComputedRef<number[]>;
+    stickyTop: (d: number) => string;
+    stickyLeft: (c: number) => string;
+    firstRow: ComputedRef<number>;
+    lastRow: ComputedRef<number>;
+    firstCol: ComputedRef<number>;
+    lastCol: ComputedRef<number>;
+    shownRows: ComputedRef<number[]>;
+    shownCols: ComputedRef<number[]>;
+    topPad: ComputedRef<number>;
+    bottomPad: ComputedRef<number>;
+    leftPad: ComputedRef<number>;
+    rightPad: ComputedRef<number>;
+    tableWidth: ComputedRef<number>;
+    boxOf: (d1: number, c1: number, d2: number, c2: number) => {
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+        frozen: boolean;
+    };
+    viewBox: ComputedRef<{
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+    }>;
+    cellAt: (px: number, py: number) => {
+        d: number;
+        col: number;
+        x: number;
+        y: number;
+    };
+};
+export type Viewport = ReturnType<typeof useViewport>;
+export {};

package/dist/core/windows.d.ts

@@ -0,0 +1,102 @@
+import { type ShallowRef } from 'vue';
+import type { CellRect, CellStyle, CellValue, ConditionalAppearance } from 'xlcalc/contract';
+import type { CellUpdate, SheetWindow } from '../contract/source.js';
+import { type Geometry } from './geometry.js';
+import type { SheetState } from './state.js';
+import type { Viewport } from './viewport.js';
+export type SlotKind = 'body' | 'top' | 'left';
+/** A window's range by display rows. */
+interface Area {
+    row: number;
+    rows: number;
+    col: number;
+    cols: number;
+}
+/** The pending request: its view and range (a repaint may overlap it), whether it re-reads a drawn window in place, and the changes that arrived meanwhile. */
+interface Asked extends Area {
+    view: string;
+    /** An on-screen window re-read for a repaint: it stays drawn meanwhile, so there is no loading indicator. */
+    quiet: boolean;
+    /** Cell updates that arrived while the request was pending: the response may have been read before them, so they are applied over it. */
+    missed: CellUpdate[];
+}
+/** One window: what is loaded, the pending request and the one already answered (so neither repeats). */
+export interface Slot {
+    /** The sheet and filter the window was requested under: another filter means other rows. */
+    view: string;
+    win: SheetWindow | null;
+    rows: number;
+    cols: number;
+    /** The window's merged ranges and the sheet's tables, read once when it arrives. */
+    merges: CellRect[];
+    tables: SheetTable[];
+    pendingKey: string;
+    servedKey: string;
+    ctrl: AbortController | null;
+    asked: Asked | null;
+    /** A repaint overlapped the window: it is re-read, drawn as is until the response arrives. */
+    stale: boolean;
+}
+/** A table of the sheet with its range parsed. */
+export type SheetTable = NonNullable<SheetWindow['tables']>[number] & {
+    rect: CellRect;
+};
+/** Everything a cell has in its window, for drawing it. */
+export interface CellData {
+    text: string;
+    value: CellValue | undefined;
+    style: CellStyle | undefined;
+    formula: string | undefined;
+    color: string | undefined;
+    link: NonNullable<SheetWindow['links']>[string] | undefined;
+    note: NonNullable<SheetWindow['notes']>[string] | undefined;
+    /** The cell's conditional formatting. */
+    look: ConditionalAppearance | undefined;
+    /** A list mode drill-down: marked in its window's `drill` and not empty. */
+    drill: boolean;
+    loaded: boolean;
+}
+export declare function useWindows(s: SheetState, v: Viewport, geo: Geometry): {
+    slots: Record<SlotKind, ShallowRef<Slot>>;
+    viewKey: () => string;
+    revision: ShallowRef<number, number>;
+    slotAt: (d: number, col: number) => Slot | null;
+    textAt: (d: number, col: number) => string;
+    styleAt: (d: number, col: number, addr: string) => CellStyle | undefined;
+    cellData: (d: number, col: number, addr: string) => CellData;
+    emptyAt: (d: number, col: number) => boolean;
+    textOfRow: (r: number, col: number) => string;
+    drillOfRow: (r: number, col: number) => boolean;
+    valueOfRow: (r: number, col: number) => 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<CellRect[]>;
+    tables: import("vue").ComputedRef<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: CellUpdate[]) => void;
+    repaint: (ranges: {
+        sheet: string;
+        range: string;
+    }[]) => void;
+};
+export type Windows = ReturnType<typeof useWindows>;
+export {};

package/dist/entry.d.ts

@@ -0,0 +1,3 @@
+export type Entry = typeof import('xlcalc/entry');
+/** The module, imported once; a failed import is retried on the next call. */
+export declare function loadEntry(): Promise<Entry>;

package/dist/failure.d.ts

@@ -0,0 +1,5 @@
+import type { EditOutcome } from './contract/source.js';
+/** An error's message; '' for anything else, where the caller describes the failure in its own words. */
+export declare const errorText: (e: unknown) => string;
+/** The outcome of a call that threw: failed, with the error's message. */
+export declare const failedOutcome: (e: unknown) => EditOutcome;

package/dist/filter-key.d.ts

@@ -0,0 +1,3 @@
+import type { SheetFilter } from './contract/source.js';
+/** A filter's stable key, for caching its row list. */
+export declare const filterKey: (f: SheetFilter) => string;

package/dist/find-match.d.ts

@@ -0,0 +1,24 @@
+import type { FindRequest, FindResult } from './contract/source.js';
+/** Visits every cell a search reads with its text (what it opens with, or its displayed text), in any order. */
+export type EachCell = (visit: (row: number, col: number, text: string) => void) => void;
+/** A cell and its text: a match, or a cell Replace All writes. */
+export interface CellText {
+    row: number;
+    col: number;
+    text: string;
+}
+/** Excel's cell order for Find: row by row, or column by column. */
+export declare const cellOrder: (byColumns: boolean | undefined) => (a: {
+    row: number;
+    col: number;
+}, b: {
+    row: number;
+    col: number;
+}) => number;
+/** The cells whose text matches, in Excel's order from the first after `req.after`, wrapping around at the end, at most `max` of them; `total` counts them all. */
+export declare function findCells(each: EachCell, req: FindRequest, visible: Set<number> | null, max: number): FindResult;
+/**
+ * Replace All's new texts: each cell the request finds with its new text, in Excel's order. Cells whose text would not
+ * change are omitted: written again, an in-memory cell would lose the displayed text it was given.
+ */
+export declare function replaceCells(each: EachCell, req: FindRequest, by: string, visible: Set<number> | null): CellText[];

package/dist/format-cells.d.ts

@@ -0,0 +1,85 @@
+import type { AlignmentStyle, BorderLine, FontStyle, FormatChoice, NumberFormat } from 'xlcalc/contract';
+import type { SheetFormatPatch, SheetViewState } from './contract/view.js';
+import { type BorderEdge, type EdgeLines } from './toolbar.js';
+export type FormatTab = 'number' | 'alignment' | 'font' | 'border' | 'fill';
+export declare const FORMAT_TABS: readonly FormatTab[];
+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';
+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). */
+    numberCode: string;
+    /** What OK sets: an item's format (a built-in one by number), or the typed code; null leaves the format unchanged. */
+    numberFormat: NumberFormat | null;
+    horizontal: Horizontal;
+    vertical: Vertical;
+    wrap: boolean;
+    indent: string;
+    fontName: string;
+    fontSize: string;
+    fontStyle: FontStyleKind;
+    underline: Underline;
+    strike: boolean;
+    /** null: Automatic. */
+    fontColour: string | null;
+    /** null: No Color. */
+    fill: string | null;
+    /** The line the Border tab's buttons draw with. */
+    line: BorderLine;
+    /** Edges as the Border tab set them; an edge not listed stays unchanged. */
+    edges: EdgeLines;
+}
+/** The dialog as it opened: the inputs, the range it formats and what its edges were (known for one cell, unknown for a range). */
+export interface FormatStart {
+    draft: FormatDraft;
+    ref: string;
+    /** One cell: the inside edges are off, and the outline is the cell's own sides. */
+    single: boolean;
+    edges: EdgeLines;
+}
+/** The inputs as the active cell's formatting fills them: its style, its number format's code, and Excel's thin black line to draw with. */
+export declare function startOf(state: SheetViewState): FormatStart;
+/** The edges the selection has: a single cell has no inside lines. */
+export declare const edgesIn: (start: FormatStart) => BorderEdge[];
+/** What an edge shows now: as set in the dialog, otherwise as it was; undefined where that is not known. */
+export declare const shownEdge: (start: FormatStart, draft: FormatDraft, e: BorderEdge) => BorderLine | null | undefined;
+/** An edge's button, as in Excel: puts the line on it, or turns it off when it already has that line. */
+export declare function pressEdge(start: FormatStart, draft: FormatDraft, e: BorderEdge): void;
+/** Excel's presets: None removes every line, Outline and Inside draw the line around the selection or inside it. */
+export declare function pressPreset(start: FormatStart, draft: FormatDraft, preset: 'none' | 'outline' | 'inside'): void;
+/** An input OK cannot parse, by its name: the code, the indent, the size. */
+interface DraftErrors {
+    numberCode?: true;
+    indent?: true;
+    fontSize?: true;
+}
+/** Excel's limits: a font of 1 to 409 points, an indent of 0 to 250, and a non-empty code of the cell's own. */
+export declare function draftErrors(draft: FormatDraft): DraftErrors;
+/** An item from Excel's list: its format, and its code in the input to edit from there, as Excel's Custom starts. */
+export declare function pickNumber(draft: FormatDraft, item: FormatChoice): void;
+/** A code typed into the input: OK sets it as written. */
+export declare function typeNumber(draft: FormatDraft, code: string): void;
+/** An alignment chosen in the list; one without an indent resets it to 0, as Excel grays out the input. */
+export declare function setHorizontal(draft: FormatDraft, h: string): void;
+/**
+ * OK's patches: one over the selection with the changes to the font, the alignment, the fill and the number format, and
+ * the Border tab's edges on their ranges, all for one call and so a single undo step; none when nothing changed. An input
+ * reset to its default removes the cell's own setting (null), as Excel stores no defaults.
+ */
+export declare function patchesOf(start: FormatStart, draft: FormatDraft): SheetFormatPatch[];
+export {};

package/dist/frame.d.ts

@@ -0,0 +1,5 @@
+import { type Ref } from 'vue';
+/** Below this width a viewport counts as a phone's: narrower row numbers, the toolbar's buttons in a menu. */
+export declare const NARROW_PX = 600;
+/** Whether the pointer is touch (`pointer: coarse`), following the media query until the scope ends. */
+export declare function useCoarsePointer(): Ref<boolean>;

package/dist/grid-ref.d.ts

@@ -0,0 +1,3 @@
+import type { FormulaReference, GridReference } from 'xlcalc/contract';
+/** Whether a reference found by `scanReferences` is one the grid displays: not a table reference, not across several sheets. */
+export declare const isGridRef: (r: FormulaReference) => r is GridReference;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { default as SheetView } from './components/SheetView.vue.js';
+export { default as SheetToolbar } from './components/SheetToolbar.vue.js';
+export { default as FormatDialog } from './components/FormatDialog.vue.js';
+export type * from './contract.js';
+export { enMessages, ruMessages } from './messages.js';
+export { memorySource } from './memory-source.js';