@dou-ui/sheet 0.0.0-stage → 0.1.0-alpha.1

package/dist/types/core/file.d.ts

@@ -0,0 +1,301 @@
+import type { Component } from 'vue';
+import type { SheetFunction } from '../formula/functions';
+import { type SheetResult } from '../formula/values';
+import { type SheetMessages } from '../locale';
+import { type SheetBounds } from './address';
+import { type SheetCellType, type SheetResolvedType } from './cell-type';
+import type { SheetExtension } from './extension';
+import { type SheetData, type SheetStyle, type SheetValue, type SheetWorkbook } from './model';
+import { type SheetRef } from './transaction';
+import { type SheetLabel } from './commands';
+import type { SheetDrawing } from '../export/draw';
+/** What is exported: every sheet, the sheet shown, or the selected cells. */
+export type SheetExportScope = 'workbook' | 'sheet' | 'selection';
+/** A sheet to export, with the cells to write. */
+export interface SheetFileSheet {
+    /** Its place in the workbook. */
+    index: number;
+    data: SheetData;
+    /** The cells to write: the selection, or from `A1` to the last cell with data; `null` when it is empty. */
+    bounds: SheetBounds | null;
+}
+/** What an exporter reads: the workbook and how its cells show, without the grid. */
+export interface SheetFileSource {
+    /** The workbook as it is stored. */
+    book: SheetWorkbook;
+    /** What is being exported. */
+    scope: SheetExportScope;
+    /** The sheets to write, in order: one, unless `scope` is `'workbook'`. */
+    sheets: SheetFileSheet[];
+    /** The language dates and numbers are written in. */
+    locale?: string;
+    messages: SheetMessages;
+    /** The grid's default column width and row height in px, for columns and rows without their own. */
+    colWidth: number;
+    rowHeight: number;
+    /** A cell's value as stored: for a formula, the formula. */
+    value: (sheet: number, row: number, col: number) => SheetValue;
+    /** What a cell comes to: its formula's result (an error as a `SheetError`), or its value. */
+    result: (sheet: number, row: number, col: number) => SheetResult;
+    /** The text a cell shows, with its format and cell type, as the grid draws it. */
+    text: (sheet: number, row: number, col: number) => string;
+    /**
+     * The value to write into another spreadsheet program: the cell type's
+     * `plain`, or what the cell comes to (an error as its code, such as `#DIV/0!`).
+     */
+    plain: (sheet: number, row: number, col: number) => SheetValue;
+    /**
+     * How the cell looks: its named style with what its conditional formats
+     * give it over it, `tone` and `fill` as the colors they are in the light
+     * theme (in `color` and `background`). `{}` for a plain cell.
+     */
+    style: (sheet: number, row: number, col: number) => SheetStyle;
+    /** The cell's number or date format. */
+    format: (sheet: number, row: number, col: number) => string | undefined;
+    /** The cell's type and its settings, or `undefined` for a plain cell. */
+    cellType: (sheet: number, row: number, col: number) => SheetResolvedType | undefined;
+    /** Aborted when the export is called off. */
+    signal?: AbortSignal;
+    /** Only for exporters with `needs: 'view'`, in the grid: the cells as the grid draws them. */
+    view?: SheetFileView;
+}
+/** What an exporter with `needs: 'view'` gets of the grid. */
+export interface SheetFileView {
+    /**
+     * The cells exported laid out as the grid draws them: column widths, row
+     * heights, text and looks in plain colors of the page's theme.
+     */
+    drawing: (options?: {
+        headers?: boolean;
+        gridlines?: boolean;
+        background?: boolean;
+    }) => SheetDrawing;
+}
+/** A way to write the workbook as a file, such as CSV; see `defineSheetExporter`. */
+export interface SheetExporter<Options = any> {
+    /** Unique among the exporters; `exportFile` takes it. */
+    name: string;
+    /** Its name in the toolbar's export menu. */
+    label: SheetLabel;
+    /**
+     * Its icon in the toolbar's export menu; by default a file icon for its
+     * `extension`, so an exporter needn't load icons (and Vue), as in a Worker.
+     */
+    icon?: Component;
+    /** The file name's extension, without the dot, e.g. `xlsx`. */
+    extension: string;
+    /** The file's media type. */
+    mime: string;
+    /** What it can export, the first being what the toolbar exports. Defaults to every scope. */
+    scopes?: SheetExportScope[];
+    /**
+     * `'view'` for an exporter that draws the cells as the grid shows them
+     * (sizes, the page's colors), which gets `source.view` and only works in
+     * the grid; `exportWorkbook` refuses it. Defaults to `'data'`.
+     */
+    needs?: 'data' | 'view';
+    /** Writes the file. A string is wrapped in a `Blob` of `mime`. */
+    export: (source: SheetFileSource, options?: Options) => Blob | string | Promise<Blob | string>;
+}
+/**
+ * The options an exporter or importer takes; for either of two, either's,
+ * so one picked at run time, e.g. by a message, can be passed as it is.
+ */
+type OptionsOf<Handler> = Handler extends SheetExporter<infer Options> | SheetImporter<infer Options, any> ? Options : never;
+/** What an importer gives back, as it declares it. */
+type ResultOf<Importer> = Importer extends SheetImporter<any, infer Result> ? Result : SheetImportResult;
+/** Declares an exporter; only gives it a type. */
+export declare function defineSheetExporter<Options = any>(exporter: SheetExporter<Options>): SheetExporter<Options>;
+/** An exporter as menus show it, its label in the sheet's language. */
+export interface SheetExporterInfo {
+    name: string;
+    label: string;
+    icon?: Component;
+    extension: string;
+    mime: string;
+    /** What it can export, the first being what it exports by default. */
+    scopes: SheetExportScope[];
+}
+/** An importer as menus show it, its label in the sheet's language. */
+export interface SheetImporterInfo {
+    name: string;
+    label: string;
+    accept: string[];
+}
+export declare const exporterInfo: (exporter: SheetExporter, messages: SheetMessages) => SheetExporterInfo;
+export declare const importerInfo: (importer: SheetImporter, messages: SheetMessages) => SheetImporterInfo;
+/** Something an importer couldn't bring over, such as images or borders. */
+export interface SheetImportWarning {
+    /** A short name for what was lost, e.g. `'border'`. */
+    code: string;
+    /** It in words, for people. */
+    message: string;
+    /** How many times it came up. */
+    count?: number;
+    /** The sheet it was on. */
+    sheet?: string;
+}
+/** What an importer read. */
+export interface SheetImportResult {
+    book: SheetWorkbook;
+    warnings?: SheetImportWarning[];
+}
+/** What an importer gets besides the file. */
+export interface SheetImportContext {
+    messages: SheetMessages;
+    locale?: string;
+    signal?: AbortSignal;
+}
+/** A way to read a file into a workbook, such as CSV; see `defineSheetImporter`. */
+export interface SheetImporter<Options = any, Result extends SheetImportResult = SheetImportResult> {
+    /** Unique among the importers; `importFile`'s `importer` takes it. */
+    name: string;
+    /**
+     * What the files it reads are called, such as “CSV 文件”: in the hints the
+     * grid shows about a file without a name, and in `useSheet().importers`
+     * for a menu of your own.
+     */
+    label: SheetLabel;
+    /**
+     * The files it reads, as the file picker's `accept` takes them: extensions
+     * such as `.csv` and media types such as `text/csv`.
+     */
+    accept: string[];
+    /** Tells from the file's first bytes whether it reads it, for files whose name says nothing. */
+    sniff?: (head: Uint8Array) => boolean;
+    import: (file: Blob, context: SheetImportContext, options?: Options) => Result | Promise<Result>;
+}
+/**
+ * Declares an importer; only gives it a type. `defineSheetImporter<Options, Result>`
+ * also says what it gives back, such as warnings it always has.
+ */
+export declare function defineSheetImporter<Options = any>(importer: SheetImporter<Options>): SheetImporter<Options>;
+export declare function defineSheetImporter<Options, Result extends SheetImportResult>(importer: SheetImporter<Options, Result>): SheetImporter<Options, Result>;
+/**
+ * An import or export that can't be done, for a reason people can be told:
+ * the grid shows `reason` in its hint, while `message` is for developers.
+ * `code` tells the cases apart, such as `'locked'`.
+ */
+export declare class SheetFileError<Code extends string = string> extends Error {
+    readonly code: Code;
+    readonly reason: string;
+    name: string;
+    constructor(message: string, code: Code, reason: string, options?: ErrorOptions);
+}
+/** What to tell people of a failed import or export: an error's `reason` when it gives one. */
+export declare function reasonOf(error: unknown): string;
+/** Whether an importer takes a file, by its name, type or first bytes. */
+export declare function importerTakes(importer: SheetImporter, file: Blob): Promise<boolean>;
+/** The first importer that takes a file, or `undefined`. */
+export declare function findImporter(importers: readonly SheetImporter[], file: Blob): Promise<SheetImporter<any, SheetImportResult> | undefined>;
+/** How a source reads a workbook. */
+export interface SheetFileSourceOptions {
+    scope?: SheetExportScope;
+    /** The sheet for `'sheet'` and `'selection'`; the first by default. */
+    sheet?: number;
+    /** For `'selection'` (or to write part of a sheet): the cells. */
+    bounds?: SheetBounds;
+    /** What formulas come to, by sheet key; a new engine works them out by default. */
+    result?: (key: string, row: number, col: number) => SheetResult;
+    cellTypes?: ReadonlyMap<string, SheetCellType>;
+    functions?: readonly SheetFunction[];
+    locale?: string;
+    messages?: SheetMessages;
+    /** The grid's default column width in px; `96` by default. */
+    colWidth?: number;
+    /** The grid's default row height in px; `28` by default. */
+    rowHeight?: number;
+    /** Works out a formula as if it were in a cell of a sheet, by key, for conditional formats; with `result`. */
+    evaluate?: (formula: string, key: string) => unknown;
+    signal?: AbortSignal;
+    view?: SheetFileView;
+}
+/** The cell types by name: the built-in ones, then these, the first named winning. */
+export declare function cellTypeMap(added?: readonly SheetCellType[]): Map<string, SheetCellType>;
+/** What exporters read: a workbook and how its cells show. */
+export declare function createFileSource(book: SheetWorkbook, options?: SheetFileSourceOptions): SheetFileSource;
+/** Options of `exportWorkbook`. */
+export interface SheetExportWorkbookOptions<Options = any> {
+    /** The extensions whose cell types and functions the workbook uses. */
+    extensions?: (SheetExtension | SheetExtension[])[];
+    /** `'workbook'` by default, or the exporter's first scope when it can't. */
+    scope?: SheetExportScope;
+    /** The sheet, by index, `id` or name, for `'sheet'` and `'selection'`; the first by default. */
+    sheet?: SheetRef;
+    /** The cells, such as `'A1:D20'`, for `'selection'`. */
+    range?: string;
+    locale?: string;
+    messages?: SheetMessages;
+    /** The default column width and row height in px the workbook is laid out with, as `DouSheet`'s `col-width` and `row-height`. */
+    colWidth?: number;
+    rowHeight?: number;
+    signal?: AbortSignal;
+    /** Passed on to the exporter. */
+    options?: Options;
+}
+/** The scope an exporter writes: the one asked for when it can, otherwise its first. */
+export declare function scopeFor(exporter: SheetExporter, asked?: SheetExportScope): SheetExportScope;
+/** An exporter's output as a `Blob`. */
+export declare const toBlob: (out: Blob | string, mime: string) => Blob;
+/**
+ * Writes a workbook with an exporter, without a grid: in a script, a
+ * worker or on a server. Formulas are worked out on the way.
+ */
+export declare function exportWorkbook<Exporter extends SheetExporter>(book: SheetWorkbook, exporter: Exporter, options?: SheetExportWorkbookOptions<OptionsOf<Exporter>>): Promise<Blob>;
+/** Options of `readWorkbook`. */
+export interface SheetReadWorkbookOptions<Options = any> {
+    locale?: string;
+    messages?: SheetMessages;
+    signal?: AbortSignal;
+    /** Passed on to the importer. */
+    options?: Options;
+}
+/** Reads a file with an importer, without a grid. */
+export declare function readWorkbook<Importer extends SheetImporter>(file: Blob, importer: Importer, options?: SheetReadWorkbookOptions<OptionsOf<Importer>>): Promise<ResultOf<Importer>>;
+/** The name of a file without its extension, for a sheet's name. */
+export declare const baseName: (file: Blob) => string;
+/** Options of the CSV exporter. */
+export interface SheetCSVExportOptions {
+    /** `,` by default. */
+    delimiter?: string;
+    /** Starts with a byte order mark, so programs that guess the encoding read it as UTF-8. On by default. */
+    bom?: boolean;
+    /**
+     * Writes what the cells show (`¥1,280.00`, `2026年3月5日`) instead of
+     * values a spreadsheet can sort and add up (`1280`, `2026-03-05`, what
+     * formulas come to). Off by default.
+     */
+    text?: boolean;
+    /** Writes formulas as written instead of what they come to. Ignored with `text`. */
+    formulas?: boolean;
+    /** Line breaks between rows; `\r\n` by default. */
+    newline?: string;
+    /** Puts a `'` before text a spreadsheet program would run as a formula. On by default. */
+    escapeFormulas?: boolean;
+}
+/** CSV: one sheet (or the selected cells), with the cells' values. */
+export declare const csvExporter: SheetExporter<SheetCSVExportOptions>;
+/** CSV and tab-separated text: a new sheet named after the file. */
+export declare const csvImporter: SheetImporter<unknown, {
+    book: {
+        version: 1;
+        sheets: {
+            name: string;
+            cells: import("./model").SheetRow[];
+        }[];
+    };
+}>;
+/** A label as text. */
+export declare const fileLabel: (label: SheetLabel, messages: SheetMessages) => string;
+/**
+ * Puts the built-in exporters (or importers) and the extensions' together,
+ * by name: an extension's replaces a built-in one of the same name; two
+ * extensions with the same name are an error.
+ */
+export declare function mergeFileHandlers<T extends {
+    name: string;
+}>(builtin: readonly T[], added: readonly {
+    extension: string;
+    handler: T;
+}[], kind: 'exporter' | 'importer'): T[];
+export {};

