@xlcalc/vue 0.0.0-stage → 0.21.2

package/dist/components/icons.d.ts

@@ -0,0 +1,33 @@
+import { type FunctionalComponent } from 'vue';
+/** The attributes every icon's svg has; the toolbar's color icons build on them too. */
+export declare const ICON_ATTRS: {
+    class: string;
+    viewBox: string;
+    fill: string;
+    stroke: string;
+    'stroke-width': number;
+    'stroke-linecap': string;
+    'stroke-linejoin': string;
+    'aria-hidden': string;
+};
+/** An icon of strokes along `paths`; `extra` overrides an attribute (a heavier stroke, dashes). */
+export declare const icon: (paths: string[], extra?: Record<string, unknown>) => FunctionalComponent;
+export declare const IconBack: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconLink: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconLock: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconLockOpen: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconClose: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconCheck: FunctionalComponent<{}, {}, any, {}>;
+/** Excel's fx: an italic f and an x. */
+export declare const IconFx: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconRetry: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconSpinner: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconSearch: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconFilter: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconFilterOff: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconUp: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconDown: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconSortAsc: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconSortDesc: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconPlus: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconOptions: FunctionalComponent<{}, {}, any, {}>;

package/dist/components/popup.d.ts

@@ -0,0 +1,29 @@
+import { type Ref, type WatchSource } from 'vue';
+/** A box, in the coordinates of the element the popups are placed in. */
+export interface PopupRect {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+}
+/** An item of Excel's lists (AutoComplete, a validation list) is 18 px; 44 on a touch screen, as --xs-touch-target in the CSS. */
+export declare const ITEM_PX = 18;
+export declare const TOUCH_PX = 44;
+/** A list's height: up to `rows` items plus its 1 px border above and below. */
+export declare const listHeight: (count: number, rows: number, touch: boolean) => number;
+/**
+ * The top of a box `height` tall below `field` (`gap` px from it), or above it when the viewport has no room below and room
+ * above; below it without a viewport or with room in neither direction.
+ */
+export declare function placeBelowOrAbove(field: PopupRect, height: number, view: PopupRect | undefined, gap?: number): number;
+/** A box `width` wide from `left`, moved left to end at the viewport's right edge, but not beyond its left edge. */
+export declare const clampLeft: (left: number, width: number, view: PopupRect | undefined) => number;
+/** Scrolls the list (the offset parent of its items) by its own scroll only, so the page and its containers stay put, until item `i` is in view. */
+export declare function scrollToItem(list: HTMLElement | null | undefined, i: number): void;
+/** Keeps a list's highlighted item in view as the keys move it: after each change of `on`, once the list is drawn. */
+export declare function keepActiveInView(list: Ref<HTMLElement | null>, on: WatchSource<unknown>, active: () => number): void;
+/**
+ * Calls `onOutside` on a press outside `inside` (an element, or a selector the pressed element's ancestors match) while
+ * `active` returns true; the press is captured before the page's own handlers see it.
+ */
+export declare function useOutsidePress(inside: Ref<HTMLElement | null> | string, onOutside: () => void, active: () => boolean): void;

package/dist/components/toolbar-icons.d.ts

@@ -0,0 +1,24 @@
+import { type FunctionalComponent } from 'vue';
+export declare const IconUndo: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconRedo: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconBold: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconItalic: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconUnderline: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconFontColour: FunctionalComponent<{
+    colour?: string | null;
+}, {}, any, {}>;
+export declare const IconFillColour: FunctionalComponent<{
+    colour?: string | null;
+}, {}, any, {}>;
+export declare const IconBorderAll: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconBorderOutside: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconBorderBottom: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconBorderNone: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconAlignLeft: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconAlignCenter: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconAlignRight: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconWrap: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconMore: FunctionalComponent<{}, {}, any, {}>;
+export declare const IconFormatCells: FunctionalComponent<{}, {}, any, {}>;
+/** Merge & Center: a cell's box over the cells it covers, with a two-way arrow. */
+export declare const IconMerge: FunctionalComponent<{}, {}, any, {}>;

