@svgrid/enterprise 3.0.0 → 3.0.2

package/dist/pivot-enable.js

@@ -17,9 +17,9 @@
  * ```
  */
 import { registerPivotEngine } from '@svgrid/grid';
-import { isLicenseKeySet } from './license';
-import { emitUnlicensedNudge } from './watermark';
-import { createPivotModel } from './pivot';
+import { isLicenseKeySet } from './license.js';
+import { emitUnlicensedNudge } from './watermark.js';
+import { createPivotModel } from './pivot.js';
 let enabled = false;
 // The grid's `PivotEngine` seam is generic over row type; `createPivotModel` is
 // the concrete implementation. Bridge them with a single boundary cast.

package/dist/print.d.ts

@@ -1,5 +1,5 @@
 import type { RowData, TableFeatures, SvGridApi } from '@svgrid/grid';
-import { type ExportColumn, type ExportRowSource } from './export';
+import { type ExportColumn, type ExportRowSource } from './export.js';
 import type { ConditionalFormat } from '@svgrid/grid/format';
 export type PrintOptions<TData> = {
     /** Title placed above the printed grid. Defaults to "Grid". */

package/dist/print.js

@@ -1,7 +1,7 @@
-import { assertEnterpriseLicensed } from './license';
-import { buildLinkResolver, projectRows, resolveColumns, resolveRowSource, } from './export';
-import { buildPrintDocument } from './export-print';
-import { buildConditionalResolver } from './export-conditional';
+import { assertEnterpriseLicensed } from './license.js';
+import { buildLinkResolver, projectRows, resolveColumns, resolveRowSource, } from './export.js';
+import { buildPrintDocument } from './export-print.js';
+import { buildConditionalResolver } from './export-conditional.js';
 export async function printGrid(api, opts) {
     assertEnterpriseLicensed('Print');
     if (typeof window === 'undefined') {

package/dist/scheduler-config.d.ts

@@ -12,11 +12,11 @@
  *   - Wave C: non-working-time collapse + continuous zoom
  */
 import type { SchedulerConfig, SchedulerResource, TableFeatures, RowData } from '@svgrid/grid';
-import type { SchedulerDependency } from './scheduler-dependencies';
-import type { SchedulerAssignment } from './scheduler-assignments';
-import type { ColumnReducer } from './scheduler-summary';
-import type { ZoomLevel } from './scheduler-axis';
-import type { SchedulerResourceGroup } from './scheduler-resource-tree';
+import type { SchedulerDependency } from './scheduler-dependencies.js';
+import type { SchedulerAssignment } from './scheduler-assignments.js';
+import type { ColumnReducer } from './scheduler-summary.js';
+import type { ZoomLevel } from './scheduler-axis.js';
+import type { SchedulerResourceGroup } from './scheduler-resource-tree.js';
 export type SchedulerProConfig<TFeatures extends TableFeatures = TableFeatures, TData extends RowData = RowData> = SchedulerConfig<TFeatures, TData> & {
     /**
      * Event dependency links (predecessor -> successor). `from` / `to` are row ids

package/dist/scheduler-freebusy.d.ts

@@ -5,7 +5,7 @@
  * Deterministic - the caller supplies all dates. Reuses the interval algebra from
  * scheduler-slots (`mergeIntervals` / `subtractIntervals`).
  */
-import { type Interval } from './scheduler-slots';
+import { type Interval } from './scheduler-slots.js';
 export type { Interval };
 /** Union of a set of busy intervals into a sorted, disjoint list (an alias of the
  *  slots merge, named for the free/busy domain). */

package/dist/scheduler-freebusy.js

@@ -5,7 +5,7 @@
  * Deterministic - the caller supplies all dates. Reuses the interval algebra from
  * scheduler-slots (`mergeIntervals` / `subtractIntervals`).
  */
-import { mergeIntervals, subtractIntervals } from './scheduler-slots';
+import { mergeIntervals, subtractIntervals } from './scheduler-slots.js';
 const MS_MIN = 60000;
 /** Union of a set of busy intervals into a sorted, disjoint list (an alias of the
  *  slots merge, named for the free/busy domain). */

package/dist/scheduler.js

@@ -16,8 +16,8 @@
  * ```
  */
 import { registerSchedulerView } from '@svgrid/grid';