package/dist/types/core/fill.d.ts

@@ -0,0 +1,23 @@
+import type { SheetValue } from './model';
+/**
+ * How the fill handle fills: `auto` continues runs it recognises and
+ * copies a single number; `series` also counts a single number up by one;
+ * `copy` only repeats.
+ */
+export type SheetFillMode = 'auto' | 'series' | 'copy';
+export interface SheetFillOptions {
+    /** @default 'auto' */
+    mode?: SheetFillMode;
+    /**
+     * The values are in reverse, filling up or left: a single value counts
+     * down.
+     */
+    back?: boolean;
+}
+/** The `count` values that follow `values`, as the fill handle continues them. */
+export declare function continueValues(values: readonly SheetValue[], count: number, options?: SheetFillOptions): SheetValue[];
+/**
+ * Whether filling in `auto` mode continues the values rather than copying
+ * them. Ctrl / ⌘ while dragging the fill handle does the other.
+ */
+export declare function fillContinues(values: readonly SheetValue[]): boolean;

package/dist/types/core/find.d.ts

@@ -0,0 +1,39 @@
+/** What to look for in the cells, and how. */
+export interface SheetSearchQuery {
+    /** The text to find. */
+    search: string;
+    /** What `replace` puts in place of each match. */
+    replace?: string;
+    /** Tells upper and lower case apart. */
+    caseSensitive?: boolean;
+    /** A cell matches only when its whole text is the search, not when it contains it. */
+    wholeCell?: boolean;
+    /**
+     * Where to look: `'values'` (the default) reads the text cells show, a
+     * formula's result included; `'formulas'` reads what was typed, so a
+     * formula is found by the formula itself.
+     */
+    lookIn?: 'values' | 'formulas';
+    /** Which cells: the sheet shown (the default) or every sheet of the workbook. */
+    scope?: 'sheet' | 'workbook';
+}
+/** A cell that matches, on the sheet with index `sheet`. */
+export interface SheetMatch {
+    sheet: number;
+    row: number;
+    col: number;
+}
+/**
+ * Tells whether a cell's text matches the query; `null` when there is
+ * nothing to look for.
+ */
+export declare function cellMatcher(query: SheetSearchQuery): ((text: string) => boolean) | null;
+/**
+ * The text with every match of the query replaced; the text as it is when
+ * nothing in it matches. With `wholeCell` the whole text is replaced.
+ */
+export declare function replaceInText(text: string, query: SheetSearchQuery): string;
+/** Whether `a` comes before `b`: by sheet, then row, then column. */
+export declare const foundBefore: (a: SheetMatch, b: SheetMatch) => boolean;
+/** The index of the first match at or after `at` (wrapping round to the first); `-1` for none. */
+export declare function foundFrom(list: readonly SheetMatch[], at: SheetMatch): number;

