@svgrid/enterprise 3.0.2 → 3.1.0

package/dist/sheet/sheet-kinds.js

@@ -0,0 +1,91 @@
+/**
+ * What kind of thing a sheet tab is.
+ *
+ * A workbook's tabs have always been cell grids. A `grid` tab is the other
+ * thing a business workbook wants: a data-bound table, backed by records
+ * rather than by cells, sorted and filtered and edited as a grid rather
+ * than as a sheet.
+ *
+ * The trick that makes this cheap rather than a second engine: **a grid
+ * sheet PROJECTS its records into the workbook's cells.** The records are
+ * the truth, and after every change they are written into the same
+ * `string[][]` a cell sheet keeps, header row included. So
+ * `=SUM(Orders!D2:D99)` on a cell sheet reads a grid sheet with no new
+ * machinery at all: the formula engine, the dependency graph, the file
+ * writers and the printer never learn that this tab is different.
+ *
+ * The projection runs through `setRaw`, which ignores a write that changes
+ * nothing, so editing one field of one record rewrites one cell and
+ * recalculates what depended on it, not the sheet.
+ *
+ * What a grid sheet deliberately does NOT do: hold a formula of its own.
+ * Its cells are a rendering of its records, so anything typed into them
+ * would be overwritten by the next projection. A sheet that needs formulas
+ * beside the data is a cell sheet reading the grid one across.
+ */
+import { sheetCellsFromRows } from './from-rows.js';
+export const emptyGridSheet = () => ({ fields: [], rows: [] });
+/** The cells a grid sheet stands for: the header, the records, the totals. */
+export function projectGridSheet(spec) {
+    return sheetCellsFromRows(spec.rows, spec.fields, spec.totals ? { totals: true } : {});
+}
+/**
+ * Where a record sits in the projection.
+ *
+ * Row 0 is the header, so record `i` is at row `i + 1`. Kept as a function
+ * rather than inlined so the offset is named in one place: getting it
+ * wrong reads the header as a record and is silent.
+ */
+export const rowOfRecord = (index) => index + 1;
+export const recordOfRow = (row) => row - 1;
+/** Is this row of the projection a record, rather than a header or total? */
+export const isRecordRow = (spec, row) => row >= 1 && row <= spec.rows.length;
+/**
+ * A field's column in the projection, or -1.
+ *
+ * Matched on the field name rather than the label, since two columns may
+ * share a label and the name is what the record is keyed by.
+ */
+export const columnOfField = (spec, field) => spec.fields.findIndex((f) => f.field === field);
+/** A deep-enough copy for a document snapshot. */
+export const copyGridSheet = (spec) => ({
+    fields: spec.fields.map((f) => ({ ...f })),
+    rows: spec.rows.map((r) => ({ ...r })),
+    ...(spec.editable !== undefined ? { editable: spec.editable } : {}),
+    ...(spec.totals !== undefined ? { totals: spec.totals } : {}),
+});
+/**
+ * A value typed into a grid sheet, coerced to the field's type.
+ *
+ * The grid hands back whatever its editor produced, which for a number
+ * column typed into by hand is a string. Storing that would make the
+ * record's shape depend on how it was edited, so it is narrowed here once.
+ */
+export function coerceFieldValue(field, value) {
+    if (value === null || value === undefined || value === '')
+        return value === '' ? '' : null;
+    switch (field.type) {
+        case 'number': {
+            const n = typeof value === 'number' ? value : Number(String(value).trim());
+            return Number.isFinite(n) ? n : value;
+        }
+        case 'boolean': {
+            if (typeof value === 'boolean')
+                return value;
+            const text = String(value).trim().toLowerCase();
+            if (text === 'true' || text === 'yes' || text === '1')
+                return true;
+            if (text === 'false' || text === 'no' || text === '0')
+                return false;
+            return value;
+        }
+        case 'date': {
+            if (value instanceof Date)
+                return value;
+            const text = String(value).trim();
+            return text === '' ? null : text;
+        }
+        default:
+            return typeof value === 'string' ? value : String(value);
+    }
+}