-import { isLicenseKeySet } from './license';
-import { emitUnlicensedNudge } from './watermark';
+import { isLicenseKeySet } from './license.js';
+import { emitUnlicensedNudge } from './watermark.js';
 import SvGridScheduler from './SvGridScheduler.svelte';
 let enabled = false;
 /**

package/dist/schema-designer.d.ts

@@ -7,7 +7,7 @@
  * Pure (no Svelte, no DOM), mirroring the pivot-designer / edit-panel split.
  * Every mutation returns a NEW schema so Svelte reactivity and undo stay simple.
  */
-import type { EntityField, EntityFieldType, EntitySchema } from './schema';
+import type { EntityField, EntityFieldType, EntitySchema } from './schema.js';
 /** All field types the designer offers, in menu order. */
 export declare const FIELD_TYPES: ReadonlyArray<EntityFieldType>;
 /** A fresh field with a name unique within the schema. */

package/dist/schema-designer.js

@@ -1,5 +1,5 @@
-import { resolveIdField } from './schema';
-import { generateRows } from './studio/sample-data';
+import { resolveIdField } from './schema.js';
+import { generateRows } from './studio/sample-data.js';
 /** All field types the designer offers, in menu order. */
 export const FIELD_TYPES = [
     'text',

package/dist/selection-bar.js

@@ -22,8 +22,8 @@
  * ```
  */
 import { registerSelectionBarView } from '@svgrid/grid';
-import { isLicenseKeySet } from './license';
-import { emitUnlicensedNudge } from './watermark';
+import { isLicenseKeySet } from './license.js';
+import { emitUnlicensedNudge } from './watermark.js';
 import SvGridSelectionBar from './SvGridSelectionBar.svelte';
 let enabled = false;
 /**

package/dist/sheet/address.d.ts

@@ -0,0 +1,43 @@
+/**
+ * A1 addressing, with absolute and relative parts kept apart.
+ *
+ * Every demo copy of this engine does `part.replace(/\$/g, '')` and then treats
+ * what is left as relative, so `$A$1` parses and evaluates as `A1`. Nothing
+ * notices while nothing translates a formula. The moment fill-down, copy/paste
+ * or insert-row exists, `=$A$1*B2` copied down starts reading the wrong cell
+ * and quietly returns a plausible wrong number, which is the worst failure mode
+ * a spreadsheet has.
+ *
+ * So `$` is structure here, not noise: `parseA1` reports which halves were
+ * pinned, and `refs.ts` is the only module allowed to move the unpinned ones.
+ *
+ * Rows and columns are 0-based internally (`A1` is `{ row: 0, col: 0 }`) and
+ * 1-based on the wire, which is the same convention the grid's selection model
+ * uses so nothing has to convert at the boundary.
+ */
+/** A parsed cell reference. `row: null` means a whole-column ref (`A:A`). */
+export type CellRef = {
+    col: number;
+    colAbs: boolean;
+    /** null for a column-only reference. */
+    row: number | null;
+    rowAbs: boolean;
+    /** null means "the sheet the formula lives on". */
+    sheet: string | null;
+};
+/** 0-based column index to letters: 0 -> A, 25 -> Z, 26 -> AA. */
+export declare function colToLetters(col: number): string;
+/** Letters to a 0-based column index. Returns -1 for anything unparseable. */
+export declare function lettersToCol(letters: string): number;
+/**
+ * Parse one reference part: `A1`, `$A$1`, `A$1`, `$A1`, or a bare column `A`.
+ * Returns null when the text is not a reference at all, which is how the
+ * tokenizer tells a reference from a bare name.
+ */
+export declare function parseA1(text: string, sheet?: string | null): CellRef | null;
+/** Render a reference back to A1, `$` included, sheet prefix and all. */
+export declare function formatA1(ref: CellRef): string;
+/** A sheet name needs quoting unless it is a bare word. */
+export declare function quoteSheet(name: string): string;
+/** True when the reference points outside a sheet of this size. */
+export declare function isOutOfBounds(ref: CellRef, rowCount: number, colCount: number): boolean;

package/dist/sheet/address.js

@@ -0,0 +1,81 @@
+/**
+ * A1 addressing, with absolute and relative parts kept apart.
+ *
+ * Every demo copy of this engine does `part.replace(/\$/g, '')` and then treats
+ * what is left as relative, so `$A$1` parses and evaluates as `A1`. Nothing
+ * notices while nothing translates a formula. The moment fill-down, copy/paste
+ * or insert-row exists, `=$A$1*B2` copied down starts reading the wrong cell
+ * and quietly returns a plausible wrong number, which is the worst failure mode
+ * a spreadsheet has.
+ *
+ * So `$` is structure here, not noise: `parseA1` reports which halves were
+ * pinned, and `refs.ts` is the only module allowed to move the unpinned ones.
+ *
+ * Rows and columns are 0-based internally (`A1` is `{ row: 0, col: 0 }`) and
+ * 1-based on the wire, which is the same convention the grid's selection model
+ * uses so nothing has to convert at the boundary.
+ */
+/** 0-based column index to letters: 0 -> A, 25 -> Z, 26 -> AA. */
+export function colToLetters(col) {
+    if (!Number.isInteger(col) || col < 0)
+        return '';
+    let n = col;
+    let out = '';
+    while (n >= 0) {
+        out = String.fromCharCode(65 + (n % 26)) + out;
+        n = Math.floor(n / 26) - 1;
+    }
+    return out;
+}
+/** Letters to a 0-based column index. Returns -1 for anything unparseable. */
+export function lettersToCol(letters) {
+    if (!letters || !/^[A-Za-z]+$/.test(letters))
+        return -1;
+    let col = 0;
+    for (const ch of letters.toUpperCase())
+        col = col * 26 + (ch.charCodeAt(0) - 64);
+    return col - 1;
+}
+const REF_RE = /^(\$?)([A-Za-z]+)(?:(\$?)(\d+))?$/;
+/**
+ * Parse one reference part: `A1`, `$A$1`, `A$1`, `$A1`, or a bare column `A`.
+ * Returns null when the text is not a reference at all, which is how the
+ * tokenizer tells a reference from a bare name.
+ */
+export function parseA1(text, sheet = null) {
+    const m = REF_RE.exec(text);
+    if (!m)
+        return null;
+    const col = lettersToCol(m[2]);
+    if (col < 0)
+        return null;
+    const rowText = m[4];
+    if (rowText === undefined) {
+        return { col, colAbs: m[1] === '$', row: null, rowAbs: false, sheet };
+    }
+    const row = Number(rowText) - 1;
+    // Row 0 does not exist in A1 notation; `A0` is a name, not a reference.
+    if (!Number.isInteger(row) || row < 0)
+        return null;
+    return { col, colAbs: m[1] === '$', row, rowAbs: m[3] === '$', sheet };
+}
+/** Render a reference back to A1, `$` included, sheet prefix and all. */
+export function formatA1(ref) {
+    const col = `${ref.colAbs ? '$' : ''}${colToLetters(ref.col)}`;
+    const cell = ref.row === null ? col : `${col}${ref.rowAbs ? '$' : ''}${ref.row + 1}`;
+    if (ref.sheet === null)
+        return cell;
+    return `${quoteSheet(ref.sheet)}!${cell}`;
+}
+/** A sheet name needs quoting unless it is a bare word. */
+export function quoteSheet(name) {
+    return /^[A-Za-z_][A-Za-z0-9_.]*$/.test(name) ? name : `'${name.replace(/'/g, "''")}'`;
+}
+/** True when the reference points outside a sheet of this size. */
+export function isOutOfBounds(ref, rowCount, colCount) {
+    if (ref.col < 0 || ref.col >= colCount)
+        return true;
+    if (ref.row === null)
+        return false;
+    return ref.row < 0 || ref.row >= rowCount;
+}