package/dist/types/core/format.d.ts

@@ -0,0 +1,47 @@
+import type { SheetValue } from './model';
+/** Whether a format has date parts, outside quoted and escaped text. */
+export declare const isDateFormat: (format: string) => boolean;
+/** Up to 15 significant digits, so 0.1 + 0.2 shows as 0.3. */
+export declare function generalNumber(value: number): string;
+/**
+ * A value as the cell shows it, with its format. `locale` names the
+ * language for weekdays (`ddd`, `dddd`).
+ */
+export declare function formatValue(value: SheetValue | undefined, format?: string, locale?: string): string;
+/** Text as it shows: `'=…` is text starting with `=`, shown without its mark. */
+export declare const textOf: (value: string) => string;
+/**
+ * A number without a format, in at most `chars` characters, for a cell
+ * too narrow for all its digits: fewer decimals first, then `1.2E+11`.
+ * Only what the cell shows changes, never the value.
+ */
+export declare function fitNumber(value: number, chars: number): string;
+/**
+ * A number format with `by` more digits after the point, or fewer when
+ * `by` is below 0, as the toolbar's buttons change it: `0.00` → `0.000`,
+ * `#,##0` → `#,##0.0`, `0.0%` → `0%`. Without a format it starts from the
+ * digits `value` shows. Date, time and text formats stay as they are.
+ */
+export declare function changeDecimals(format: string | undefined, value: SheetValue, by: number): string | undefined;
+/**
+ * How a value lines up in its cell unless its style says otherwise:
+ * numbers, dates and times to the right, `TRUE` and `FALSE` in the middle,
+ * text to the left.
+ */
+export declare function alignOf(value: SheetValue | undefined): 'left' | 'center' | 'right';
+/** What typing `text` into a cell writes: the value, and a format when the text implies one. */
+export interface SheetInput {
+    value: SheetValue;
+    format?: string;
+}
+/**
+ * Reads typed text: numbers (with thousands commas, `12%`, `¥1,200.50`),
+ * `TRUE` and `FALSE`, dates (`2026-10-31`, `2026/3/5`, `2026.3.5`, with a
+ * time or not), times (`9:30`), formulas (`=…`) and text. A leading `'`
+ * keeps the rest as text. Dates and times are written the standard way
+ * (`2026-03-05`, `09:30`); when typed another way, the format shows them
+ * as typed.
+ */
+export declare function parseInput(text: string): SheetInput;
+/** The text a cell's editor starts with: what was typed, so editing it changes nothing. */
+export declare function inputText(value: SheetValue | undefined): string;

