@xlcalc/vue 0.0.0-stage → 0.21.2

package/dist/lines.d.ts

@@ -0,0 +1,16 @@
+import type { OutlineChange } from './contract/source.js';
+/** Rows or columns of a sheet. */
+export type LineAxis = 'rows' | 'columns';
+/** The rows or columns of `text` on one axis (`C`, `C:C`, `B:D`; `5`, `5:5`, `3:6`; any letter case); null for anything else. */
+export declare function lineSpan(text: string, axis: LineAxis): {
+    first: number;
+    last: number;
+} | null;
+/** The axis an outline command acts on. */
+export declare const axisOf: (change: OutlineChange) => LineAxis;
+/** Rows or columns on an axis as a change names them: `{ rows: '3:6' }`, `{ columns: 'B:D' }`. */
+export declare const linesOn: (axis: LineAxis, key: string) => {
+    rows: string;
+} | {
+    columns: string;
+};

package/dist/local/find.d.ts

@@ -0,0 +1,15 @@
+import type { AsyncSession, ReplaceResult } from 'xlcalc';
+import type { FindRequest, FindResult } from '../contract/source.js';
+import type { CellsBox } from './outcome.js';
+/** Excel's Find: at most `FIND_MAX_HITS` matches in its order, from the first after `after`, wrapping around at the end, and the total count; `rows`, the display filter's in ascending order. */
+export declare function findHits(s: AsyncSession, req: FindRequest, rows: number[] | null, signal?: AbortSignal): Promise<FindResult>;
+/** Excel's Replace All: the cells Find finds in the text they open with, whatever Look in says, each with its matches replaced, as a single undo step. */
+export declare function replaceAll(s: AsyncSession, req: FindRequest, by: string, rows: number[] | null): Promise<ReplaceResult>;
+/**
+ * Cells scattered over a sheet (Replace All's) in ranges of at most `max` cells, so that reading them fits in windows;
+ * the cells come in Find's order, which keeps neighbors together.
+ */
+export declare function boxesUnder(sheet: string, cells: {
+    row: number;
+    col: number;
+}[], max: number): Required<CellsBox>[];

package/dist/local/index.d.ts

@@ -0,0 +1,3 @@
+export { localSource } from './source.js';
+export { openXlsx, saveXlsx, groupIssues, type IssueGroup, type XlsxIssuesOptions } from './xlsx.js';
+export type { LocalSource, LocalSourceOptions } from './types.js';

package/dist/local/locale.d.ts

@@ -0,0 +1,5 @@
+import type { Locale } from 'xlcalc/contract';
+/** Loads the locale of `tag` once; a tag without a module is left to the session, which rejects it, listing the locales it has. */
+export declare function loadLocale(tag: string): Promise<void>;
+/** The loaded locale of `tag` with its tooltip text attached, loaded once; the tag alone where it has none (en-US) or it fails to load. */
+export declare function tipLocale(tag: string): Promise<Locale | string>;

package/dist/local/outcome.d.ts

@@ -0,0 +1,21 @@
+import type { CellRect, CellRef, CellTextsRefusal, EditResult, PasteTextRefusal, ViewportCell } from 'xlcalc';
+import type { CellUpdate, EditOutcome } from '../contract/source.js';
+export declare const failed: (message: string) => EditOutcome;
+/** A session exception as an outcome: input the workbook rejects as `input`, anything else (a busy calculator too) as failed. */
+export declare function outcomeOf(e: unknown, input: 'refused' | 'failed'): EditOutcome;
+/** A text the session did not accept: a value a rule rejects, with the rule's alert; a formula that cannot be parsed, as invalid at its position with the correction Excel suggests; the rest as refused. */
+export declare function refusalOf(r: CellTextsRefusal | PasteTextRefusal): EditOutcome;
+/** A window cell as the update of an edited cell: its formula as displayed and the text it opens with. */
+export declare function updateOf(sheet: string, addr: string, cell: ViewportCell | undefined): CellUpdate;
+/** The change moved, laid out, restyled, or changed a note or a hyperlink, which cell updates do not carry: the sheets and windows are read again. */
+export declare const needsReload: (got: EditResult) => boolean;
+/** A cell key that matches sheet names as the library does, case-insensitively. */
+export declare const cellKey: (sheet: string, cell: string) => string;
+/** Cells on a sheet: the range that contains them and their addresses. */
+export interface CellsBox {
+    sheet: string;
+    rect: CellRect;
+    only?: Set<string>;
+}
+/** Cells by sheet, each sheet's in the range that contains them; an address that is not a cell is omitted. */
+export declare function boxesOf(refs: CellRef[]): CellsBox[];