package/dist/sheet/ast.d.ts

@@ -0,0 +1,94 @@
+/**
+ * The formula AST and the error vocabulary, in their own module so the
+ * tokenizer, parser, evaluator and the reference rewriter can all import the
+ * shapes without importing each other.
+ */
+import type { CellRef } from './address.js';
+export type SheetError = '#REF!' | '#CYCLE!' | '#DIV/0!' | '#VALUE!' | '#NAME?' | '#NUM!' | '#N/A' | '#PARSE!';
+/** A computed cell value. Errors are values, not exceptions, once evaluation
+ *  finishes - that is what lets `=IFERROR(A1, 0)` see one. */
+export type CellValue = string | number | boolean | {
+    error: SheetError;
+};
+export declare function isError(v: CellValue): v is {
+    error: SheetError;
+};
+export declare function err(code: SheetError): {
+    error: SheetError;
+};
+/** Thrown during evaluation and caught at the boundary, where it becomes a
+ *  value. Carrying the code on a real Error keeps stack traces useful in dev
+ *  without the evaluator having to thread a result type through every branch. */
+export declare class FormulaError extends Error {
+    readonly code: SheetError;
+    constructor(code: SheetError);
+}
+export type Node = {
+    k: 'num';
+    v: number;
+} | {
+    k: 'str';
+    v: string;
+} | {
+    k: 'bool';
+    v: boolean;
+}
+/** A single cell. `ref.row` is never null here; a column-only reference
+ *  parses as a range instead. */
+ | {
+    k: 'ref';
+    ref: CellRef;
+}
+/** A rectangle. Either end's row may be null, meaning a whole-column ref
+ *  that runs to the last used row of the sheet. */
+ | {
+    k: 'range';
+    from: CellRef;
+    to: CellRef;
+}
+/** A defined name (`=Tax`), resolved against the workbook at evaluation. */
+ | {
+    k: 'name';
+    name: string;
+}
+/**
+ * A structured reference: `Orders[Amount]`, `[@Amount]`, `Orders[#Totals]`.
+ *
+ * Deliberately NOT resolved to a range here. The range a table reference
+ * means depends on how many rows the table has right now, and the AST is
+ * cached across the edits that change that. Resolving at parse time is how
+ * a total silently stops covering rows added after it was typed, which is
+ * the exact problem tables exist to fix.
+ */
+ | {
+    k: 'table';
+    /** null for the unqualified `[Amount]` form, which only means
+     *  something inside a table. */
+    table: string | null;
+    /** null when the reference names no column, e.g. `Orders[#All]`. */
+    column: string | null;
+    /** The far end of a column span: `Orders[[Qty]:[Amount]]`. */
+    columnTo?: string | null;
+    specifier: '#All' | '#Data' | '#Headers' | '#Totals' | '#ThisRow';
+} | {
+    k: 'unary';
+    op: '-' | '+' | '%';
+    arg: Node;
+} | {
+    k: 'binary';
+    op: BinaryOp;
+    left: Node;
+    right: Node;
+} | {
+    k: 'fn';
+    name: string;
+    args: Node[];
+};
+export type BinaryOp = '+' | '-' | '*' | '/' | '^' | '&' | '=' | '<>' | '<' | '>' | '<=' | '>=';
+/** Binding power. Comparison loosest, then concat, then arithmetic. */
+export declare const PRECEDENCE: Record<BinaryOp, number>;
+/** Walk every node, parents before children. */
+export declare function visit(node: Node, fn: (n: Node) => void): void;
+/** Rebuild the tree with `fn` applied to every node, deepest first. Used by
+ *  the reference rewriter, which must not mutate a cached AST in place. */
+export declare function mapNode(node: Node, fn: (n: Node) => Node): Node;

