@svgrid/enterprise 3.0.0 → 3.0.2

package/dist/sheet/comments.js

@@ -0,0 +1,73 @@
+/**
+ * Cell comments, Excel's notes: a text on a cell, shown as a corner mark
+ * and read on hover. They live in the sheet document in the grid's own
+ * `notes` shape (`r4` -> `B` -> text), so the grid draws the mark and the
+ * tooltip and the document moves them with an insert or delete
+ * (`remapNotes`). This module is the pure part: reading, writing, and
+ * walking them the way Review > Previous / Next do.
+ */
+import { colToLetters, lettersToCol } from './address.js';
+/** The comment on (r, c), or undefined when there is none. */
+export function commentAt(notes, r, c) {
+    const text = notes[`r${r}`]?.[colToLetters(c)];
+    return text && text.trim() ? text : undefined;
+}
+/**
+ * The map with (r, c) set to `text`, or cleared when the text is blank.
+ * A new map, never the old one changed: the grid re-reads `notes` only
+ * when the object it is handed is a different one.
+ */
+export function withComment(notes, r, c, text) {
+    const rowId = `r${r}`;
+    const columnId = colToLetters(c);
+    const out = {};
+    for (const [id, line] of Object.entries(notes))
+        out[id] = { ...line };
+    if (text.trim()) {
+        out[rowId] = { ...(out[rowId] ?? {}), [columnId]: text };
+    }
+    else if (out[rowId]) {
+        delete out[rowId][columnId];
+        if (Object.keys(out[rowId]).length === 0)
+            delete out[rowId];
+    }
+    return out;
+}
+/** Every comment, top to bottom then left to right. */
+export function listComments(notes) {
+    const out = [];
+    for (const [rowId, line] of Object.entries(notes)) {
+        const row = Number(rowId.slice(1));
+        if (!Number.isInteger(row) || row < 0)
+            continue;
+        for (const [columnId, text] of Object.entries(line)) {
+            const col = lettersToCol(columnId);
+            if (col < 0 || !text || !text.trim())
+                continue;
+            out.push({ row, col, text });
+        }
+    }
+    return out.sort((a, b) => a.row - b.row || a.col - b.col);
+}
+/**
+ * The comment after (or before) `from`, reading the sheet row by row and
+ * wrapping at the end, as Excel's Next Comment and Previous Comment do. The
+ * cell itself is skipped, so pressing Next on a commented cell moves on;
+ * null when the sheet has no comments at all.
+ */
+export function nextComment(notes, from, dir) {
+    const all = listComments(notes);
+    if (!all.length)
+        return null;
+    const after = (a, b) => a.row > b.row || (a.row === b.row && a.col > b.col);
+    const at = (entry) => ({ row: entry.row, col: entry.col });
+    if (dir === 1) {
+        const hit = all.find((entry) => after(entry, from));
+        return at(hit ?? all[0]);
+    }
+    for (let i = all.length - 1; i >= 0; i -= 1) {
+        if (after(from, all[i]))
+            return at(all[i]);
+    }
+    return at(all[all.length - 1]);
+}