package/dist/contract/memory.d.ts

@@ -0,0 +1,108 @@
+import type { CellStyle, CellValue, ConditionalAppearance } from 'xlcalc/contract';
+import type { CellUpdate, EditOutcome, SheetInfo, SheetSource, SheetValidationAlert, SourceEvent } from './source.js';
+/** A cell of the in-memory workbook; a bare value is a cell with that value. */
+export interface MemoryCell {
+    value?: CellValue;
+    /** Displayed text; by default the value as plain text. */
+    text?: string;
+    /** The formula as displayed, without `=`; with no engine its value is whatever `value` specifies. */
+    formula?: string;
+    /** A style from the workbook's `styles`, by index. */
+    style?: number;
+    /** The color from the number format's section. */
+    color?: string;
+    /** The number format code the cell is displayed with, as xlsx stores it (`0.0%`, `dd.mm.yyyy`); General without it. The text the cell opens with for editing follows it. */
+    numberFormat?: string;
+    link?: {
+        href?: string;
+        location?: string;
+        tooltip?: string;
+        target?: string;
+    };
+    note?: {
+        author?: string;
+        text: string;
+    };
+    /** List mode: the cell is a drill-down (`SheetWindow.drill`). */
+    drill?: true;
+    /** The cell's conditional formatting, as xlcalc calculates it (`ConditionalAppearance`); the in-memory workbook keeps it as given. */
+    appearance?: ConditionalAppearance;
+}
+/**
+ * Excel's outline of an in-memory sheet: outline levels (1 to 7) of rows and columns by row, column or span, keyed as in
+ * `widths` and `heights` (`'3:9': 1`, `'C:E': 2`), the summary rows and columns marked collapsed (`'10'`, `'F'`; a group
+ * inside a collapsed one stays collapsed when the outer one is expanded), and where the summaries are (below and to the
+ * right by default). A group's rows or columns are hidden by a size of 0.
+ */
+export interface MemoryOutline {
+    rows?: Record<string, number>;
+    columns?: Record<string, number>;
+    collapsed?: string[];
+    summaryBelow?: boolean;
+    summaryRight?: boolean;
+}
+export interface MemorySheet extends Omit<SheetInfo, 'maxRow' | 'maxCol' | 'outline'> {
+    /** Cells by A1 address. */
+    cells: Record<string, MemoryCell | CellValue>;
+    /** Column widths by letters (`B`) or a span (`B:D`), in xlsx units; 0 hides. */
+    widths?: Record<string, number>;
+    /** Row heights by row (`5`) or a span (`5:9`), in points; 0 hides. */
+    heights?: Record<string, number>;
+    defaultRowHeight?: number;
+    merges?: string[];
+    tables?: {
+        name: string;
+        range: string;
+        headerRow: number;
+    }[];
+    notice?: string;
+    outline?: MemoryOutline;
+    /** Data validation rules: a cell's dropdown and input message, and the alert for a typed value that violates a rule. */
+    validations?: MemoryValidation[];
+}
+export interface MemoryBook {
+    sheets: MemorySheet[];
+    styles?: CellStyle[];
+    /** The functions for Formula AutoComplete, by their names as typed in the workbook's formulas, in the order its list displays them; without them the source has no `functionNames`. */
+    functions?: string[];
+}
+export interface MemorySourceOptions {
+    /** Milliseconds every response takes, to see the component waiting; 0 by default. */
+    delay?: number;
+    maxCells?: number;
+}
+export interface MemorySource extends SheetSource {
+    /** Responds to the next edits with these failed outcomes instead of applying them (for tests and the example). */
+    failNext(...outcomes: Extract<EditOutcome, {
+        ok: false;
+    }>[]): void;
+    /** Sends an event to the subscribers, as another tab would. */
+    emit(event: SourceEvent): void;
+    /** Changes cells as another tab would: the changes are applied and sent to the subscribers as `changed`. */
+    setCells(sheet: string, entries: Record<string, string | null>): CellUpdate[];
+    /** Simulates a workbook recalculating for `ms`: windows return `pending` until then. */
+    recompute(ms: number): void;
+}
+/** A data validation rule of an in-memory sheet, as Excel's dialog creates one: a list or whole numbers within bounds, an input message, the alert. */
+export interface MemoryValidation {
+    /** The cells: A1 ranges separated by spaces (`B2:B20 D2`, `C:C`). */
+    range: string;
+    /** A list: the value must be one of the items, case-sensitively, ignoring leading and trailing spaces; the cell shows them in a dropdown. */
+    list?: string[];
+    /** Whole numbers from `min` to `max`; omit either bound for none. */
+    whole?: {
+        min?: number;
+        max?: number;
+    };
+    /** The input message displayed while a cell is selected. */
+    prompt?: {
+        title?: string;
+        text: string;
+    };
+    /** The alert for a value that violates the rule: its style (stop by default), title and message (Excel's own text without one). */
+    alert?: {
+        severity?: SheetValidationAlert['severity'];
+        title?: string;
+        message?: string;
+    };
+}