package/dist/local/query.d.ts

@@ -0,0 +1,23 @@
+import type { CellValue, CellView } from 'xlcalc';
+import type { QuerySheet } from '../sheet-query.js';
+/** A sheet's columns as the display filter has needed them, read through `read` (the session's `getCells` over ranges, stopped by a signal). */
+export declare class SheetValues implements QuerySheet {
+    maxRow: number;
+    private readonly read;
+    /** Columns read, and those being read. */
+    private readonly cols;
+    private readonly reading;
+    /** `maxRow`: where the sheet's cells end; an edit beyond it extends it, as Excel's used range grows. */
+    constructor(maxRow: number, read: (ranges: string[], signal?: AbortSignal) => Promise<Record<string, CellView>>);
+    /**
+     * The columns read, with the missing ones read in one call that `signal` stops. A read that another request started and
+     * its signal stopped is repeated for this one.
+     */
+    load(cols: number[], signal?: AbortSignal): Promise<void>;
+    /** Reads columns `want` in one call. */
+    private start;
+    /** A cell's new text and value, stored where its column is read or being read. */
+    set(row: number, col: number, text: string, value: CellValue | undefined): void;
+    textAt(row: number, col: number): string;
+    valueAt(row: number, col: number): CellValue | undefined;
+}

package/dist/local/source.d.ts

@@ -0,0 +1,4 @@
+import { type BookInput } from 'xlcalc';
+import type { LocalSource, LocalSourceOptions } from './types.js';
+/** A source over `input`: the workbook is passed to the session as is (its cells are not copied), so do not change it afterwards. */
+export declare function localSource(input: BookInput, opts?: LocalSourceOptions): LocalSource;

package/dist/local/types.d.ts

@@ -0,0 +1,37 @@
+import type { AsyncSessionOptions, BookInput, BookSnapshot, Calc, CalcPoolOptions, SessionHistory } from 'xlcalc';
+import type { SheetSource } from '../contract/source.js';
+export interface LocalSourceOptions {
+    /**
+     * Where the workbook is calculated: `pool`, in Web Workers of `xlcalc/worker` (the default where `Worker` exists);
+     * `inline`, on the page's own thread in slices (the default elsewhere, e.g. Node); or by the host's calculator, which
+     * the source does not close.
+     */
+    calc?: 'pool' | 'inline' | Calc;
+    /** Options for the pool the source starts (`calc: 'pool'`), e.g. `spawn` for a bundler that relocates the thread script. */
+    pool?: CalcPoolOptions;
+    /** Options for the workbook's session (a live clock, limits, deadlines). */
+    session?: AsyncSessionOptions;
+    /** The maximum number of cells in one window, 20,000 by default. */
+    maxCells?: number;
+    /** A notice included in every window (displayed above the grid), e.g. what the xlsx reader left out. */
+    notice?: string;
+}
+/** Methods of `SheetSource` that the local source always has. */
+type Given = 'edit' | 'paste' | 'fill' | 'pick' | 'end' | 'undo' | 'redo' | 'structure' | 'layout' | 'format' | 'replace' | 'outline' | 'freeze' | 'subscribe' | 'validation' | 'functionNames' | 'functionSignature' | 'explain' | 'stats' | 'find' | 'visibleRows' | 'columnValues';
+/** A sheet source over an xlcalc workbook: every method of `SheetSource`, plus the host's handles on the workbook. */
+export interface LocalSource extends Omit<SheetSource, Given | 'maxCells'>, Required<Pick<SheetSource, Given>> {
+    readonly maxCells: number;
+    /** The workbook's locale tag: formulas are displayed and typed values parsed in it. */
+    readonly locale: string;
+    /** Resolves when the workbook is calculated; rejects if it could not be opened (the methods reject with the same error). */
+    readonly ready: Promise<void>;
+    /** The number of steps `undo` and `redo` can take now, for a toolbar's buttons. */
+    readonly history: SessionHistory;
+    /** The workbook with all changes so far, to save or store. */
+    book(): Promise<BookInput>;
+    /** The workbook and its calculated values captured at one moment, as `writeXlsx` takes them. */
+    snapshot(): Promise<BookSnapshot>;
+    /** Closes the session, and the pool when the source started it. */
+    close(): Promise<void>;
+}
+export {};