package/dist/sheet/ast.js

@@ -0,0 +1,56 @@
+export function isError(v) {
+    return typeof v === 'object' && v !== null && 'error' in v;
+}
+export function err(code) {
+    return { error: code };
+}
+/** Thrown during evaluation and caught at the boundary, where it becomes a
+ *  value. Carrying the code on a real Error keeps stack traces useful in dev
+ *  without the evaluator having to thread a result type through every branch. */
+export class FormulaError extends Error {
+    constructor(code) {
+        super(code);
+        this.name = 'FormulaError';
+        this.code = code;
+    }
+}
+/** Binding power. Comparison loosest, then concat, then arithmetic. */
+export const PRECEDENCE = {
+    '=': 1, '<>': 1, '<': 1, '>': 1, '<=': 1, '>=': 1,
+    '&': 2,
+    '+': 3, '-': 3,
+    '*': 4, '/': 4,
+    '^': 5,
+};
+/** Walk every node, parents before children. */
+export function visit(node, fn) {
+    fn(node);
+    switch (node.k) {
+        case 'unary':
+            visit(node.arg, fn);
+            break;
+        case 'binary':
+            visit(node.left, fn);
+            visit(node.right, fn);
+            break;
+        case 'fn':
+            for (const a of node.args)
+                visit(a, fn);
+            break;
+        default: break;
+    }
+}
+/** Rebuild the tree with `fn` applied to every node, deepest first. Used by
+ *  the reference rewriter, which must not mutate a cached AST in place. */
+export function mapNode(node, fn) {
+    switch (node.k) {
+        case 'unary':
+            return fn({ ...node, arg: mapNode(node.arg, fn) });
+        case 'binary':
+            return fn({ ...node, left: mapNode(node.left, fn), right: mapNode(node.right, fn) });
+        case 'fn':
+            return fn({ ...node, args: node.args.map((a) => mapNode(a, fn)) });
+        default:
+            return fn(node);
+    }
+}