package/dist/types/core/group.d.ts

@@ -0,0 +1,76 @@
+import type { SheetData, SheetGroup } from './model';
+/** How deep groups may nest. */
+export declare const MAX_GROUP_DEPTH = 8;
+/** How wide each lane of the outline beside the headers is. */
+export declare const OUTLINE_LANE = 16;
+type Axis = 'row' | 'col';
+/** A group of a sheet, laid out. */
+export interface SheetGroupLines {
+    /** Its place in the sheet's `groups`. */
+    index: number;
+    axis: Axis;
+    /** Its first and last line. */
+    start: number;
+    end: number;
+    /** 1 for a group inside no other. */
+    depth: number;
+    collapsed: boolean;
+}
+/** The lines a group's range covers, or `null` when it isn't whole rows or columns. */
+export declare function groupSpan(range: string): {
+    axis: Axis;
+    start: number;
+    end: number;
+} | null;
+/** A group's range for its lines: `'3:8'` or `'B:D'`. */
+export declare const groupRange: (axis: Axis, start: number, end: number) => string;
+/** One axis of a sheet's groups. */
+export declare class SheetGroupAxis {
+    /** Outer groups before the ones inside them. */
+    readonly list: readonly SheetGroupLines[];
+    /** Groups left out for crossing another or nesting too deep. */
+    readonly dropped: number;
+    /** Lines inside a folded group. */
+    readonly hidden: Set<number>;
+    /** The deepest a group nests; `0` without groups. */
+    readonly depth: number;
+    constructor(
+    /** Outer groups before the ones inside them. */
+    list: readonly SheetGroupLines[], 
+    /** Groups left out for crossing another or nesting too deep. */
+    dropped: number);
+    /** The groups around a line, outer first. */
+    around(line: number): SheetGroupLines[];
+    /** The group with exactly these lines. */
+    find(start: number, end: number): SheetGroupLines | undefined;
+    /**
+     * The line a group's button sits on: its summary line, before or after
+     * it; the other side when that line is missing or inside a group beside
+     * it; `-1` when neither side will do.
+     */
+    buttonLine(g: SheetGroupLines, count: number, summary?: SheetGroupSummary): number;
+    /**
+     * Why lines can't be grouped: a group they would cross, or `'deep'` for
+     * nesting more than eight deep; `null` when they can.
+     */
+    problem(start: number, end: number): {
+        cross: SheetGroupLines;
+    } | 'deep' | null;
+    /** The groups at a depth that sit right beside these lines, inside the same parent. */
+    beside(start: number, end: number): SheetGroupLines[];
+}
+/** Which side of a group holds its heading or subtotal, and its button. */
+export type SheetGroupSummary = 'before' | 'after';
+/** The groups of a sheet, laid out per axis. */
+export declare class SheetGroups {
+    static readonly EMPTY: SheetGroups;
+    readonly rows: SheetGroupAxis;
+    readonly cols: SheetGroupAxis;
+    constructor(groups: readonly SheetGroup[] | undefined, 
+    /** Whether a group is folded, when it isn't what the sheet says. */
+    collapsed?: (group: SheetGroup, index: number) => boolean);
+    axis(axis: Axis): SheetGroupAxis;
+}
+/** A sheet's groups, read once per list. */
+export declare function groupsOf(sheet: SheetData): SheetGroups;
+export {};

