@xlcalc/vue 0.0.0-stage → 0.21.2

package/dist/locale-ref.d.ts

@@ -0,0 +1,7 @@
+import { type ShallowRef } from 'vue';
+import type { Locale } from 'xlcalc/contract';
+/**
+ * The locale object of `tag()`: null while its module loads; undefined for a tag the package has no module for (en-US)
+ * and for a module that failed to load, which is treated as en-US. A module that arrives after the tag changed is discarded.
+ */
+export declare function useLocaleModule(tag: () => string | undefined): ShallowRef<Locale | undefined | null>;

package/dist/locales.d.ts

@@ -0,0 +1,3 @@
+import type { Locale } from 'xlcalc/contract';
+/** Each a dynamic import a bundler can see: the main entry point ships it as a separate chunk, `./local` leaves it to the host's xlcalc. */
+export declare const LOCALE_MODULES: Readonly<Record<string, () => Promise<Locale>>>;

package/dist/memory-outline.d.ts

@@ -0,0 +1,31 @@
+import type { OutlineEditOp, OutlineGroup as BookGroup, OutlineSettings, SheetInput } from 'xlcalc/contract';
+import { type LineAxis } from './lines.js';
+import type { OutlineChange, SheetOutline } from './contract/source.js';
+/** One axis's rows or columns as `memorySource` stores them, one by one: outline levels, collapsed flags and hidden ones. */
+export interface AxisLines {
+    levels: Map<number, number>;
+    marks: Set<number>;
+    hidden: Set<number>;
+}
+/** The summary settings alone, as xlcalc takes them: an omitted field is Excel's default. */
+export declare function outlineSettings(o?: OutlineSettings | null): OutlineSettings;
+/** A sheet's rows and columns on both axes as xlcalc's outline reads them, with its summaries where the settings put them. */
+export declare function outlineSheet(axes: Record<LineAxis, AxisLines>, settings?: OutlineSettings | null): Pick<SheetInput, 'rows' | 'columns' | 'outline'>;
+/** A sheet's outline in the contract's terms from xlcalc's groups on both axes; none for a sheet without groups. */
+export declare function outlineOf(groups: Record<LineAxis, BookGroup[]>, settings?: OutlineSettings | null): SheetOutline | undefined;
+/**
+ * The component's outline command as xlcalc's, or why there is none. A group's button is Show or Hide Detail at its summary
+ * row or column, with the group found among the axis's groups by its rows or columns and level; a group at the edge of the
+ * sheet has no summary row or column and, as in Excel, no button.
+ */
+export declare function outlineOp(change: OutlineChange, groups: (axis: LineAxis) => readonly BookGroup[]): OutlineEditOp | {
+    refused: string;
+};
+/**
+ * Runs an outline command on the rows or columns of its axis as xlcalc's `outlineEdit` does, changing them in place; returns
+ * Excel's rejection in English with xlcalc's code, or null. A command xlcalc cannot parse (a level button beyond 8) throws its `InputError`.
+ */
+export declare function outlineCommand(lines: AxisLines, settings: OutlineSettings | null | undefined, change: OutlineChange): {
+    code?: string;
+    message: string;
+} | null;

package/dist/memory-query.d.ts

@@ -0,0 +1,26 @@
+import type { CellRect } from 'xlcalc/contract';
+import { type CellText } from './find-match.js';
+import { type QuerySheet } from './sheet-query.js';
+import type { FindRequest, FindResult, RangeStats, SheetFilter } from './contract/source.js';
+/** What the queries read of a sheet: what the display filter reads, and for search where its columns end and what each cell opens with. */
+export interface MemorySheetQuery extends QuerySheet {
+    maxCol: number;
+    /** The text a cell opens with: its formula, otherwise its value as typed. */
+    editAt(row: number, col: number): string;
+}
+/** The sheet's rows in display order: the header first, then the rows that match the conditions, sorted; null without conditions. */
+export declare function visibleList(sheet: MemorySheetQuery, filter: SheetFilter | undefined): number[] | null;
+/** A column's displayed values with their counts, over the rows the other columns' conditions keep; '' is an empty cell. */
+export declare function columnList(sheet: MemorySheetQuery, col: number, filter: SheetFilter): {
+    values: {
+        text: string;
+        count: number;
+    }[];
+    more: number;
+};
+/** Excel's Find: matches in its order, only the visible rows under a filter. */
+export declare function findHits(sheet: MemorySheetQuery, req: FindRequest): FindResult;
+/** Excel's Replace All: the new text of each cell the request finds in formulas, as Excel replaces whatever Look in says. */
+export declare function replaceTexts(sheet: MemorySheetQuery, req: FindRequest, by: string): CellText[];
+/** Totals of a range as in Excel's status bar, over the visible rows under a filter. */
+export declare function rangeStats(sheet: MemorySheetQuery, rect: CellRect, filter: SheetFilter | undefined): RangeStats;