package/dist/sheet/auto-filter.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Excel's AutoFilter: arrows on the header row of a region, each opening a
+ * menu of the column's values to tick and untick, or a condition (equals,
+ * greater than, contains, between...), and the rows that fail fold away.
+ * The rows are hidden through the grid's collapsed rows, kept apart from
+ * the rows the user hid by hand so Unhide and the saved document see
+ * only those.
+ *
+ * This module is the pure part: the state, the values a column offers,
+ * which rows a state hides, and how the state moves with an insert or
+ * delete. Conditions run through the grid's own Excel-filter compiler, so
+ * the operator semantics are the ones the grid's filter row has.
+ */
+import { type ExcelFilterOperator } from '@svgrid/grid/filtering';
+import { type CellValue } from './ast.js';
+import type { StructuralEdit } from './refs.js';
+import { type Rect } from './rects.js';
+export type FilterCondition = {
+    op: ExcelFilterOperator;
+    value?: string;
+    valueTo?: string;
+};
+export type ColumnFilter = {
+    kind: 'values'; /** Display texts left unticked; '' stands for the blanks. */
+    excluded: string[];
+} | {
+    kind: 'condition';
+    first: FilterCondition;
+    join?: 'and' | 'or';
+    second?: FilterCondition;
+};
+export type AutoFilterState = {
+    /** The region, header row first. */
+    range: Rect;
+    /** Filters by column index; a column absent here shows every row. */
+    filters: Record<number, ColumnFilter>;
+};
+export type FilterValue = {
+    text: string;
+    count: number;
+    numeric: number | null;
+};
+/**
+ * The values a column offers, each once with its count: numbers first
+ * in order, then text A to Z, the blanks last. `rowVisible` leaves out the
+ * rows other columns' filters hide, as Excel's list does.
+ */
+export declare function distinctValues(state: AutoFilterState, col: number, valueAt: (r: number, c: number) => CellValue, displayAt: (r: number, c: number) => string, rowVisible?: (r: number) => boolean): FilterValue[];
+/** Whether a row passes one column's filter. */
+export declare function passesFilter(filter: ColumnFilter, value: CellValue, display: string): boolean;
+/**
+ * The rows the state hides: every row of the region under the header
+ * that fails a column's filter. Blanks past the region's edge are not in
+ * it, as Excel's region is what was filtered.
+ */
+export declare function hiddenRowsFor(state: AutoFilterState | null, valueAt: (r: number, c: number) => CellValue, displayAt: (r: number, c: number) => string): Set<number>;
+/** Whether any column is filtered. */
+export declare function isFiltering(state: AutoFilterState | null): boolean;
+/** The state with one column's filter set, or cleared with null. */
+export declare function withColumnFilter(state: AutoFilterState, col: number, filter: ColumnFilter | null): AutoFilterState;
+/** A values filter from the ticked list, or null when everything is ticked. */
+export declare function valuesFilter(all: ReadonlyArray<string>, ticked: ReadonlySet<string>): ColumnFilter | null;
+/** The state after an insert or delete: the region moves, the filters follow their columns. */
+export declare function shiftAutoFilter(state: AutoFilterState | null, edit: StructuralEdit): AutoFilterState | null;
+/** A filter in words, for the menu's heading. */
+export declare function describeFilter(filter: ColumnFilter): string;