package/dist/types/core/history.d.ts

@@ -0,0 +1,27 @@
+import { type SheetTransaction } from './transaction';
+import type { SheetWorkbook } from './model';
+import type { SheetSelection } from './selection';
+/** What an undo or redo puts back: the sheet and the selection that went with the change. */
+export interface SheetHistoryView {
+    /** The sheet's key (`id`, or its name), so it is found again after sheets move. */
+    sheet: string;
+    selection: SheetSelection;
+}
+export declare class SheetHistory {
+    private depth;
+    private done;
+    private undone;
+    constructor(depth?: number);
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    record(tr: SheetTransaction, before: SheetHistoryView, after: SheetHistoryView, now?: number): void;
+    undo(doc: SheetWorkbook): {
+        tr: SheetTransaction;
+        view: SheetHistoryView;
+    } | null;
+    redo(doc: SheetWorkbook): {
+        tr: SheetTransaction;
+        view: SheetHistoryView;
+    } | null;
+    clear(): void;
+}

package/dist/types/core/index.d.ts

@@ -0,0 +1,33 @@
+export { createFileSource, csvExporter, csvImporter, defineSheetExporter, defineSheetImporter, SheetFileError, exportWorkbook, readWorkbook, } from './file';
+export type { SheetCSVExportOptions, SheetExporter, SheetExporterInfo, SheetExportScope, SheetExportWorkbookOptions, SheetFileSheet, SheetFileSource, SheetFileSourceOptions, SheetFileView, SheetImportContext, SheetImporter, SheetImporterInfo, SheetImportResult, SheetImportWarning, SheetReadWorkbookOptions, } from './file';
+export { boundsOf, columnIndex, columnName, formatCell, formatRange, moveReferences, dropReferences, renameReferences, renameReferencesAll, parseCell, parseRange, quoteSheet, shiftFormula, splitSheet, } from './address';
+export { detectDelimiter, parseCSV, readCSV, sheetToCSV } from './csv';
+export type { SheetCSVReadOptions, SheetCSVWriteOptions } from './csv';
+export type { SheetBounds, SheetCellTarget, SheetPoint, SheetRange, SheetRefMap } from './address';
+export { defineSheetExtension } from './extension';
+export type { SheetExtension, SheetUpdate } from './extension';
+export { keepCommentAnchors, sheetCommentAnchors } from './comments';
+export { diffWorkbooks, restoreWorkbook } from './versions';
+export type { SheetCellChange, WorkbookDiff } from './versions';
+export type { SheetCommentAnchor } from './comments';
+export type { SheetClip } from './clipboard';
+export type { SheetLabel } from './commands';
+export { defineSheetCellType, optionOf } from './cell-type';
+export type { SheetCellType, SheetDrawContext, SheetDrawRect, SheetDrawTextOptions, SheetResolvedType, } from './cell-type';
+export { cellOf, valueOf } from './model';
+export { checkWorkbook, emptyWorkbook, migrateWorkbook } from './document';
+export type { CheckWorkbookOptions, WorkbookProblem } from './document';
+export type { SheetCell, SheetCellInput, SheetColor, SheetCondition, SheetConditionalAverage, SheetConditionalBar, SheetConditionalDuplicates, SheetConditionalFormat, SheetConditionalFormula, SheetConditionalRank, SheetConditionalScale, SheetConditionalStyle, SheetConditionalUnique, SheetConditionalWhen, SheetData, SheetFilter, SheetFilterRule, SheetFreeze, SheetProtection, SheetRow, SheetRuleRange, SheetSelectOption, SheetSortOrder, SheetStyle, SheetTypeSetup, SheetValidation, SheetValidationFormula, SheetValidationList, SheetValidationWhen, SheetValue, SheetWorkbook, } from './model';
+export { compareForSort, meetsRule, sortRows, textCollator } from './data';
+export type { SheetSortKey } from './data';
+export { changeDecimals, formatValue, parseInput } from './format';
+export type { SheetInput } from './format';
+export { lightThemeColor, plainStyle } from './paint';
+export { sheetMessagesFor, sheetLocales } from '../locale';
+export type { SheetFileMessages, SheetMessages } from '../locale';
+export { checkProtection, isLocked, protectionOf } from './protect';
+export { linkTarget } from './link';
+export type { SheetLinkTarget } from './link';
+export type { SheetProtectionCheck, SheetProtectionRefusal } from './protect';
+export { applySheetSteps, compactSheetSteps, sheetKey, SheetTransaction } from './transaction';
+export type { SheetAction, SheetAxisName, SheetCellAt, SheetLinesAt, SheetBookPatch, SheetPatch, SheetRangeAt, SheetRef, SheetStep, SheetStylePatch, SheetTransactionMeta, } from './transaction';