package/dist/memory-source.d.ts

@@ -0,0 +1,3 @@
+import type { MemoryBook, MemorySource, MemorySourceOptions } from './contract/memory.js';
+/** A source over `book`; the workbook's objects are copied, and edits change the copy. */
+export declare function memorySource(book: MemoryBook, options?: MemorySourceOptions): MemorySource;

package/dist/memory-validation.d.ts

@@ -0,0 +1,17 @@
+import type { CellEntry, EditOutcome, SheetValidation } from './contract/source.js';
+import type { MemoryValidation } from './contract/memory.js';
+/** A number as the in-memory workbook parses a typed one: digits, a minus sign and a decimal point, nothing else. */
+export declare const PLAIN_NUMBER: RegExp;
+/** A sheet's rules with their ranges, parsed once. */
+export declare class MemoryRules {
+    private readonly rules;
+    constructor(rules?: MemoryValidation[]);
+    /** The rule that applies to a cell (the first, since no two rules on a sheet overlap in Excel). */
+    at(cell: string): MemoryValidation | null;
+    /** What the cell displays of its rule: the list's items and the input message; null without a rule. */
+    show(cell: string): SheetValidation | null;
+}
+/** The alert of the strictest rule that typed entries violate, the first of that style, as a rejection; null when all are accepted. */
+export declare function memoryRefusal(entries: CellEntry[], rulesOf: (sheet: string) => MemoryRules | undefined): Extract<EditOutcome, {
+    ok: false;
+}> | null;

package/dist/messages.d.ts

@@ -0,0 +1,6 @@
+import { type ComputedRef } from 'vue';
+import type { SheetMessages } from './contract/messages.js';
+export declare const enMessages: SheetMessages;
+export declare const ruMessages: SheetMessages;
+/** A component's texts: the English set overridden by the part a host passed. */
+export declare function useMessages(part: () => Partial<SheetMessages> | undefined): ComputedRef<SheetMessages>;

package/dist/number-formats.d.ts

@@ -0,0 +1,13 @@
+import { type ComputedRef } from 'vue';
+import type { FormatChoice, NumberFormatCategory } from 'xlcalc/contract';
+export interface NumberFormats {
+    /** The list's items in Excel's order, each with its name, the format it applies and that format's code; empty while the locale loads. */
+    choices: ComputedRef<FormatChoice[]>;
+    /** The category the box shows for a code (General without one); null while the locale loads. */
+    categoryOf: (code: string | undefined) => NumberFormatCategory | null;
+}
+/**
+ * The box in the workbook's locale (`SheetView`'s `locale`, en-US without one): one of the package's locales loads as a
+ * separate chunk, as the grid's formula text does; a tag the package has no module for is treated as en-US.
+ */
+export declare function useNumberFormats(tag: () => string | undefined): NumberFormats;

package/dist/rect.d.ts

@@ -0,0 +1,9 @@
+import type { CellPosition, CellRect } from 'xlcalc/contract';
+/** The range of a single cell. */
+export declare const cellRect: (row: number, col: number) => CellRect;
+/** The range two corners span, in any order. */
+export declare const rectOf: (a: CellPosition, b: CellPosition) => CellRect;
+/** The smallest range containing both. */
+export declare const unionRect: (a: CellRect, b: CellRect) => CellRect;
+/** `v` clamped to `lo`..`hi`. */
+export declare const clamp: (v: number, lo: number, hi: number) => number;