package/dist/sheet/auto-filter.js

@@ -0,0 +1,147 @@
+/**
+ * Excel's AutoFilter: arrows on the header row of a region, each opening a
+ * menu of the column's values to tick and untick, or a condition (equals,
+ * greater than, contains, between...), and the rows that fail fold away.
+ * The rows are hidden through the grid's collapsed rows, kept apart from
+ * the rows the user hid by hand so Unhide and the saved document see
+ * only those.
+ *
+ * This module is the pure part: the state, the values a column offers,
+ * which rows a state hides, and how the state moves with an insert or
+ * delete. Conditions run through the grid's own Excel-filter compiler, so
+ * the operator semantics are the ones the grid's filter row has.
+ */
+import { compileExcelFilter } from '@svgrid/grid/filtering';
+import { isError } from './ast.js';
+import { shiftRect, lineShift } from './rects.js';
+/** The operators that compare as numbers; the rest compare the display text. */
+const NUMERIC_OPS = new Set(['greaterThan', 'lessThan', 'between']);
+/**
+ * The values a column offers, each once with its count: numbers first
+ * in order, then text A to Z, the blanks last. `rowVisible` leaves out the
+ * rows other columns' filters hide, as Excel's list does.
+ */
+export function distinctValues(state, col, valueAt, displayAt, rowVisible = () => true) {
+    const seen = new Map();
+    for (let r = state.range[0] + 1; r <= state.range[2]; r += 1) {
+        if (!rowVisible(r))
+            continue;
+        const text = displayAt(r, col);
+        const v = valueAt(r, col);
+        const entry = seen.get(text);
+        if (entry) {
+            entry.count += 1;
+            continue;
+        }
+        seen.set(text, { text, count: 1, numeric: typeof v === 'number' && Number.isFinite(v) ? v : null });
+    }
+    return [...seen.values()].sort((a, b) => {
+        if (a.text === '')
+            return 1;
+        if (b.text === '')
+            return -1;
+        if (a.numeric !== null && b.numeric !== null)
+            return a.numeric - b.numeric;
+        if (a.numeric !== null)
+            return -1;
+        if (b.numeric !== null)
+            return 1;
+        return a.text.localeCompare(b.text, undefined, { sensitivity: 'base' });
+    });
+}
+function passesCondition(cond, value, display) {
+    const test = compileExcelFilter({ id: 'f', operator: cond.op, value: cond.value, valueTo: cond.valueTo });
+    if (NUMERIC_OPS.has(cond.op)) {
+        if (typeof value !== 'number' || !Number.isFinite(value))
+            return false;
+        return test(value);
+    }
+    if (cond.op === 'isBlank' || cond.op === 'isNotBlank')
+        return test(display === '' ? null : display);
+    return test(isError(value) ? value.error : display);
+}
+/** Whether a row passes one column's filter. */
+export function passesFilter(filter, value, display) {
+    if (filter.kind === 'values')
+        return !filter.excluded.includes(display);
+    const first = passesCondition(filter.first, value, display);
+    if (!filter.second)
+        return first;
+    const second = passesCondition(filter.second, value, display);
+    return filter.join === 'or' ? first || second : first && second;
+}
+/**
+ * The rows the state hides: every row of the region under the header
+ * that fails a column's filter. Blanks past the region's edge are not in
+ * it, as Excel's region is what was filtered.
+ */
+export function hiddenRowsFor(state, valueAt, displayAt) {
+    const out = new Set();
+    if (!state)
+        return out;
+    const columns = Object.entries(state.filters).map(([c, f]) => [Number(c), f]);
+    if (!columns.length)
+        return out;
+    for (let r = state.range[0] + 1; r <= state.range[2]; r += 1) {
+        for (const [c, filter] of columns) {
+            if (!passesFilter(filter, valueAt(r, c), displayAt(r, c))) {
+                out.add(r);
+                break;
+            }
+        }
+    }
+    return out;
+}
+/** Whether any column is filtered. */
+export function isFiltering(state) {
+    return !!state && Object.keys(state.filters).length > 0;
+}
+/** The state with one column's filter set, or cleared with null. */
+export function withColumnFilter(state, col, filter) {
+    const filters = { ...state.filters };
+    if (filter === null)
+        delete filters[col];
+    else
+        filters[col] = filter;
+    return { range: state.range, filters };
+}
+/** A values filter from the ticked list, or null when everything is ticked. */
+export function valuesFilter(all, ticked) {
+    const excluded = all.filter((text) => !ticked.has(text));
+    return excluded.length ? { kind: 'values', excluded } : null;
+}
+/** The state after an insert or delete: the region moves, the filters follow their columns. */
+export function shiftAutoFilter(state, edit) {
+    if (!state)
+        return null;
+    const range = shiftRect(state.range, edit);
+    if (!range)
+        return null;
+    if (edit.kind === 'insertRows' || edit.kind === 'deleteRows')
+        return { range, filters: { ...state.filters } };
+    const shift = lineShift(edit);
+    const filters = {};
+    for (const [c, f] of Object.entries(state.filters)) {
+        const next = shift(Number(c));
+        if (next !== null)
+            filters[next] = f;
+    }
+    return { range, filters };
+}
+const OP_WORDS = {
+    equals: 'equals', notEquals: 'does not equal', greaterThan: 'is greater than', lessThan: 'is less than',
+    between: 'is between', contains: 'contains', notContains: 'does not contain', startsWith: 'begins with',
+    endsWith: 'ends with', isBlank: 'is blank', isNotBlank: 'is not blank',
+};
+/** A filter in words, for the menu's heading. */
+export function describeFilter(filter) {
+    if (filter.kind === 'values')
+        return filter.excluded.length === 1 ? '1 value hidden' : `${filter.excluded.length} values hidden`;
+    const one = (c) => {
+        const word = OP_WORDS[c.op] ?? c.op;
+        if (c.op === 'isBlank' || c.op === 'isNotBlank')
+            return word;
+        return c.op === 'between' ? `${word} ${c.value ?? ''} and ${c.valueTo ?? ''}` : `${word} ${c.value ?? ''}`;
+    };
+    return filter.second ? `${one(filter.first)} ${filter.join ?? 'and'} ${one(filter.second)}` : one(filter.first);
+}