package/dist/contract/messages.d.ts

@@ -0,0 +1,260 @@
+export interface SheetMessages {
+    back: string;
+    backEmpty: string;
+    address: string;
+    addressBad: string;
+    goSheet: (name: string) => string;
+    showRange: string;
+    cellLink: string;
+    cellLinkCopied: (ref: string) => string;
+    clipboardDenied: string;
+    /** The lock button's tooltip: what the workbook freezes, and whether the frozen panes are displayed now. */
+    freeze: (rows: number, cols: number, on: boolean) => string;
+    note: (author?: string) => string;
+    linkInBook: (location: string) => string;
+    linkOpen: string;
+    linkDead: (href: string) => string;
+    loading: string;
+    empty: string;
+    retry: string;
+    loadFailed: string;
+    copyFailed: string;
+    copyPartial: string;
+    /** Selection totals over loaded cells: the count, then the sum, average, min, max and count of numbers when there are numbers. */
+    statsCount: (n: string) => string;
+    statsSum: (n: string) => string;
+    statsAverage: (n: string) => string;
+    statsMin: (n: string) => string;
+    statsMax: (n: string) => string;
+    statsNumbers: (n: string) => string;
+    /** A selection larger than the loaded windows: only its size. */
+    statsCells: (n: string) => string;
+    sheetTitle: (name: string, rows: number, cols: number) => string;
+    sheetUnnamed: (n: number) => string;
+    /** The "+" button after the tabs, and the word a new sheet's name starts with (Excel's `Sheet4`, `Лист4`). */
+    insertSheet: string;
+    sheetNamePrefix: string;
+    /** The structure menu on row numbers, column letters and sheet tabs, with Excel's item names. */
+    menu: string;
+    menuInsert: string;
+    menuDelete: string;
+    menuColumnWidth: string;
+    menuRowHeight: string;
+    menuHide: string;
+    menuUnhide: string;
+    menuRename: string;
+    menuMoveLeft: string;
+    menuMoveRight: string;
+    menuUnhideSheet: string;
+    /** Excel's outline: Group and Ungroup in the menu and the dialog for a cell range (rows or columns), the buttons' tooltips, and the messages for commands that are not performed. */
+    menuGroup: string;
+    menuUngroup: string;
+    outlineRows: string;
+    outlineColumns: string;
+    outlineExpand: string;
+    outlineCollapse: string;
+    outlineLevel: (n: number) => string;
+    outlineDeepest: string;
+    outlineNone: string;
+    /** Excel's cell context menu (cut, copy and paste within the workbook), a paste whose clipboard the browser does not allow to read, and the fill handle. */
+    cellMenu: string;
+    menuCut: string;
+    menuCopy: string;
+    menuPaste: string;
+    pasteDenied: string;
+    fillHandle: string;
+    /** Excel's commands in the cell context menu: Reapply for the display filter, Freeze Panes and its variants, Trace Precedents as a panel next to the grid. */
+    menuReapply: string;
+    filterReapply: string;
+    menuFreezePanes: string;
+    menuUnfreezePanes: string;
+    menuFreezeTopRow: string;
+    menuFreezeFirstColumn: string;
+    menuPrecedents: string;
+    explainTitle: string;
+    explainReading: string;
+    explainFailed: string;
+    explainEmpty: string;
+    /** The size dialogs: their labels in Excel's units, and the limits. */
+    columnWidth: string;
+    rowHeight: string;
+    widthRange: string;
+    heightRange: string;
+    ok: string;
+    cancel: string;
+    /** The confirmation before a sheet with data is deleted, and the list of hidden sheets. */
+    deleteSheet: string;
+    deleteSheetText: (name: string) => string;
+    unhideSheet: string;
+    rename: string;
+    selectColumn: string;
+    selectRow: string;
+    /** List mode: a sortable column's title, and the cells of the first column that open their row. */
+    sortColumn: string;
+    openRow: string;
+    selectAll: string;
+    resize: string;
+    /** A column edge where a double click fits the column to its contents. */
+    resizeFit: string;
+    /** The resize grip on a row number's edge. */
+    resizeRow: string;
+    conflict: string;
+    locked: (reason: string) => string;
+    editFailed: string;
+    /** A paste whose range would extend past the sheet's last row or column. */
+    pasteOffSheet: string;
+    tooManyCells: string;
+    pending: string;
+    close: string;
+    /** The formula bar's tooltip over a formula with references: Ctrl+click (Cmd on a Mac; the key is passed in) goes to a reference. */
+    goRefHint: (key: string) => string;
+    /** Excel's Enter button to the left of the formula bar (its Cancel button is `cancel`): enters the edit and keeps the selection. */
+    barEnter: string;
+    /** Excel's Insert Function: the fx button, then the dialog's title, search box, category box with its first two items, and the list's label. */
+    insertFunction: string;
+    insertFunctionTitle: string;
+    insertFunctionSearch: string;
+    insertFunctionCategory: string;
+    insertFunctionRecent: string;
+    insertFunctionAll: string;
+    insertFunctionPick: string;
+    /** Excel's button at the right end of the formula bar and its Ctrl+Shift+U: expands or collapses the formula bar. */
+    expandBar: string;
+    collapseBar: string;
+    /** A workbook being recalculated: the waiting message, the seconds elapsed, and the timeout. */
+    waiting: string;
+    waitSeconds: (n: number) => string;
+    waitHint: string;
+    waitTimeout: string;
+    find: string;
+    findPlaceholder: string;
+    findPrev: string;
+    findNext: string;
+    findNone: string;
+    /** Search status: the current match's position, the total, and how many were received when the source truncated the list. */
+    findStatus: (i: number, total: number, shown: number) => string;
+    /** Search status while the active cell is not a match: the total, and how many were received. */
+    findCount: (total: number, shown: number) => string;
+    findFailed: string;
+    /** Excel's Find and Replace: its options, the range it searches within, the Replace row and the result of Replace All. */
+    findOptions: string;
+    findMatchCase: string;
+    findWholeCell: string;
+    findLookIn: string;
+    findInFormulas: string;
+    findInValues: string;
+    findOrder: string;
+    findByRows: string;
+    findByColumns: string;
+    findWithin: (range: string) => string;
+    findWholeSheet: string;
+    replaceToggle: string;
+    replacePlaceholder: string;
+    replaceOne: string;
+    replaceAll: string;
+    replaceDone: (n: number) => string;
+    /** Replace All left `n` cells unchanged: Excel would not accept their new text, for the source's reason `why`. */
+    replaceRefused: (n: number, why: string) => string;
+    filter: string;
+    filterOn: string;
+    filterColumn: (letters: string) => string;
+    filterNamed: (name: string, letters: string) => string;
+    sortAsc: string;
+    sortDesc: string;
+    filterText: string;
+    filterSearch: string;
+    filterAll: string;
+    filterEmpty: string;
+    filterMore: (n: number) => string;
+    filterReading: string;
+    filterApply: string;
+    filterReset: string;
+    filterClear: string;
+    /** The filter status line at the bottom: visible rows out of all, the columns with conditions, the sort. */
+    filterStatus: (shown: string, total: string, cols: string[], sort: {
+        col: string;
+        dir: 'asc' | 'desc';
+    } | null) => string;
+    filterFailed: string;
+    valuesFailed: string;
+    unfiltered: (row: number) => string;
+    /** The formatting toolbar (`SheetToolbar`): its buttons, menus and number formats, with Excel's names. */
+    toolbar: string;
+    toolbarMore: string;
+    undo: string;
+    redo: string;
+    bold: string;
+    italic: string;
+    underline: string;
+    fontColor: string;
+    fillColor: string;
+    pickColor: string;
+    colorAuto: string;
+    fillNone: string;
+    borders: string;
+    borderAll: string;
+    borderOutside: string;
+    borderBottom: string;
+    borderNone: string;
+    alignLeft: string;
+    alignCenter: string;
+    alignRight: string;
+    wrapText: string;
+    numberFormat: string;
+    /** Excel's Format Cells dialog (`FormatDialog`): its tabs, inputs and the names of their options. */
+    formatCells: string;
+    formatCellsOpen: string;
+    fmtTab: (tab: 'number' | 'alignment' | 'font' | 'border' | 'fill') => string;
+    fmtCategory: string;
+    fmtCode: string;
+    fmtCodeEmpty: string;
+    fmtHorizontal: string;
+    fmtVertical: string;
+    fmtHorizontalKind: (h: 'general' | 'left' | 'center' | 'right' | 'fill' | 'justify' | 'centerContinuous' | 'distributed') => string;
+    fmtVerticalKind: (v: 'top' | 'center' | 'bottom' | 'justify' | 'distributed') => string;
+    fmtIndent: string;
+    fmtIndentRange: string;
+    fmtFontName: string;
+    fmtFontDefault: string;
+    fmtFontStyle: string;
+    fmtFontStyleKind: (k: 'regular' | 'italic' | 'bold' | 'boldItalic') => string;
+    fmtSize: string;
+    fmtSizeRange: string;
+    fmtUnderline: string;
+    fmtUnderlineKind: (k: 'none' | 'single' | 'double') => string;
+    fmtStrike: string;
+    fmtColor: string;
+    fmtColorCode: string;
+    fmtColorBad: string;
+    fmtBackground: string;
+    fmtLine: string;
+    fmtLineStyle: (style: string) => string;
+    fmtPresets: string;
+    fmtPreset: (p: 'none' | 'outline' | 'inside') => string;
+    fmtEdges: string;
+    fmtEdge: (e: 'top' | 'bottom' | 'left' | 'right' | 'insideH' | 'insideV') => string;
+    /** Excel's data validation: the dropdown button, the alert's title when the rule has none, its buttons (Retry, OK and Cancel are `retry`, `ok` and `cancel`), a warning's question and the style names. */
+    validationList: string;
+    validationTitle: string;
+    validationYes: string;
+    validationNo: string;
+    validationContinue: string;
+    validationStyle: (severity: 'stop' | 'warning' | 'information') => string;
+    /** The prompt for a formula that cannot be parsed, below the source's reason, and its buttons. */
+    formulaQuestion: string;
+    formulaFix: string;
+    formulaRevert: string;
+    /** Excel's dialog for an unclosed formula that it offers to correct (Yes and No are `validationYes` and `validationNo`), and its message after No. */
+    typoFound: (correction: string) => string;
+    missingParenthesis: string;
+    /** Excel's Formula AutoComplete: the function list below the editor and its hint. */
+    functionList: string;
+    functionHint: string;
+    /** Excel's Merge & Center button, its dropdown button and items, and the warning before values are lost. */
+    mergeCenter: string;
+    mergeMenu: string;
+    mergeAcross: string;
+    mergeCells: string;
+    unmergeCells: string;
+    mergeWarning: string;
+}