package/dist/local/validation.d.ts

@@ -0,0 +1,8 @@
+import type { CellValidation, CellValidationRefusal } from 'xlcalc';
+import type { EditOutcome, SheetValidation } from '../contract/source.js';
+/** A cell's rule as the component displays it: a list's items when it shows its dropdown (a formula's error yields none), and the input message unless it is turned off; null without a rule. */
+export declare function validationOf(got: CellValidation | null): SheetValidation | null;
+/** A value rejected by its rule, with Excel's alert: the rule's style, its title (the component's default without one) and its message (the library's text without one). */
+export declare function alertRefusalOf(r: CellValidationRefusal): Extract<EditOutcome, {
+    ok: false;
+}>;

package/dist/local/window.d.ts

@@ -0,0 +1,16 @@
+import type { Viewport } from 'xlcalc';
+import type { SheetWindow } from '../contract/source.js';
+interface WindowShape {
+    /** The window's first row as requested: a sheet row, or a display index under a filter. */
+    row: number;
+    /** The window's sheet rows in display order. */
+    rows: number[];
+    col: number;
+    cols: number;
+    /** The rows come from a display filter: merged ranges over several rows are omitted, as Excel displays them then. */
+    filtered: boolean;
+    notice?: string;
+}
+/** The component's window from a viewport of the shape's rows and columns. */
+export declare function windowOf(v: Viewport, a: WindowShape): SheetWindow;
+export {};

package/dist/local/xlsx.d.ts

@@ -0,0 +1,23 @@
+import type { Locale } from 'xlcalc';
+import type { XlsxIssue, XlsxRead, XlsxWritten } from 'xlcalc/xlsx';
+import type { LocalSource } from './types.js';
+/** The language of the issue messages: a tag (`ru-RU`, whose module is loaded on demand) or a locale object; en-US by default. */
+export interface XlsxIssuesOptions {
+    locale?: string | Locale;
+}
+/** Reads a file (the bytes, or a `File` from a file input or a drop) into a workbook; `issues` lists what the workbook cannot keep, in `locale`'s language. */
+export declare function openXlsx(data: Blob | ArrayBuffer | Uint8Array, opts?: XlsxIssuesOptions): Promise<XlsxRead>;
+/** Writes the source's workbook with its calculated values (`formulas`, the default, or `values` only); `issues` lists what the file cannot keep, in `locale`'s language. */
+export declare function saveXlsx(source: LocalSource, opts?: XlsxIssuesOptions & {
+    mode?: 'formulas' | 'values';
+}): Promise<XlsxWritten>;
+export interface IssueGroup {
+    code: XlsxIssue['code'];
+    count: number;
+    /** The sheets the issues concern, in order of appearance. */
+    sheets: string[];
+    /** The first issue's message. */
+    message: string;
+}
+/** Issues grouped by kind, in order of first appearance: for a notice of what a file lost. */
+export declare function groupIssues(issues: XlsxIssue[]): IssueGroup[];