package/dist/sheet/conditional-formats.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Conditional formatting, Excel's: rules over cells that colour them by
+ * what they hold. Highlight Cells Rules (greater than, between, text that
+ * contains, duplicates), Top/Bottom Rules (top 10, above average), Data
+ * Bars, Color Scales and Icon Sets, each over rectangles that move with
+ * an insert or delete.
+ *
+ * Rules are evaluated over COMPUTED values (what a formula shows, not its
+ * text), which is why the model lives here beside the workbook rather than
+ * in the grid's own value-driven rules. The statistics a rule needs over
+ * its range (min, max, mean, rank, counts) are computed once per repaint by
+ * the shell and handed in, so a thousand cells cost one pass.
+ *
+ * Priority is array order, first rule first, as Excel's Manage Rules lists
+ * them: the first rule that decides a property wins it, and a rule with
+ * Stop If True stops the rules below it for the cells it matches.
+ */
+import { type CellValue } from './ast.js';
+import type { StructuralEdit } from './refs.js';
+import { type Rect } from './rects.js';
+import type { CellFormatEntry } from './format-store.js';
+export type CfStyle = Pick<CellFormatEntry, 'fill' | 'color' | 'bold' | 'italic' | 'underline' | 'strike' | 'numFmt'>;
+export type CfOperator = 'greater' | 'less' | 'between' | 'notBetween' | 'equal' | 'notEqual' | 'greaterOrEqual' | 'lessOrEqual';
+export type CfTextMatch = 'contains' | 'notContains' | 'beginsWith' | 'endsWith';
+export type CfIconSet = 'arrows' | 'traffic' | 'flags' | 'symbols';
+export type CfScaleColors = readonly [string, string] | readonly [string, string, string];
+export type CfRule = {
+    id: string;
+    rects: ReadonlyArray<Rect>;
+    stopIfTrue?: boolean;
+} & ({
+    kind: 'cellIs';
+    operator: CfOperator;
+    value1: string;
+    value2?: string;
+    style: CfStyle;
+} | {
+    kind: 'text';
+    match: CfTextMatch;
+    value: string;
+    style: CfStyle;
+} | {
+    kind: 'duplicates';
+    unique?: boolean;
+    style: CfStyle;
+} | {
+    kind: 'topBottom';
+    top: boolean;
+    rank: number;
+    percent?: boolean;
+    style: CfStyle;
+} | {
+    kind: 'average';
+    above: boolean;
+    style: CfStyle;
+} | {
+    kind: 'dataBar';
+    color: string;
+} | {
+    kind: 'colorScale';
+    colors: CfScaleColors;
+} | {
+    kind: 'iconSet';
+    set: CfIconSet;
+});
+export type CfKind = CfRule['kind'];
+/** A rule that carries a style: what the small dialogs make. */
+export type CfStyledRule = Extract<CfRule, {
+    style: CfStyle;
+}>;
+/** Omit that keeps a union a union, one member at a time. */
+type DistributiveOmit<T, K extends keyof never> = T extends unknown ? Omit<T, K> : never;
+/** Any rule without its id and rectangles: what a new rule is made from. */
+export type CfRuleBody = DistributiveOmit<CfRule, 'id' | 'rects'>;
+/** A styled rule without its id and rectangles: what the dialog hands back. */
+export type CfBody = DistributiveOmit<CfStyledRule, 'id' | 'rects'>;
+/** The small dialogs, one per ribbon entry. */
+export type CfPreset = 'greater' | 'less' | 'between' | 'equal' | 'text' | 'duplicates' | 'top10' | 'bottom10' | 'aboveAverage' | 'belowAverage';
+/** What one rule knows about the numbers in its rectangles. */
+export type CfStats = {
+    /** Numbers, sorted ascending. */
+    sorted: number[];
+    min: number;
+    max: number;
+    mean: number;
+    /** How often each display text occurs, for Duplicate Values. */
+    counts: Map<string, number>;
+};
+/** What the rules say about one cell. */
+export type CfResult = {
+    style?: CfStyle;
+    /** A bar across the cell, 0..1 of its width. */
+    dataBar?: {
+        ratio: number;
+        color: string;
+    };
+    /** The icon set and which of its three icons: 0 = the top one. */
+    icon?: {
+        set: CfIconSet;
+        index: 0 | 1 | 2;
+    };
+};
+/** How a rule reads the sheet: the shell wires the workbook in. */
+export type CfContext = {
+    /** A formula or a literal, evaluated in the sheet. */
+    evaluate(text: string): CellValue;
+};
+/** The six "with" styles of Excel's Highlight Cells dialogs. */
+export declare const CF_PRESET_STYLES: ReadonlyArray<{
+    id: string;
+    label: string;
+    style: CfStyle;
+}>;
+export declare const DATA_BAR_COLOR = "#638EC6";
+export declare const COLOR_SCALES: Record<'green-yellow-red' | 'red-yellow-green' | 'green-white' | 'white-red', CfScaleColors>;
+export declare function cfId(): string;
+/**
+ * The numbers and the texts a rule's rectangles hold. One pass; the shell
+ * caches the result per rule until the next repaint.
+ */
+export declare function ruleStats(rule: CfRule, valueAt: (r: number, c: number) => CellValue, displayAt: (r: number, c: number) => string): CfStats;
+/** The colour a scale gives a position 0..1. */
+export declare function scaleColor(colors: CfScaleColors, t: number): string;
+/** Which of an icon set's three icons a position 0..1 gets: Excel's thirds. */
+export declare function iconIndex(t: number): 0 | 1 | 2;
+/**
+ * What the rules say about (r, c). Array order is priority; the first rule
+ * that decides a property (the fill, the text colour, the bar, the icon)
+ * keeps it; a matching rule with Stop If True ends the walk.
+ */
+export declare function evaluateCf(rules: ReadonlyArray<CfRule>, r: number, c: number, value: CellValue, display: string, statsFor: (rule: CfRule) => CfStats, ctx: CfContext): CfResult | null;
+/** The rules after an insert or delete. */
+export declare function shiftCf(rules: ReadonlyArray<CfRule>, edit: StructuralEdit): CfRule[];
+/** The rules with the rectangles cut out of them: Clear Rules from Selected Cells. */
+export declare function removeCf(rules: ReadonlyArray<CfRule>, rects: ReadonlyArray<Rect>): CfRule[];
+/** The rules touching any of the rectangles. */
+export declare function cfIn(rules: ReadonlyArray<CfRule>, rects: ReadonlyArray<Rect>): CfRule[];
+/** A rule in words, the way Excel's Manage Rules lists it. */
+export declare function describeCf(rule: CfRule): string;
+/** Whether a rule carries a style the dialog can edit. */
+export declare function hasStyle(rule: CfRule): rule is Extract<CfRule, {
+    style: CfStyle;
+}>;
+export {};