package/dist/sheet/autocomplete.d.ts

@@ -0,0 +1,42 @@
+export type FunctionSuggestion = {
+    name: string;
+    /** Where the partial name starts, so accepting can splice it out. */
+    start: number;
+    /** Where the caret is, i.e. where the partial name ends. */
+    end: number;
+};
+/** Signature hints, for the ones whose argument order is not obvious. */
+export declare const SIGNATURES: Record<string, string>;
+/**
+ * The word being typed immediately before the caret, if it could be a function
+ * name. Returns null when the caret is not in a formula, or sits somewhere a
+ * function name cannot start (inside a string, or right after a reference).
+ */
+export declare function partialAt(text: string, caret: number): {
+    word: string;
+    start: number;
+} | null;
+/**
+ * Function names matching what is being typed.
+ *
+ * Prefix matches first, then anything merely containing the text, so typing
+ * "look" still finds VLOOKUP. Within each group, SHORTER names rank first:
+ * alphabetical order puts SUBSTITUTE above SUM for "SU", which is exactly
+ * backwards from what someone typing two letters wants.
+ */
+export declare function suggestFunctions(text: string, caret: number, limit?: number): FunctionSuggestion[];
+/** Splice an accepted suggestion in, leaving the caret inside the parens. */
+export declare function applySuggestion(text: string, suggestion: FunctionSuggestion): {
+    text: string;
+    caret: number;
+};
+/**
+ * Close the parentheses a formula left open, the way Excel corrects
+ * "=SUM(A1:A3" to "=SUM(A1:A3)" when it is entered. Quoted text is skipped,
+ * so a ")" inside a string neither closes nor needs closing. Text that is
+ * not a formula, or has more closers than openers, is returned as it is:
+ * that one is an error the engine should report, not paper over.
+ */
+export declare function balanceParens(text: string): string;
+/** The signature hint for whatever call the caret is inside, if any. */
+export declare function signatureAt(text: string, caret: number): string | null;