package/dist/sheet/shortcuts.d.ts

@@ -39,7 +39,7 @@ export declare function formatAllowed(target: SheetFormatTarget, rects: Readonly
 /** Attach the store the formatting shortcuts write to. */
 export declare function setFormatTarget(target: SheetFormatTarget | null): void;
 export declare function getFormatTarget(): SheetFormatTarget | null;
-export declare function setWorkbook(next: Workbook | null, onChange?: () => void): void;
+export declare function setWorkbook(next: Workbook | null, onChange?: () => void, isHidden?: (name: string) => boolean): void;
 export declare function getWorkbook(): Workbook | null;
 /** Move `delta` sheets from the active one. Excel does NOT wrap at the ends,
  *  so neither does this: hitting the last sheet and pressing again should
@@ -57,7 +57,7 @@ export declare function setFindReplaceHandler(fn: ((cmd: GridCommandContext) =>
  * answers them the way it answers the ribbon button; returning false means
  * nothing is behind the action and the key falls through.
  */
-export type RibbonKeyAction = 'recalculate' | 'toggle-formulas' | 'toggle-filter' | 'insert-function' | 'name-manager' | 'insert-table' | 'hide-rows' | 'hide-columns' | 'unhide-rows' | 'unhide-columns' | 'edit-comment' | 'open-list' | 'toggle-ribbon' | 'merge-center' | 'merge-across' | 'merge-cells' | 'unmerge-cells';
+export type RibbonKeyAction = 'file-open' | 'file-save-xlsx' | 'file-print' | 'recalculate' | 'toggle-formulas' | 'toggle-filter' | 'insert-function' | 'name-manager' | 'insert-table' | 'hide-rows' | 'hide-columns' | 'unhide-rows' | 'unhide-columns' | 'edit-comment' | 'open-list' | 'toggle-ribbon' | 'insert-link' | 'merge-center' | 'merge-across' | 'merge-cells' | 'unmerge-cells' | 'cut';
 export declare function setRibbonActionHandler(fn: ((action: RibbonKeyAction, cmd: GridCommandContext) => boolean) | null): void;
 /** Raise a ribbon action from a button whose face is not an entry of its own. */
 export declare function raiseRibbonAction(action: RibbonKeyAction, cmd: GridCommandContext): boolean;
@@ -70,6 +70,8 @@ export declare function activeEntry(cmd: GridCommandContext): CellFormatEntry |
 /** Excel's Increase / Decrease Font Size: the next rung of the ladder. */
 export declare function nudgeFontSize(direction: 1 | -1): SheetCommand;
 export declare function setFormatDialogHandler(fn: ((cmd: GridCommandContext) => void) | null): void;
+export declare function setShortcutOwner(token: object | null): void;
+export declare function getShortcutOwner(): object | null;
 export type SheetBinding = {
     /** Matched case-insensitively against `event.key`. */
     key: string;
@@ -147,9 +149,17 @@ export declare function applyBorders(cmd: GridCommandContext, preset: BorderPres
 /** Excel's Clear Formats: drop every format on the selection, keep the values. */
 export declare function clearFormats(cmd: GridCommandContext): boolean;
 export declare function preset(name: FormatPresetName): SheetCommand;
-/** Alt+=. Inserts =SUM(range) over the run Excel would guess. */
+/**
+ * Alt+=. Proposes =SUM(range) over the run Excel would guess. With one cell
+ * selected the formula is opened in the cell's editor rather than written,
+ * as Excel's AutoSum does: the guess is often a row short, and the editor is
+ * where it gets corrected before Enter takes it. A wider selection has the
+ * sum written into the active cell outright.
+ */
 export declare const autoSum: SheetCommand;
 export declare const SHEET_BINDINGS: ReadonlyArray<SheetBinding>;
+/** Shift+F11 and the ribbon's Insert Sheet: a new sheet after the last, made active. */
+export declare function newSheet(): boolean;
 export declare function structural(cmd: GridCommandContext, kind: 'insert' | 'delete'): boolean;
 /**
  * The handler registered with the grid. Returns true when a binding ran, which

package/dist/sheet/shortcuts.js

@@ -30,9 +30,12 @@ export function getFormatTarget() {
  */
 let workbook = null;
 let onWorkbookChange = null;
-export function setWorkbook(next, onChange) {
+/** Which sheets are hidden, so Ctrl+PageUp and PageDown step over them. */
+let sheetHidden = null;
+export function setWorkbook(next, onChange, isHidden) {
     workbook = next;
     onWorkbookChange = onChange ?? null;
+    sheetHidden = isHidden ?? null;
 }
 export function getWorkbook() {
     return workbook;
@@ -48,7 +51,10 @@ export function switchSheet(delta) {
     const at = sheets.indexOf(wb.active);
     if (at < 0)
         return false;
-    const next = at + delta;
+    // The next sheet that shows; a hidden one is stepped over, as in Excel.
+    let next = at + delta;
+    while (next >= 0 && next < sheets.length && sheetHidden?.(sheets[next]))
+        next += delta;
     if (next < 0 || next >= sheets.length)
         return false;
     wb.setActive(sheets[next]);
@@ -108,6 +114,22 @@ let onFormatDialog = null;
 export function setFormatDialogHandler(fn) {
     onFormatDialog = fn;
 }
+/**
+ * Which component the targets above belong to. Every one of them is a
+ * module-level singleton, so with two sheets on a page (a collaboration
+ * demo, a docs page with an example per section) the keys, the ribbon's
+ * buttons and its pressed states all went to whichever sheet mounted last:
+ * Ctrl+B bolded a cell three examples down. A sheet claims the targets when
+ * the pointer or the focus lands in it, and on unmount lets go only of what
+ * is still its own, so tearing one sheet down cannot disarm another.
+ */
+let owner = null;
+export function setShortcutOwner(token) {
+    owner = token;
+}
+export function getShortcutOwner() {
+    return owner;
+}
 /** Read the grid through the command context as a blank-aware matrix. */
 export function gridOf(cmd) {
     return {
@@ -452,7 +474,13 @@ function rectOfActive(cmd) {
 export function preset(name) {
     return (cmd) => applyFormat(cmd, { numFmt: FORMAT_PRESETS[name] });
 }
-/** Alt+=. Inserts =SUM(range) over the run Excel would guess. */
+/**
+ * Alt+=. Proposes =SUM(range) over the run Excel would guess. With one cell
+ * selected the formula is opened in the cell's editor rather than written,
+ * as Excel's AutoSum does: the guess is often a row short, and the editor is
+ * where it gets corrected before Enter takes it. A wider selection has the
+ * sum written into the active cell outright.
+ */
 export const autoSum = (cmd) => {
     const active = cmd.activeCell;
     if (!active)
@@ -464,7 +492,12 @@ export const autoSum = (cmd) => {
         return false;
     const [minRow, minCol, maxRow, maxCol] = range;
     const ref = (r, c) => formatA1({ col: c, colAbs: false, row: r, rowAbs: false, sheet: null });
-    cmd.setCellValue(active.rowIndex, active.colIndex, `=SUM(${ref(minRow, minCol)}:${ref(maxRow, maxCol)})`);
+    const formula = `=SUM(${ref(minRow, minCol)}:${ref(maxRow, maxCol)})`;
+    const last = cmd.ranges[cmd.ranges.length - 1];
+    const oneCell = !last || (last[0] === last[2] && last[1] === last[3]);
+    if (oneCell && cmd.startEditing(active.rowIndex, active.colIndex, formula))
+        return true;
+    cmd.setCellValue(active.rowIndex, active.colIndex, formula);
     return true;
 };
 export const SHEET_BINDINGS = [
@@ -525,10 +558,16 @@ export const SHEET_BINDINGS = [
     { key: 'l', mod: true, shift: true, run: raise('toggle-filter'), label: 'Filter' },
     { key: 'F3', shift: true, run: raise('insert-function'), label: 'Insert Function' },
     { key: 'F2', shift: true, run: raise('edit-comment'), label: 'Insert or edit the comment on the active cell' },
+    { key: 'k', mod: true, run: raise('insert-link'), label: 'Insert or edit the link on the active cell' },
     { key: 'ArrowDown', alt: true, run: raise('open-list'), label: 'Open the list a validated cell offers' },
     { key: 'F1', mod: true, run: raise('toggle-ribbon'), label: 'Collapse or expand the ribbon' },
     { key: 'F3', mod: true, run: raise('name-manager'), label: 'Name Manager' },
     { key: 't', mod: true, run: raise('insert-table'), label: 'Format as Table' },
+    // The File tab's keys. The browser's own Open and Save are what they
+    // replace, as in Excel; with no shell to answer them they fall through.
+    { key: 'o', mod: true, run: raise('file-open'), label: 'Open' },
+    { key: 's', mod: true, run: raise('file-save-xlsx'), label: 'Save As' },
+    { key: 'p', mod: true, run: raise('file-print'), label: 'Print' },
     // Structure. Like the format bindings, these decline when nothing is
     // attached. Excel opens a dialog for an ambiguous selection; deciding what
     // that looks like is the consumer's, so an ambiguous selection declines and
@@ -541,12 +580,22 @@ export const SHEET_BINDINGS = [
     { key: '0', code: 'Digit0', mod: true, run: raise('hide-columns'), label: 'Hide the selected columns' },
     { key: '(', code: 'Digit9', mod: true, shift: true, run: raise('unhide-rows'), label: 'Unhide rows in the selection' },
     { key: ')', code: 'Digit0', mod: true, shift: true, run: raise('unhide-columns'), label: 'Unhide columns in the selection' },
+    // Ctrl+H is Excel's Replace and Ctrl+F its Find; the shell has one dialog
+    // for both, so both open it. Ctrl+F is the browser's find otherwise, and a
+    // spreadsheet user who presses it wants the cells searched, as in Excel
+    // and Sheets; the browser's is a keystroke away with the sheet unfocused.
     { key: 'h', mod: true, run: (cmd) => {
             if (!onFindReplace || !getFindTarget())
                 return false;
             onFindReplace(cmd);
             return true;
         }, label: 'Find and Replace' },
+    { key: 'f', mod: true, run: (cmd) => {
+            if (!onFindReplace || !getFindTarget())
+                return false;
+            onFindReplace(cmd);
+            return true;
+        }, label: 'Find' },
     { key: 'v', mod: true, shift: true, run: (cmd) => {
             if (!onPasteSpecial)
                 return false;
@@ -557,15 +606,17 @@ export const SHEET_BINDINGS = [
     // grid leaves Ctrl+PageDown to the browser.
     { key: 'PageDown', mod: true, run: () => switchSheet(1), label: 'Next sheet' },
     { key: 'PageUp', mod: true, run: () => switchSheet(-1), label: 'Previous sheet' },
-    { key: 'F11', shift: true, run: () => {
-            const wb = workbook;
-            if (!wb)
-                return false;
-            wb.addSheet();
-            onWorkbookChange?.();
-            return true;
-        }, label: 'New sheet' },
+    { key: 'F11', shift: true, run: () => newSheet(), label: 'New sheet' },
 ];
+/** Shift+F11 and the ribbon's Insert Sheet: a new sheet after the last, made active. */
+export function newSheet() {
+    const wb = workbook;
+    if (!wb)
+        return false;
+    wb.addSheet();
+    onWorkbookChange?.();
+    return true;
+}
 export function structural(cmd, kind) {
     if (!getStructureTarget())
         return false;

package/dist/sheet/sort.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Excel's sort order over a block of rows, by one key or several.
+ *
+ * The rules that make a sheet's sort read as Excel's: numbers before text
+ * before booleans and errors, blanks last whichever way the sort runs,
+ * text without regard to case, a stable order so a tie keeps the rows as
+ * they were, and each key only consulted when the ones before it tie.
+ */
+import { type CellValue } from './ast.js';
+export type SortDirection = 'asc' | 'desc';
+/**
+ * What a key sorts on. Excel's "Sort On" list: the cell's value, or one of
+ * its colours.
+ */
+export type SortOn = 'value' | 'fill' | 'color';
+export type SortKey = {
+    /** The column the key reads, as a sheet column index. */
+    col: number;
+    direction: SortDirection;
+    /** What the key reads in that column. Absent means the value. */
+    on?: SortOn;
+    /**
+     * The colour this key puts first, for a colour key: Excel sorts ONE
+     * colour to the top (ascending) or the bottom (descending) and leaves
+     * every other row where it was. Absent leaves the key doing nothing.
+     */
+    colour?: string;
+};
+/**
+ * The rows in sorted order. `rows` are the row indexes of the block's data
+ * rows (the header left out), `valueAt` reads a computed cell.
+ */
+export declare function sortOrder(rows: ReadonlyArray<number>, keys: ReadonlyArray<SortKey>, valueAt: (row: number, col: number) => CellValue, 
+/**
+ * The colours a cell carries, for a key that sorts on one: its fill and
+ * its font colour, each as it is written, or null. Only a colour key
+ * calls it.
+ */
+colourAt?: (row: number, col: number, on: 'fill' | 'color') => string | null): number[];
+/**
+ * Excel's guess at "my data has headers": the first row of the key column
+ * holds text and the row under it holds something that is not text. Given
+ * the block's columns it looks across them, as Excel does: a Name column
+ * over names says nothing, and the Pay column beside it, text over a
+ * number, is what says the first row is a header, so a sort by name does
+ * not carry "Name" down into the names.
+ */
+export declare function guessHeaderRow(valueAt: (row: number, col: number) => CellValue, top: number, col: number, columns?: {
+    left: number;
+    right: number;
+}): boolean;

package/dist/sheet/sort.js

@@ -0,0 +1,107 @@
+/**
+ * Excel's sort order over a block of rows, by one key or several.
+ *
+ * The rules that make a sheet's sort read as Excel's: numbers before text
+ * before booleans and errors, blanks last whichever way the sort runs,
+ * text without regard to case, a stable order so a tie keeps the rows as
+ * they were, and each key only consulted when the ones before it tie.
+ */
+import { isError } from './ast.js';
+import { isBlankValue } from './navigate.js';
+/** Excel's type order: numbers, then text, then booleans and errors. */
+function rank(v) {
+    if (isBlankValue(v))
+        return [3, ''];
+    if (typeof v === 'number')
+        return [0, v];
+    if (typeof v === 'boolean')
+        return [2, v ? 1 : 0];
+    if (isError(v))
+        return [2, 0];
+    return [1, String(v).toLowerCase()];
+}
+function compareValues(a, b, direction) {
+    const [ka, va] = rank(a);
+    const [kb, vb] = rank(b);
+    // A blank sorts last both ways, as in Excel.
+    if (ka === 3 || kb === 3)
+        return ka === kb ? 0 : ka === 3 ? 1 : -1;
+    if (ka !== kb)
+        return direction === 'asc' ? ka - kb : kb - ka;
+    const cmp = typeof va === 'number' && typeof vb === 'number' ? va - vb : String(va).localeCompare(String(vb));
+    return direction === 'asc' ? cmp : -cmp;
+}
+/**
+ * The rows in sorted order. `rows` are the row indexes of the block's data
+ * rows (the header left out), `valueAt` reads a computed cell.
+ */
+export function sortOrder(rows, keys, valueAt, 
+/**
+ * The colours a cell carries, for a key that sorts on one: its fill and
+ * its font colour, each as it is written, or null. Only a colour key
+ * calls it.
+ */
+colourAt) {
+    if (!keys.length)
+        return [...rows];
+    return rows
+        .map((row, index) => ({ row, index }))
+        .sort((a, b) => {
+        for (const key of keys) {
+            const cmp = key.on === 'fill' || key.on === 'color'
+                ? compareColours(a.row, b.row, key, colourAt)
+                : compareValues(valueAt(a.row, key.col), valueAt(b.row, key.col), key.direction);
+            if (cmp !== 0)
+                return cmp;
+        }
+        return a.index - b.index;
+    })
+        .map((entry) => entry.row);
+}
+/**
+ * A colour key: the rows wearing the chosen colour move to the top, or to
+ * the bottom when the key runs the other way, and everything else keeps the
+ * order it had.
+ *
+ * That is Excel's model and it is worth stating, because the obvious
+ * alternative, ordering colours among themselves, has no order to use: two
+ * colours are not greater or lesser than one another.
+ */
+function compareColours(rowA, rowB, key, colourAt) {
+    if (!key.colour || !colourAt || (key.on !== 'fill' && key.on !== 'color'))
+        return 0;
+    const wanted = key.colour.trim().toLowerCase();
+    const has = (row) => (colourAt(row, key.col, key.on) ?? '').trim().toLowerCase() === wanted;
+    const a = has(rowA);
+    const b = has(rowB);
+    if (a === b)
+        return 0;
+    return key.direction === 'asc' ? (a ? -1 : 1) : (a ? 1 : -1);
+}
+/**
+ * Excel's guess at "my data has headers": the first row of the key column
+ * holds text and the row under it holds something that is not text. Given
+ * the block's columns it looks across them, as Excel does: a Name column
+ * over names says nothing, and the Pay column beside it, text over a
+ * number, is what says the first row is a header, so a sort by name does
+ * not carry "Name" down into the names.
+ */
+export function guessHeaderRow(valueAt, top, col, columns) {
+    const isText = (v) => typeof v === 'string' && v !== '';
+    const headerOver = (c) => {
+        const below = valueAt(top + 1, c);
+        return isText(valueAt(top, c)) && !isText(below) && !isBlankValue(below);
+    };
+    if (!columns)
+        return headerOver(col);
+    let someHeader = false;
+    for (let c = columns.left; c <= columns.right; c += 1) {
+        const head = valueAt(top, c);
+        // A number or a blank in the first row is data, whatever is beside it.
+        if (!isBlankValue(head) && !isText(head))
+            return false;
+        if (headerOver(c))
+            someHeader = true;
+    }
+    return someHeader;
+}

package/dist/sheet/sparklines.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Sparklines: Excel's tiny chart drawn INSIDE a cell, one per row (or per
+ * column) of a block of numbers.
+ *
+ * Excel keeps them as a group rather than as one chart per cell: a data
+ * range, a location range of the same shape, and the settings the whole
+ * group shares (the kind, the colours, whether every line is drawn on one
+ * scale). That is what this keeps, because it is also what the user edits:
+ * changing the kind changes the group, and clearing one clears the group.
+ *
+ * A sparkline is not an object (`objects.ts`): it has no anchor and no size
+ * of its own, it IS the cell, so it moves and dies with the cells the way a
+ * conditional format does. Its data is read live from the range, so editing
+ * a number redraws it.
+ */
+import type { Rect } from './format-store.js';
+import type { StructuralEdit } from './refs.js';
+import type { CellValue } from './ast.js';
+/** The three Excel offers: Line, Column and Win/Loss. */
+export declare const SPARKLINE_TYPES: readonly ["line", "column", "winloss"];
+export type SheetSparklineType = (typeof SPARKLINE_TYPES)[number];
+export type SparklineGroup = {
+    id: string;
+    /** The cells the sparklines are drawn in: one row, or one column. */
+    location: Rect;
+    /** The numbers they read, one line of it per location cell. */
+    data: Rect;
+    type: SheetSparklineType;
+    /** The line or the positive bars. Defaults to the theme's accent. */
+    color?: string;
+    /** The negative bars of a Column or Win/Loss group. */
+    negativeColor?: string;
+    /** One value scale across the whole group, as Excel's "Same for All". */
+    sameScale?: boolean;
+    /** A dot on the last point of a Line group. */
+    markers?: boolean;
+};
+/** An id no other group of this session carries. */
+export declare const sparklineId: () => string;
+/** A copy safe to hand out or save. */
+export declare function copySparkline(group: SparklineGroup): SparklineGroup;
+/**
+ * The group after an insert or delete: both rectangles move with their
+ * cells. Null when the edit took every cell the group was drawn in, or
+ * every cell it read.
+ */
+export declare function shiftSparkline(group: SparklineGroup, edit: StructuralEdit): SparklineGroup | null;
+/** The groups of a sheet after an insert or delete, the gone ones dropped. */
+export declare function shiftSparklines(groups: ReadonlyArray<SparklineGroup>, edit: StructuralEdit): SparklineGroup[];
+/** True when the group draws down a column of cells rather than along a row. */
+export declare function isColumnLocation(group: SparklineGroup): boolean;
+/**
+ * The numbers one location cell draws, read through `valueAt`. The nth cell
+ * of the location reads the nth line of the data: the nth row when the
+ * sparklines run down a column, the nth column when they run along a row.
+ * A blank or a text cell inside the line is a gap, which Excel draws as a
+ * zero rather than breaking the line.
+ */
+export declare function sparklineSeries(group: SparklineGroup, row: number, col: number, valueAt: (row: number, col: number) => CellValue): number[] | null;
+/** The group drawn in a cell, or null: the last one wins, as Excel's does. */
+/**
+ * One line per cell of the group: the cell the sparkline is drawn in and
+ * the block of numbers it reads.
+ *
+ * The drawing works this out cell by cell as it paints; a writer needs the
+ * whole list, because Excel stores a sparkline group as one entry per cell
+ * with its own reference.
+ */
+/**
+ * A sparkline as standalone SVG markup, for a page the component cannot
+ * draw on: the printed sheet.
+ *
+ * The geometry is the grid's own `buildSparkline`, so the printed line is
+ * the line on screen rather than a second drawing that can disagree with
+ * it. The markup carries its colours inline, since the print document has
+ * no stylesheet of ours.
+ */
+export declare function sparklineSvg(values: ReadonlyArray<number>, options: {
+    type?: SheetSparklineType;
+    width: number;
+    height: number;
+    color?: string;
+    negativeColor?: string;
+    min?: number;
+    max?: number;
+    markers?: boolean;
+}): string;
+export declare function sparklineLines(group: SparklineGroup): Array<{
+    row: number;
+    col: number;
+    data: Rect;
+}>;
+export declare function sparklineAt(groups: ReadonlyArray<SparklineGroup>, row: number, col: number): SparklineGroup | null;
+/**
+ * The scale a group is drawn on when every sparkline in it shares one, which
+ * is Excel's "Same for All": the smallest and largest number anywhere in the
+ * data range. Null when the group scales each sparkline on its own.
+ */
+export declare function sparklineScale(group: SparklineGroup, valueAt: (row: number, col: number) => CellValue): {
+    min: number;
+    max: number;
+} | null;
+/**
+ * Where Excel's Create Sparklines dialog opens: the data is the selected
+ * block, and the location the column just past it (or the row just under it
+ * when the block is a single row). A block one cell tall gets a location of
+ * one cell, which is the common "a row of months, a sparkline beside it".
+ */
+export declare function sparklinesFromRange(data: Rect, type?: SheetSparklineType): SparklineGroup;
+/** The groups left after clearing every one the rectangles touch. */
+export declare function clearSparklines(groups: ReadonlyArray<SparklineGroup>, rects: ReadonlyArray<Rect>): SparklineGroup[];