package/dist/sheet/conditional-formats.js

@@ -0,0 +1,316 @@
+/**
+ * Conditional formatting, Excel's: rules over cells that colour them by
+ * what they hold. Highlight Cells Rules (greater than, between, text that
+ * contains, duplicates), Top/Bottom Rules (top 10, above average), Data
+ * Bars, Color Scales and Icon Sets, each over rectangles that move with
+ * an insert or delete.
+ *
+ * Rules are evaluated over COMPUTED values (what a formula shows, not its
+ * text), which is why the model lives here beside the workbook rather than
+ * in the grid's own value-driven rules. The statistics a rule needs over
+ * its range (min, max, mean, rank, counts) are computed once per repaint by
+ * the shell and handed in, so a thousand cells cost one pass.
+ *
+ * Priority is array order, first rule first, as Excel's Manage Rules lists
+ * them: the first rule that decides a property wins it, and a rule with
+ * Stop If True stops the rules below it for the cells it matches.
+ */
+import { isError } from './ast.js';
+import { toText } from './coerce.js';
+import { rectContains, shiftRects, subtractRect, rectsIntersect } from './rects.js';
+// ---------------------------------------------------------------------------
+// Excel's palettes
+// ---------------------------------------------------------------------------
+/** The six "with" styles of Excel's Highlight Cells dialogs. */
+export const CF_PRESET_STYLES = [
+    { id: 'light-red', label: 'Light Red Fill with Dark Red Text', style: { fill: '#FFC7CE', color: '#9C0006' } },
+    { id: 'yellow', label: 'Yellow Fill with Dark Yellow Text', style: { fill: '#FFEB9C', color: '#9C5700' } },
+    { id: 'green', label: 'Green Fill with Dark Green Text', style: { fill: '#C6EFCE', color: '#006100' } },
+    { id: 'red-fill', label: 'Light Red Fill', style: { fill: '#FFC7CE' } },
+    { id: 'red-text', label: 'Red Text', style: { color: '#9C0006' } },
+];
+export const DATA_BAR_COLOR = '#638EC6';
+export const COLOR_SCALES = {
+    'green-yellow-red': ['#63BE7B', '#FFEB84', '#F8696B'],
+    'red-yellow-green': ['#F8696B', '#FFEB84', '#63BE7B'],
+    'green-white': ['#63BE7B', '#FCFCFF'],
+    'white-red': ['#FCFCFF', '#F8696B'],
+};
+let nextId = 1;
+export function cfId() {
+    nextId += 1;
+    return `cf${Date.now().toString(36)}${nextId}`;
+}
+// ---------------------------------------------------------------------------
+// Statistics
+// ---------------------------------------------------------------------------
+/**
+ * The numbers and the texts a rule's rectangles hold. One pass; the shell
+ * caches the result per rule until the next repaint.
+ */
+export function ruleStats(rule, valueAt, displayAt) {
+    const numbers = [];
+    const counts = new Map();
+    let sum = 0;
+    for (const [r1, c1, r2, c2] of rule.rects) {
+        for (let r = r1; r <= r2; r += 1) {
+            for (let c = c1; c <= c2; c += 1) {
+                const v = valueAt(r, c);
+                if (typeof v === 'number' && Number.isFinite(v)) {
+                    numbers.push(v);
+                    sum += v;
+                }
+                if (rule.kind === 'duplicates') {
+                    const shown = displayAt(r, c);
+                    if (shown !== '')
+                        counts.set(shown, (counts.get(shown) ?? 0) + 1);
+                }
+            }
+        }
+    }
+    numbers.sort((a, b) => a - b);
+    return {
+        sorted: numbers,
+        min: numbers[0] ?? 0,
+        max: numbers[numbers.length - 1] ?? 0,
+        mean: numbers.length ? sum / numbers.length : 0,
+        counts,
+    };
+}
+// ---------------------------------------------------------------------------
+// Evaluation
+// ---------------------------------------------------------------------------
+function numberOf(text, ctx) {
+    const v = ctx.evaluate(text);
+    if (isError(v) || typeof v === 'boolean')
+        return null;
+    const n = typeof v === 'number' ? v : Number(v);
+    return Number.isFinite(n) ? n : null;
+}
+function textOf(text, ctx) {
+    const t = text.trim();
+    if (!t.startsWith('='))
+        return t;
+    const v = ctx.evaluate(t);
+    return isError(v) ? '' : toText(v);
+}
+function cellIs(value, operator, a, b) {
+    if (a === null)
+        return false;
+    switch (operator) {
+        case 'greater': return value > a;
+        case 'less': return value < a;
+        case 'greaterOrEqual': return value >= a;
+        case 'lessOrEqual': return value <= a;
+        case 'equal': return value === a;
+        case 'notEqual': return value !== a;
+        case 'between': return b !== null && value >= Math.min(a, b) && value <= Math.max(a, b);
+        case 'notBetween': return b !== null && (value < Math.min(a, b) || value > Math.max(a, b));
+    }
+}
+/** Whether a styling rule matches the cell. */
+function matches(rule, value, display, stats, ctx) {
+    switch (rule.kind) {
+        case 'cellIs': {
+            const isEquality = rule.operator === 'equal' || rule.operator === 'notEqual';
+            const a = numberOf(rule.value1, ctx);
+            if (typeof value === 'number' && (a !== null || !isEquality)) {
+                return cellIs(value, rule.operator, a, rule.value2 === undefined ? null : numberOf(rule.value2, ctx));
+            }
+            // Equal to / not equal to compare as text where either side is text,
+            // as Excel does: 5 is not equal to 'Paid', and 'paid' is equal to it.
+            if (!isEquality)
+                return false;
+            const same = display !== '' && display.toLowerCase() === textOf(rule.value1, ctx).toLowerCase();
+            return rule.operator === 'equal' ? same : display !== '' && !same;
+        }
+        case 'text': {
+            if (display === '')
+                return false;
+            const hay = display.toLowerCase();
+            const needle = textOf(rule.value, ctx).toLowerCase();
+            if (needle === '')
+                return false;
+            switch (rule.match) {
+                case 'contains': return hay.includes(needle);
+                case 'notContains': return !hay.includes(needle);
+                case 'beginsWith': return hay.startsWith(needle);
+                case 'endsWith': return hay.endsWith(needle);
+                default: return false;
+            }
+        }
+        case 'duplicates': {
+            if (display === '')
+                return false;
+            const n = stats.counts.get(display) ?? 0;
+            return rule.unique ? n === 1 : n > 1;
+        }
+        case 'topBottom': {
+            if (typeof value !== 'number' || !stats.sorted.length)
+                return false;
+            const count = rule.percent
+                ? Math.max(1, Math.round((stats.sorted.length * rule.rank) / 100))
+                : rule.rank;
+            if (count <= 0)
+                return false;
+            // The cut is the count-th value from the top (or bottom); ties keep
+            // every cell at that value in, as Excel's do.
+            const sorted = stats.sorted;
+            const cut = rule.top
+                ? sorted[Math.max(sorted.length - count, 0)]
+                : sorted[Math.min(count - 1, sorted.length - 1)];
+            return rule.top ? value >= cut : value <= cut;
+        }
+        case 'average': {
+            if (typeof value !== 'number' || !stats.sorted.length)
+                return false;
+            return rule.above ? value > stats.mean : value < stats.mean;
+        }
+        default:
+            return false;
+    }
+}
+/**
+ * A data bar's share of the cell, 0..1. Excel measures from zero when the
+ * range is non-negative (10, 20, 40 draw a quarter, a half and the whole
+ * width), so the smallest value keeps a bar; a range with negatives runs
+ * from its minimum instead, since there is no negative axis here.
+ */
+function barRatio(value, stats) {
+    const lo = Math.min(0, stats.min);
+    const hi = Math.max(0, stats.max);
+    if (hi === lo)
+        return 0;
+    return Math.min(1, Math.max(0, (value - lo) / (hi - lo)));
+}
+/** Where a number sits in a range, 0..1; 0.5 for a flat range. */
+function ratioOf(value, stats) {
+    if (stats.max === stats.min)
+        return 0.5;
+    return Math.min(1, Math.max(0, (value - stats.min) / (stats.max - stats.min)));
+}
+/** Linear interpolate two hex colours. */
+function lerp(a, b, t) {
+    const pa = parseHex(a);
+    const pb = parseHex(b);
+    if (!pa || !pb)
+        return a;
+    const k = Math.min(1, Math.max(0, t));
+    const ch = (i) => Math.round(pa[i] + (pb[i] - pa[i]) * k).toString(16).padStart(2, '0');
+    return `#${ch(0)}${ch(1)}${ch(2)}`;
+}
+function parseHex(hex) {
+    const m = /^#?([0-9a-f]{6})$/i.exec(hex.trim());
+    if (!m)
+        return null;
+    const n = parseInt(m[1], 16);
+    return [(n >> 16) & 255, (n >> 8) & 255, n & 255];
+}
+/** The colour a scale gives a position 0..1. */
+export function scaleColor(colors, t) {
+    if (colors.length === 2)
+        return lerp(colors[0], colors[1], t);
+    return t <= 0.5 ? lerp(colors[0], colors[1], t * 2) : lerp(colors[1], colors[2], (t - 0.5) * 2);
+}
+/** Which of an icon set's three icons a position 0..1 gets: Excel's thirds. */
+export function iconIndex(t) {
+    return t >= 2 / 3 ? 0 : t >= 1 / 3 ? 1 : 2;
+}
+/**
+ * What the rules say about (r, c). Array order is priority; the first rule
+ * that decides a property (the fill, the text colour, the bar, the icon)
+ * keeps it; a matching rule with Stop If True ends the walk.
+ */
+export function evaluateCf(rules, r, c, value, display, statsFor, ctx) {
+    let out = null;
+    for (const rule of rules) {
+        if (!rule.rects.some((rect) => rectContains(rect, r, c)))
+            continue;
+        let hit = false;
+        if (rule.kind === 'dataBar') {
+            if (typeof value === 'number' && !(out?.dataBar)) {
+                const stats = statsFor(rule);
+                out = { ...(out ?? {}), dataBar: { ratio: barRatio(value, stats), color: rule.color } };
+                hit = true;
+            }
+        }
+        else if (rule.kind === 'colorScale') {
+            const current = out ?? {};
+            if (typeof value === 'number' && current.style?.fill === undefined) {
+                const stats = statsFor(rule);
+                out = { ...current, style: { ...(current.style ?? {}), fill: scaleColor(rule.colors, ratioOf(value, stats)) } };
+                hit = true;
+            }
+        }
+        else if (rule.kind === 'iconSet') {
+            if (typeof value === 'number' && !(out?.icon)) {
+                const stats = statsFor(rule);
+                out = { ...(out ?? {}), icon: { set: rule.set, index: iconIndex(ratioOf(value, stats)) } };
+                hit = true;
+            }
+        }
+        else if (hasStyle(rule) && matches(rule, value, display, statsFor(rule), ctx)) {
+            const style = { ...(out?.style ?? {}) };
+            const own = rule.style;
+            for (const key of Object.keys(own)) {
+                if (style[key] === undefined && own[key] !== undefined)
+                    style[key] = own[key];
+            }
+            out = { ...(out ?? {}), style };
+            hit = true;
+        }
+        if (hit && rule.stopIfTrue)
+            break;
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Bookkeeping
+// ---------------------------------------------------------------------------
+/** The rules after an insert or delete. */
+export function shiftCf(rules, edit) {
+    return shiftRects(rules, edit);
+}
+/** The rules with the rectangles cut out of them: Clear Rules from Selected Cells. */
+export function removeCf(rules, rects) {
+    const out = [];
+    for (const rule of rules) {
+        let kept = [...rule.rects];
+        for (const hole of rects)
+            kept = kept.flatMap((rect) => subtractRect(rect, hole));
+        if (kept.length)
+            out.push({ ...rule, rects: kept });
+    }
+    return out;
+}
+/** The rules touching any of the rectangles. */
+export function cfIn(rules, rects) {
+    return rules.filter((rule) => rule.rects.some((a) => rects.some((b) => rectsIntersect(a, b))));
+}
+const OPERATOR_WORDS = {
+    greater: 'greater than', less: 'less than', between: 'between', notBetween: 'not between',
+    equal: 'equal to', notEqual: 'not equal to', greaterOrEqual: 'greater than or equal to', lessOrEqual: 'less than or equal to',
+};
+const MATCH_WORDS = {
+    contains: 'contains', notContains: 'does not contain', beginsWith: 'begins with', endsWith: 'ends with',
+};
+/** A rule in words, the way Excel's Manage Rules lists it. */
+export function describeCf(rule) {
+    switch (rule.kind) {
+        case 'cellIs':
+            return rule.operator === 'between' || rule.operator === 'notBetween'
+                ? `Cell Value ${OPERATOR_WORDS[rule.operator]} ${rule.value1} and ${rule.value2 ?? ''}`
+                : `Cell Value ${OPERATOR_WORDS[rule.operator]} ${rule.value1}`;
+        case 'text': return `Cell Value ${MATCH_WORDS[rule.match]} '${rule.value}'`;
+        case 'duplicates': return rule.unique ? 'Unique Values' : 'Duplicate Values';
+        case 'topBottom': return `${rule.top ? 'Top' : 'Bottom'} ${rule.rank}${rule.percent ? '%' : ''}`;
+        case 'average': return rule.above ? 'Above Average' : 'Below Average';
+        case 'dataBar': return 'Data Bar';
+        case 'colorScale': return rule.colors.length === 3 ? 'Graded Color Scale' : 'Two-Color Scale';
+        case 'iconSet': return 'Icon Set';
+    }
+}
+/** Whether a rule carries a style the dialog can edit. */
+export function hasStyle(rule) {
+    return 'style' in rule;
+}

package/dist/sheet/deps.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Dependency graph, so a recalc costs what the edit actually affects.
+ *
+ * The demo engines call `computeSheet`, which resolves every cell on every
+ * keystroke. On a small budget sheet nobody notices; on demo 211's 360-row
+ * amortisation schedule, typing one digit in an input cell walks every cell in
+ * the sheet and re-parses every formula among them.
+ *
+ * This tracks which cells each formula reads, inverts that into "who reads
+ * me", and walks forward from an edit in topological order.
+ *
+ * Cycles are reported rather than thrown. A cycle is a normal thing to type on
+ * the way to something correct, and every cell in one shows #CYCLE! while the
+ * rest of the sheet keeps working.
+ */
+import { type Node } from './ast.js';
+export type CellKey = string;
+/**
+ * Cells are keyed "row col sheet", in that order deliberately.
+ *
+ * Row and column are numbers and contain no separator, so the first two fields
+ * are unambiguous and EVERYTHING after the second space is the sheet name.
+ * Putting the sheet first would let a name like `Price list` collide with a
+ * different cell, and a ':' or '!' separator has the same problem the moment
+ * someone names a sheet after a range.
+ */
+export declare function cellKey(sheet: string | null, row: number, col: number): CellKey;
+export declare function parseCellKey(key: CellKey): {
+    sheet: string | null;
+    row: number;
+    col: number;
+};
+/**
+ * Every cell a formula reads. A range contributes each cell inside it, which
+ * is why `lastRow` is needed: a whole-column reference has no upper bound of
+ * its own.
+ */
+export declare function precedentsOf(ast: Node, self: {
+    sheet: string | null;
+}, lastRow: (sheet: string | null) => number, 
+/**
+ * The reference behind a defined name. Without it a formula that reads
+ * `=Subtotal*Tax` records no precedents at all, so editing the cell behind
+ * `Tax` leaves the formula showing its old value until something else
+ * forces a recalculation.
+ */
+resolveName?: (name: string) => Node | null, depth?: number): CellKey[];
+export type DependencyGraph = {
+    /** Record (or clear, with null) what one cell reads. */
+    setPrecedents(cell: CellKey, precedents: ReadonlyArray<CellKey> | null): void;
+    /** Cells that must recompute after `changed`, ordered so every cell comes
+     *  after everything it reads. Excludes the changed cells themselves. */
+    dirtyFrom(changed: ReadonlyArray<CellKey>): CellKey[];
+    /** Every cell taking part in a dependency cycle. */
+    cycles(): CellKey[];
+    /** Direct readers of a cell. */
+    dependentsOf(cell: CellKey): CellKey[];
+    clear(): void;
+};
+export declare function createDependencyGraph(): DependencyGraph;