package/dist/types/core/link.d.ts

@@ -0,0 +1,14 @@
+import { type SheetRange } from './address';
+/** Where a link goes: a web page or app, or cells of the workbook. */
+export type SheetLinkTarget = {
+    kind: 'web';
+    href: string;
+} | {
+    kind: 'cell';
+    sheet?: string;
+    range: SheetRange;
+};
+/** Where a link goes, or `null` for one that isn't followed, such as `javascript:`. */
+export declare function linkTarget(link: string | undefined): SheetLinkTarget | null;
+/** Whether typed text is a web address, which then becomes the cell's link. */
+export declare const isTypedLink: (text: string) => boolean;

package/dist/types/core/merge.d.ts

@@ -0,0 +1,26 @@
+import { type SheetBounds, type SheetPoint } from './address';
+import type { SheetData } from './model';
+/** The merged ranges of a sheet, read once, with quick lookups by cell. */
+export declare class SheetMerges {
+    readonly list: readonly SheetBounds[];
+    static readonly EMPTY: SheetMerges;
+    /** By row, the merges that cover it. */
+    private byRow;
+    constructor(list: readonly SheetBounds[]);
+    get size(): number;
+    /** The merge covering a cell, or `undefined`. */
+    at(row: number, col: number): SheetBounds | undefined;
+    /** The merges that cover a row. */
+    inRow(row: number): readonly SheetBounds[];
+    /** The top left cell of the merge a cell is in, or the cell itself. */
+    anchor(point: SheetPoint): SheetPoint;
+    /** The cell's bounds: its merge, or just itself. */
+    cell(point: SheetPoint): SheetBounds;
+    /** Grows a range until no merge sticks out of it. */
+    expand(range: SheetBounds): SheetBounds;
+    /** The merges that touch a range. */
+    touching(range: SheetBounds): SheetBounds[];
+}
+/** A sheet's merges, read once per list. Ranges that aren't ranges, or are one cell, are left out. */
+export declare function mergesOf(sheet: SheetData): SheetMerges;
+export declare const overlaps: (a: SheetBounds, b: SheetBounds) => boolean;