@calliopelabs/ui 0.16.0 → 0.18.0

package/dist/workbench/grid-stats.js

@@ -0,0 +1,185 @@
+/**
+ * Column and selection statistics, and the column profile (from Loadr's grid
+ * and profile view). Pure.
+ *
+ * One pass, no sorting of the whole column: at 50k rows the grid computes these
+ * on a header menu opening or a selection change, so the cost has to stay linear
+ * and allocation-light.
+ */
+function asNumber(value) {
+    if (typeof value === "number")
+        return Number.isFinite(value) ? value : null;
+    if (typeof value === "string" && value.trim() !== "") {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+export function computeStats(values) {
+    let nulls = 0;
+    let numericCount = 0;
+    let nonNull = 0;
+    let sum = 0;
+    let numMin = Number.POSITIVE_INFINITY;
+    let numMax = Number.NEGATIVE_INFINITY;
+    let strMin;
+    let strMax;
+    const distinct = new Set();
+    for (const value of values) {
+        if (value === null || value === undefined) {
+            nulls++;
+            continue;
+        }
+        nonNull++;
+        const text = typeof value === "object" ? JSON.stringify(value) : String(value);
+        distinct.add(text);
+        const num = typeof value === "number" && Number.isFinite(value) ? value : null;
+        if (num !== null) {
+            numericCount++;
+            sum += num;
+            if (num < numMin)
+                numMin = num;
+            if (num > numMax)
+                numMax = num;
+        }
+        else {
+            if (strMin === undefined || text < strMin)
+                strMin = text;
+            if (strMax === undefined || text > strMax)
+                strMax = text;
+        }
+    }
+    const numeric = nonNull > 0 && numericCount === nonNull;
+    const stats = {
+        count: nulls + nonNull,
+        nulls,
+        distinct: distinct.size,
+        numeric,
+    };
+    if (numeric) {
+        stats.min = numMin;
+        stats.max = numMax;
+        stats.sum = sum;
+        stats.avg = sum / numericCount;
+    }
+    else {
+        stats.min = strMin;
+        stats.max = strMax;
+    }
+    return stats;
+}
+/**
+ * Sum/avg over whatever in the selection parses as a number.
+ *
+ * Unlike `computeStats` this does coerce numeric strings, because a selection
+ * spans columns and a numeric column arriving as text should still add up.
+ */
+export function numericSummary(values) {
+    let count = 0;
+    let sum = 0;
+    let min = Number.POSITIVE_INFINITY;
+    let max = Number.NEGATIVE_INFINITY;
+    for (const value of values) {
+        const num = asNumber(value);
+        if (num === null)
+            continue;
+        count++;
+        sum += num;
+        if (num < min)
+            min = num;
+        if (num > max)
+            max = num;
+    }
+    if (count === 0)
+        return null;
+    return { count, sum, avg: sum / count, min, max };
+}
+export function formatStatValue(value) {
+    if (value === undefined)
+        return "";
+    if (typeof value === "number") {
+        return Number.isInteger(value)
+            ? value.toLocaleString()
+            : value.toLocaleString(undefined, { maximumFractionDigits: 4 });
+    }
+    return value.length > 40 ? `${value.slice(0, 40)}\u2026` : value;
+}
+function profileKind(values) {
+    let total = 0;
+    let nums = 0;
+    let bools = 0;
+    let dates = 0;
+    for (const v of values) {
+        if (v === null || v === undefined)
+            continue;
+        total++;
+        if (typeof v === "number")
+            nums++;
+        else if (typeof v === "boolean")
+            bools++;
+        else if (typeof v === "string") {
+            if (/^\d{4}-\d{2}-\d{2}/.test(v))
+                dates++;
+            else if (asNumber(v) !== null)
+                nums++;
+        }
+    }
+    if (total === 0)
+        return "null";
+    if (bools / total > 0.8)
+        return "boolean";
+    if (dates / total > 0.8)
+        return "date";
+    if (nums / total > 0.8)
+        return "numeric";
+    return "text";
+}
+/** A column's profile: counts, range, mean and median (numeric), and the top values. */
+export function profileColumn(name, values, topCount = 5) {
+    const kind = profileKind(values);
+    const freq = new Map();
+    let nulls = 0;
+    for (const v of values) {
+        if (v === null || v === undefined) {
+            nulls++;
+            continue;
+        }
+        const text = typeof v === "object" ? JSON.stringify(v) : String(v);
+        freq.set(text, (freq.get(text) ?? 0) + 1);
+    }
+    const nonNull = values.length - nulls;
+    const profile = {
+        name,
+        kind,
+        count: values.length,
+        nulls,
+        distinct: freq.size,
+        top: [...freq.entries()]
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, topCount)
+            .map(([value, count]) => ({ value, count, share: nonNull > 0 ? count / nonNull : 0 })),
+    };
+    if (kind === "numeric") {
+        const nums = [];
+        for (const v of values) {
+            const n = asNumber(v);
+            if (n !== null)
+                nums.push(n);
+        }
+        nums.sort((a, b) => a - b);
+        if (nums.length > 0) {
+            const mid = Math.floor(nums.length / 2);
+            profile.min = nums[0];
+            profile.max = nums[nums.length - 1];
+            profile.mean = nums.reduce((s, n) => s + n, 0) / nums.length;
+            profile.median =
+                nums.length % 2 === 0 ? ((nums[mid - 1] ?? 0) + (nums[mid] ?? 0)) / 2 : nums[mid];
+        }
+    }
+    else if (kind === "text" || kind === "date") {
+        const keys = [...freq.keys()].sort();
+        profile.min = keys[0];
+        profile.max = keys[keys.length - 1];
+    }
+    return profile;
+}

package/dist/workbench/index.d.ts

@@ -14,3 +14,31 @@ export { FileGrid, type FileGridProps } from "./FileGrid.js";
 export { FileBrowser, type FileBrowserProps } from "./FileBrowser.js";
 export { UploadDropzone, type UploadDropzoneProps, type UploadItem, type UploadRejection, } from "./UploadDropzone.js";
 export { FilePreview, type FilePreviewContent, type FilePreviewProps } from "./FilePreview.js";
+export { formatShortcut, isMacPlatform, matchesShortcut, parseShortcut, shortcutKeys, type KeyChord, } from "./keys.js";
+export { KeyboardShortcutsDialog, ShortcutKeys, useRegisteredShortcuts, useShortcuts, type KeyboardShortcutsDialogProps, type ShortcutDefinition, type ShortcutEntry, type ShortcutKeysProps, } from "./Shortcuts.js";
+export { fuzzyScore, rankItems, type PaletteMatchable } from "./palette.js";
+export { CommandPalette, type CommandPaletteProps, type PaletteItem } from "./CommandPalette.js";
+export { MenuBar, type MenuBarProps, type MenuEntry, type WorkbenchMenu } from "./MenuBar.js";
+export { ActivityBar, type ActivityBarProps, type ActivityItem } from "./ActivityBar.js";
+export { EditorGroup, EditorTabs, editorTabId, type EditorGroupProps, type EditorTab, type EditorTabsProps, } from "./EditorTabs.js";
+export { Pane, PaneGroup, resolvePaneSizes, type PaneGroupProps, type PaneProps, type PaneSize, } from "./PaneGroup.js";
+export { BottomPanel, type BottomPanelProps, type BottomPanelView } from "./BottomPanel.js";
+export { StatusBar, StatusBarItem, type StatusBarItemProps, type StatusBarProps, type StatusBarTone, } from "./StatusBar.js";
+export { WorkbenchShell, type WorkbenchShellProps } from "./WorkbenchShell.js";
+export { COLUMN_TYPES, asBinary, buildColumnMeta, cellText, columnSignature, compareCells, isNumericType, normalizeColumnType, sniffColumnType, viewRowIndexes, type BinaryCell, type ColumnType, type GridColumn, type GridColumnMeta, type GridRow, type GridSort, type SortDirection, } from "./grid-model.js";
+export { EMPTY_SELECTION, extendSelection, isSelected, moveActive, selectAll, selectCell, selectColumn, selectRow, selectionBounds, selectionSize, toggleCell, type CellRef, type SelectionRange, type SelectionState, } from "./grid-selection.js";
+export { EXPORT_FORMATS, exportBlob, exportMatrix, formatMatrix, quoteIdentifier, rowsMatrix, selectionMatrix, sqlLiteral, toCSV, toInsert, toJSON, toJSONL, toMarkdown, toTSV, type CellMatrix, type CopyFormat, type ExportFile, type ExportFormat, } from "./grid-format.js";
+export { computeStats, formatStatValue, numericSummary, profileColumn, type ColumnProfile, type ColumnStats, type NumericSummary, type ProfileKind, } from "./grid-stats.js";
+export { NO_CHANGES, addRow, changeSetToSql, deleteRows, editCell, insertedKeys, isCellChanged, parseCellInput, pendingCounts, pendingValue, revertRow, toChangeSet, type ChangeSet, type ChangeSetDelete, type ChangeSetInsert, type ChangeSetUpdate, type PendingChanges, type PendingCounts, type PendingRow, type PendingState, } from "./pending.js";
+export { downloadBase64, downloadBlob, downloadExport } from "./download.js";
+export { ColumnKeyIcons, ColumnTypeIcon, GridCellValue, type ColumnKeyIconsProps, type ColumnTypeIconProps, type GridCellValueProps, } from "./GridCell.js";
+export { TruncationBanner, type TruncationBannerProps } from "./TruncationBanner.js";
+export { CellDetailDialog, RowDetailDrawer, type CellDetailDialogProps, type RowDetailDrawerProps, } from "./GridDetails.js";
+export { PendingChangesBar, type PendingChangesBarProps } from "./PendingChangesBar.js";
+export { DataGrid, type DataGridProps, type GridCommitError, type GridCopyEvent, type GridExportOption, type GridExportRequest, } from "./DataGrid.js";
+export { DataProfile, type DataProfileProps } from "./DataProfile.js";
+export { DataChart, type ChartKind, type ChartLibrary, type DataChartProps } from "./DataChart.js";
+export { CodeEditor, configureMonaco, type CodeEditorProps, type MonacoApi, type MonacoEditor, } from "./CodeEditor.js";
+export { SqlEditor, type SqlEditorProps } from "./SqlEditor.js";
+export { ambiguousColumns, extractTableRefs, isDdlStatement, resolveSqlDot, sqlCompletions, sqlCursorContext, sqlMatch, statementAt, SQL_FUNCTIONS, SQL_KEYWORDS, type SqlColumn, type SqlCompletion, type SqlCompletionKind, type SqlCompletionResult, type SqlCursorContext, type SqlDotTarget, type SqlSchema, type SqlSchemaRequest, type SqlTable, type SqlTableRef, } from "./sql-completion.js";
+export { cssColorToHex, editorTheme, readEditorPalette, type EditorPalette, type EditorThemeData, } from "./editor-theme.js";

package/dist/workbench/index.js

@@ -14,3 +14,34 @@ export { FileGrid } from "./FileGrid.js";
 export { FileBrowser } from "./FileBrowser.js";
 export { UploadDropzone, } from "./UploadDropzone.js";
 export { FilePreview } from "./FilePreview.js";
+// The IDE shell.
+export { formatShortcut, isMacPlatform, matchesShortcut, parseShortcut, shortcutKeys, } from "./keys.js";
+export { KeyboardShortcutsDialog, ShortcutKeys, useRegisteredShortcuts, useShortcuts, } from "./Shortcuts.js";
+export { fuzzyScore, rankItems } from "./palette.js";
+export { CommandPalette } from "./CommandPalette.js";
+export { MenuBar } from "./MenuBar.js";
+export { ActivityBar } from "./ActivityBar.js";
+export { EditorGroup, EditorTabs, editorTabId, } from "./EditorTabs.js";
+export { Pane, PaneGroup, resolvePaneSizes, } from "./PaneGroup.js";
+export { BottomPanel } from "./BottomPanel.js";
+export { StatusBar, StatusBarItem, } from "./StatusBar.js";
+export { WorkbenchShell } from "./WorkbenchShell.js";
+// The data grid, profile and chart.
+export { COLUMN_TYPES, asBinary, buildColumnMeta, cellText, columnSignature, compareCells, isNumericType, normalizeColumnType, sniffColumnType, viewRowIndexes, } from "./grid-model.js";
+export { EMPTY_SELECTION, extendSelection, isSelected, moveActive, selectAll, selectCell, selectColumn, selectRow, selectionBounds, selectionSize, toggleCell, } from "./grid-selection.js";
+export { EXPORT_FORMATS, exportBlob, exportMatrix, formatMatrix, quoteIdentifier, rowsMatrix, selectionMatrix, sqlLiteral, toCSV, toInsert, toJSON, toJSONL, toMarkdown, toTSV, } from "./grid-format.js";
+export { computeStats, formatStatValue, numericSummary, profileColumn, } from "./grid-stats.js";
+export { NO_CHANGES, addRow, changeSetToSql, deleteRows, editCell, insertedKeys, isCellChanged, parseCellInput, pendingCounts, pendingValue, revertRow, toChangeSet, } from "./pending.js";
+export { downloadBase64, downloadBlob, downloadExport } from "./download.js";
+export { ColumnKeyIcons, ColumnTypeIcon, GridCellValue, } from "./GridCell.js";
+export { TruncationBanner } from "./TruncationBanner.js";
+export { CellDetailDialog, RowDetailDrawer, } from "./GridDetails.js";
+export { PendingChangesBar } from "./PendingChangesBar.js";
+export { DataGrid, } from "./DataGrid.js";
+export { DataProfile } from "./DataProfile.js";
+export { DataChart } from "./DataChart.js";
+// The code and SQL editors (Monaco, an optional peer the host loads).
+export { CodeEditor, configureMonaco, } from "./CodeEditor.js";
+export { SqlEditor } from "./SqlEditor.js";
+export { ambiguousColumns, extractTableRefs, isDdlStatement, resolveSqlDot, sqlCompletions, sqlCursorContext, sqlMatch, statementAt, SQL_FUNCTIONS, SQL_KEYWORDS, } from "./sql-completion.js";
+export { cssColorToHex, editorTheme, readEditorPalette, } from "./editor-theme.js";

package/dist/workbench/keys.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Keyboard chords as strings: `"Mod+K"`, `"Mod+Shift+A"`, `"Alt+ArrowLeft"`,
+ * `"F2"`. `Mod` is Command on a Mac and Control elsewhere, so one binding
+ * serves both. Pure: parsing, matching and display, no listeners.
+ */
+export interface KeyChord {
+    /** The key, as `KeyboardEvent.key` names it, lowercased for letters. */
+    key: string;
+    mod: boolean;
+    ctrl: boolean;
+    meta: boolean;
+    alt: boolean;
+    shift: boolean;
+}
+export declare function parseShortcut(shortcut: string): KeyChord;
+export declare function isMacPlatform(): boolean;
+type KeyEventLike = Pick<KeyboardEvent, "key" | "code" | "ctrlKey" | "metaKey" | "altKey" | "shiftKey">;
+export declare function matchesShortcut(event: KeyEventLike, shortcut: string | KeyChord, isMac?: boolean): boolean;
+/** The keys of a chord as they are drawn: `["⌘", "K"]` on a Mac, `["Ctrl", "K"]` elsewhere. */
+export declare function shortcutKeys(shortcut: string, isMac?: boolean): string[];
+/** One string for a menu or a tooltip: `"⌘K"` on a Mac, `"Ctrl+K"` elsewhere. */
+export declare function formatShortcut(shortcut: string, isMac?: boolean): string;
+export {};

package/dist/workbench/keys.js

@@ -0,0 +1,105 @@
+/**
+ * Keyboard chords as strings: `"Mod+K"`, `"Mod+Shift+A"`, `"Alt+ArrowLeft"`,
+ * `"F2"`. `Mod` is Command on a Mac and Control elsewhere, so one binding
+ * serves both. Pure: parsing, matching and display, no listeners.
+ */
+const MODIFIERS = new Set(["mod", "ctrl", "control", "meta", "cmd", "alt", "option", "shift"]);
+export function parseShortcut(shortcut) {
+    const chord = {
+        key: "",
+        mod: false,
+        ctrl: false,
+        meta: false,
+        alt: false,
+        shift: false,
+    };
+    // "Mod++" binds the plus key: the last part is the key, even when empty.
+    const plus = shortcut === "+" || shortcut.endsWith("++");
+    const parts = (plus ? shortcut.slice(0, -1) : shortcut).split("+");
+    const last = parts.pop() ?? "";
+    const raw = plus ? "+" : last;
+    for (const part of parts) {
+        const p = part.trim().toLowerCase();
+        if (!MODIFIERS.has(p))
+            throw new Error(`Unknown modifier "${part}" in "${shortcut}"`);
+        if (p === "mod")
+            chord.mod = true;
+        else if (p === "ctrl" || p === "control")
+            chord.ctrl = true;
+        else if (p === "meta" || p === "cmd")
+            chord.meta = true;
+        else if (p === "alt" || p === "option")
+            chord.alt = true;
+        else
+            chord.shift = true;
+    }
+    const key = raw.trim() || raw;
+    chord.key = key.length === 1 ? key.toLowerCase() : key;
+    return chord;
+}
+export function isMacPlatform() {
+    if (typeof navigator === "undefined")
+        return false;
+    const nav = navigator;
+    return /mac|iphone|ipad/i.test(nav.userAgentData?.platform ?? nav.platform ?? "");
+}
+/** The key a physical code stands for, so Alt and Shift layouts still match letters and digits. */
+function keyFromCode(code) {
+    const m = /^(?:Key([A-Z])|Digit(\d))$/.exec(code);
+    if (!m)
+        return null;
+    return (m[1] ?? m[2] ?? "").toLowerCase();
+}
+export function matchesShortcut(event, shortcut, isMac = isMacPlatform()) {
+    const chord = typeof shortcut === "string" ? parseShortcut(shortcut) : shortcut;
+    const wantCtrl = chord.ctrl || (chord.mod && !isMac);
+    const wantMeta = chord.meta || (chord.mod && isMac);
+    if (event.ctrlKey !== wantCtrl || event.metaKey !== wantMeta || event.altKey !== chord.alt) {
+        return false;
+    }
+    const key = event.key.length === 1 ? event.key.toLowerCase() : event.key;
+    // A shifted symbol ("?" for Shift+/) carries its shift in the key itself.
+    if (event.shiftKey !== chord.shift &&
+        !(key === chord.key && key.length === 1 && !/[a-z0-9]/.test(key))) {
+        return false;
+    }
+    return key === chord.key || keyFromCode(event.code) === chord.key;
+}
+const MAC_GLYPH = {
+    mod: "⌘",
+    meta: "⌘",
+    ctrl: "⌃",
+    alt: "⌥",
+    shift: "⇧",
+};
+const KEY_NAME = {
+    ArrowUp: "↑",
+    ArrowDown: "↓",
+    ArrowLeft: "←",
+    ArrowRight: "→",
+    Enter: "Enter",
+    Escape: "Esc",
+    Backspace: "Backspace",
+    Delete: "Del",
+    " ": "Space",
+};
+/** The keys of a chord as they are drawn: `["⌘", "K"]` on a Mac, `["Ctrl", "K"]` elsewhere. */
+export function shortcutKeys(shortcut, isMac = isMacPlatform()) {
+    const chord = parseShortcut(shortcut);
+    const keys = [];
+    const add = (name, label) => keys.push(isMac ? (MAC_GLYPH[name] ?? label) : label);
+    if (chord.ctrl || (chord.mod && !isMac))
+        add("ctrl", "Ctrl");
+    if (chord.alt)
+        add("alt", "Alt");
+    if (chord.shift)
+        add("shift", "Shift");
+    if (chord.meta || (chord.mod && isMac))
+        add("meta", "Meta");
+    keys.push(KEY_NAME[chord.key] ?? (chord.key.length === 1 ? chord.key.toUpperCase() : chord.key));
+    return keys;
+}
+/** One string for a menu or a tooltip: `"⌘K"` on a Mac, `"Ctrl+K"` elsewhere. */
+export function formatShortcut(shortcut, isMac = isMacPlatform()) {
+    return shortcutKeys(shortcut, isMac).join(isMac ? "" : "+");
+}

package/dist/workbench/palette.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The command palette's matching: pure, so a host can rank its own lists
+ * with the same rules the palette uses.
+ */
+/**
+ * How well `query` matches `text` as a subsequence, higher is better, or -1
+ * when it does not match. Consecutive characters, word starts and an exact
+ * prefix score more, so "nq" ranks "New Query" above "Run query".
+ */
+export declare function fuzzyScore(text: string, query: string): number;
+export interface PaletteMatchable {
+    label: string;
+    keywords?: string;
+    group?: string;
+}
+/** The items that match, best first; ties keep the given order. */
+export declare function rankItems<T extends PaletteMatchable>(items: readonly T[], query: string): T[];

package/dist/workbench/palette.js

@@ -0,0 +1,45 @@
+/**
+ * The command palette's matching: pure, so a host can rank its own lists
+ * with the same rules the palette uses.
+ */
+/**
+ * How well `query` matches `text` as a subsequence, higher is better, or -1
+ * when it does not match. Consecutive characters, word starts and an exact
+ * prefix score more, so "nq" ranks "New Query" above "Run query".
+ */
+export function fuzzyScore(text, query) {
+    const q = query.trim().toLowerCase();
+    if (q === "")
+        return 0;
+    const t = text.toLowerCase();
+    if (t.startsWith(q))
+        return 1000 - t.length;
+    let score = 0;
+    let ti = 0;
+    let streak = 0;
+    for (const ch of q) {
+        if (ch === " ")
+            continue;
+        const found = t.indexOf(ch, ti);
+        if (found === -1)
+            return -1;
+        const wordStart = found === 0 || /[\s\-_./:]/.test(t[found - 1] ?? "");
+        streak = found === ti ? streak + 1 : 0;
+        score += 1 + streak * 3 + (wordStart ? 8 : 0) - Math.min(found - ti, 10) * 0.1;
+        ti = found + 1;
+    }
+    return score;
+}
+/** The items that match, best first; ties keep the given order. */
+export function rankItems(items, query) {
+    if (query.trim() === "")
+        return [...items];
+    return items
+        .map((item, index) => {
+        const score = Math.max(fuzzyScore(item.label, query), item.keywords ? fuzzyScore(item.keywords, query) - 1 : -1);
+        return { item, index, score };
+    })
+        .filter((r) => r.score >= 0)
+        .sort((a, b) => b.score - a.score || a.index - b.index)
+        .map((r) => r.item);
+}

package/dist/workbench/pending.d.ts

@@ -0,0 +1,92 @@
+import { type ColumnType, type GridRow } from "./grid-model.js";
+export type PendingState = "modified" | "added" | "deleted";
+/** One row that differs from what the host holds. */
+export interface PendingRow {
+    state: PendingState;
+    /** The row as it was read; empty for an inserted row. */
+    original: GridRow;
+    /** The row as it will be written. */
+    values: GridRow;
+}
+export interface PendingChanges {
+    readonly rows: ReadonlyMap<number, PendingRow>;
+    /** Rows inserted so far, for the next insert's key. */
+    readonly inserted: number;
+}
+export declare const NO_CHANGES: PendingChanges;
+/**
+ * Sets one cell. `source` is the row as read (unused for an inserted row).
+ * An edit back to the original value drops the row's entry.
+ */
+export declare function editCell(changes: PendingChanges, key: number, column: string, value: unknown, source: GridRow | undefined): PendingChanges;
+/** Inserts a row of NULLs, or a copy of `from` (duplicate). Returns the new row's key. */
+export declare function addRow(changes: PendingChanges, columns: readonly string[], from?: GridRow): {
+    changes: PendingChanges;
+    key: number;
+};
+/** Marks rows deleted; an inserted row is simply dropped. */
+export declare function deleteRows(changes: PendingChanges, keys: Iterable<number>, sourceOf: (key: number) => GridRow | undefined): PendingChanges;
+/** Forgets every change to one row (an inserted row disappears). */
+export declare function revertRow(changes: PendingChanges, key: number): PendingChanges;
+/** The value a cell shows: the pending value when there is one. */
+export declare function pendingValue(changes: PendingChanges, key: number, column: string, source: GridRow | undefined): unknown;
+/** True when the cell will be written: every cell of an inserted row, the edited cells of a modified one. */
+export declare function isCellChanged(changes: PendingChanges, key: number, column: string): boolean;
+/** The keys of the inserted rows, in the order they were added. */
+export declare function insertedKeys(changes: PendingChanges): number[];
+export interface PendingCounts {
+    inserts: number;
+    updates: number;
+    deletes: number;
+    total: number;
+}
+export declare function pendingCounts(changes: PendingChanges): PendingCounts;
+/** One statement's worth of a commit. `key` is the grid's row key, for reporting a failure back. */
+export interface ChangeSetInsert {
+    key: number;
+    /** The cells the person filled; an untouched NULL is left to the column's default. */
+    values: Record<string, unknown>;
+}
+export interface ChangeSetUpdate {
+    key: number;
+    /** The primary key values the row was read under. */
+    primaryKey: Record<string, unknown>;
+    /** The changed cells only. */
+    values: Record<string, unknown>;
+    /** The old values of exactly those cells, for an optimistic-concurrency check (JSON and binary cells left out). */
+    expected: Record<string, unknown>;
+}
+export interface ChangeSetDelete {
+    key: number;
+    primaryKey: Record<string, unknown>;
+}
+/** What a commit hands the host. */
+export interface ChangeSet {
+    inserts: ChangeSetInsert[];
+    updates: ChangeSetUpdate[];
+    deletes: ChangeSetDelete[];
+}
+/**
+ * The pending changes as a batch to write. Updates and deletes are keyed on
+ * `primaryKeys`; without one they cannot name a row, and the grid only
+ * offers inserts.
+ */
+export declare function toChangeSet(changes: PendingChanges, options: {
+    columns: readonly string[];
+    primaryKeys: readonly string[];
+}): ChangeSet;
+/**
+ * A change set as SQL statements, for a host that runs SQL rather than an
+ * apply endpoint: INSERT, UPDATE ... WHERE <primary key>, DELETE ... WHERE
+ * <primary key>. Literals are quoted by `sqlLiteral`; dialect differences
+ * beyond ANSI quoting are the host's.
+ */
+export declare function changeSetToSql(changeSet: ChangeSet, options: {
+    table: string;
+}): string[];
+/**
+ * What a typed cell means: empty or "NULL" is NULL; a number or boolean
+ * column (by its type, or the original value's) keeps its type when the
+ * text parses as one.
+ */
+export declare function parseCellInput(text: string, original: unknown, type?: ColumnType): unknown;