@joewinke/jatui 0.40.0 → 0.41.0

package/dist/components/tree/TreeView.svelte.d.ts

@@ -0,0 +1,123 @@
+export interface TreeRowContext {
+    id: string;
+    level: number;
+    expanded: boolean;
+    hasChildren: boolean;
+    selected: boolean;
+    focused: boolean;
+    disabled: boolean;
+}
+/** Pass `createRowWindow` from `jatui/virtual`; TreeView never imports it itself. */
+export interface TreeViewVirtualOptions {
+    createRowWindow: (opts: {
+        count: () => number;
+        getKey: (index: number) => string;
+        estimateSize: (index: number) => number;
+        overscan?: number;
+        threshold?: number;
+        scrollRoot?: HTMLElement | Window | 'auto';
+    }) => {
+        readonly items: ReadonlyArray<{
+            index: number;
+            key: string;
+            gapBefore: number;
+        }>;
+        readonly paddingTop: number;
+        readonly paddingBottom: number;
+        readonly windowed: boolean;
+        measure: (node: HTMLElement, key: string) => {
+            update?(key: string): void;
+            destroy(): void;
+        };
+        anchor: (node: HTMLElement) => {
+            destroy(): void;
+        };
+        scrollToKey(key: string, opts?: {
+            align?: 'auto' | 'start' | 'center' | 'end';
+        }): void;
+    };
+    /** Row height estimate in px (default: the size's row height). */
+    estimateRowSize?: number;
+    overscan?: number;
+    /** Render everything below this many visible rows (default 0 = always window). */
+    threshold?: number;
+    scrollRoot?: HTMLElement | Window | 'auto';
+}
+import { type Snippet } from 'svelte';
+declare function $$render<T>(): {
+    props: {
+        nodes: readonly T[];
+        /** Default: `node.id`. */
+        getId?: (node: T) => string;
+        /** Default: `node.children`. */
+        getChildren?: (node: T) => readonly T[] | null | undefined;
+        /** Text for the row and typeahead. Default: `node.label ?? node.name ?? id`. */
+        getLabel?: (node: T) => string;
+        /** Branch override for lazily-loaded folders (show a chevron before children arrive). */
+        hasChildren?: (node: T) => boolean;
+        isDisabled?: (node: T) => boolean;
+        /** Open branch ids. Replaced (never mutated) on change. */
+        expanded?: Set<string>;
+        /** Selected ids. Replaced (never mutated) on change. */
+        selected?: Set<string>;
+        selectionMode?: "none" | "single" | "multiple";
+        size?: "sm" | "md";
+        showGuides?: boolean;
+        /** Default folder/file icons. False hides them (an `icon` snippet still wins). */
+        icons?: boolean;
+        /** Clicking a branch row (not just its chevron) toggles it. */
+        expandOnClick?: boolean;
+        /** Expand/collapse animation. Always off under reduced motion and while windowed. */
+        animate?: boolean;
+        /** CSS max-height; makes the tree its own scroller. */
+        maxHeight?: string;
+        ariaLabel?: string;
+        emptyText?: string;
+        virtual?: TreeViewVirtualOptions;
+        label?: Snippet<[T, TreeRowContext]>;
+        icon?: Snippet<[T, TreeRowContext]>;
+        trailing?: Snippet<[T, TreeRowContext]>;
+        empty?: Snippet;
+        onExpandedChange?: (expanded: Set<string>) => void;
+        onSelectionChange?: (selected: Set<string>) => void;
+        /** A branch just opened: load its children here if they are lazy. */
+        onExpand?: (node: T) => void;
+        /** Enter or double-click. */
+        onAction?: (node: T) => void;
+        onRowContextMenu?: (node: T, event: MouseEvent) => void;
+        class?: string;
+    };
+    exports: {
+        expandAll: () => void;
+        collapseAll: () => void;
+        reveal: (id: string) => Promise<void>;
+        focus: (id?: string) => void;
+        visibleIds: () => string[];
+    };
+    bindings: "expanded" | "selected";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T> {
+    props(): ReturnType<typeof $$render<T>>['props'];
+    events(): ReturnType<typeof $$render<T>>['events'];
+    slots(): ReturnType<typeof $$render<T>>['slots'];
+    bindings(): "expanded" | "selected";
+    exports(): {
+        expandAll: () => void;
+        collapseAll: () => void;
+        reveal: (id: string) => Promise<void>;
+        focus: (id?: string) => void;
+        visibleIds: () => string[];
+    };
+}
+interface $$IsomorphicComponent {
+    new <T>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<T>['bindings']>;
+    } & ReturnType<__sveltets_Render<T>['exports']>;
+    <T>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const TreeView: $$IsomorphicComponent;
+type TreeView<T> = InstanceType<typeof TreeView<T>>;
+export default TreeView;

package/dist/components/tree/flattenTree.d.ts

@@ -0,0 +1,57 @@
+/**
+ * flattenTree: nested data → the flat, visible row list a TreeView renders
+ * (BoardUI wave 3, jatui-6kitr).
+ *
+ * A tree is rendered as ONE flat list of `role="treeitem"` rows carrying
+ * aria-level / aria-posinset / aria-setsize, not nested `<ul>`s. That keeps the
+ * row list windowable (`jatui/virtual`) and makes the keyboard model a walk
+ * over an array. Collapsed branches contribute their own row only.
+ *
+ * Connector guides are computed here in the same O(n) pass. Column c (0-based)
+ * is the trunk of the ancestor at level c+1, centred under its chevron. A row
+ * at level L may draw:
+ *   - `guides[c]` for c = 0..L-3: a full-height trunk, drawn when the row's
+ *     ancestor at level c+2 still has a LATER sibling (that trunk keeps running
+ *     past this row);
+ *   - an elbow in column L-2 (its parent's trunk turning into the row), with a
+ *     tail to the bottom unless `isLastSibling`. Roots have no elbow;
+ *   - a bridge in column L-1, below its own chevron, when it is an expanded
+ *     branch with children showing.
+ *
+ * Pure, DOM-free and unit-tested (tests/unit/flattenTree.test.ts).
+ */
+export interface FlattenTreeOptions<T> {
+    /** Stable id per node. */
+    getId: (node: T) => string;
+    /** Child list, or undefined/empty for a leaf. */
+    getChildren: (node: T) => readonly T[] | null | undefined;
+    /** Which branches are open: a Set of ids or a predicate. */
+    expanded: ReadonlySet<string> | ((id: string, node: T) => boolean);
+    /**
+     * Override "is this a branch". Lets a lazily-loaded folder whose children
+     * have not arrived yet still show a chevron. Default: has ≥1 child.
+     */
+    hasChildren?: (node: T) => boolean;
+}
+export interface FlatTreeNode<T> {
+    id: string;
+    node: T;
+    /** 1-based depth (aria-level). */
+    level: number;
+    /** 1-based position among its siblings (aria-posinset). */
+    posinset: number;
+    /** Sibling count (aria-setsize). */
+    setsize: number;
+    parentId: string | null;
+    hasChildren: boolean;
+    /** Open AND a branch. */
+    expanded: boolean;
+    isLastSibling: boolean;
+    /** Length max(0, level-2): ancestor trunk columns that continue through this row. */
+    guides: boolean[];
+}
+export declare function flattenTree<T>(nodes: readonly T[], opts: FlattenTreeOptions<T>): FlatTreeNode<T>[];
+/** Every branch id in the tree (expand-all). */
+export declare function collectBranchIds<T>(nodes: readonly T[], getId: (node: T) => string, getChildren: (node: T) => readonly T[] | null | undefined): string[];
+/** Ids from the root down to `id` (inclusive), or null when absent. Open these to reveal a node. */
+export declare function pathToNode<T>(nodes: readonly T[], id: string, getId: (node: T) => string, getChildren: (node: T) => readonly T[] | null | undefined): string[] | null;

package/dist/components/tree/flattenTree.js

@@ -0,0 +1,91 @@
+/**
+ * flattenTree: nested data → the flat, visible row list a TreeView renders
+ * (BoardUI wave 3, jatui-6kitr).
+ *
+ * A tree is rendered as ONE flat list of `role="treeitem"` rows carrying
+ * aria-level / aria-posinset / aria-setsize, not nested `<ul>`s. That keeps the
+ * row list windowable (`jatui/virtual`) and makes the keyboard model a walk
+ * over an array. Collapsed branches contribute their own row only.
+ *
+ * Connector guides are computed here in the same O(n) pass. Column c (0-based)
+ * is the trunk of the ancestor at level c+1, centred under its chevron. A row
+ * at level L may draw:
+ *   - `guides[c]` for c = 0..L-3: a full-height trunk, drawn when the row's
+ *     ancestor at level c+2 still has a LATER sibling (that trunk keeps running
+ *     past this row);
+ *   - an elbow in column L-2 (its parent's trunk turning into the row), with a
+ *     tail to the bottom unless `isLastSibling`. Roots have no elbow;
+ *   - a bridge in column L-1, below its own chevron, when it is an expanded
+ *     branch with children showing.
+ *
+ * Pure, DOM-free and unit-tested (tests/unit/flattenTree.test.ts).
+ */
+function isOpen(expanded, id, node) {
+    return typeof expanded === 'function' ? expanded(id, node) : expanded.has(id);
+}
+export function flattenTree(nodes, opts) {
+    const out = [];
+    const { getId, getChildren } = opts;
+    const branch = opts.hasChildren ?? ((n) => (getChildren(n)?.length ?? 0) > 0);
+    // `trail[i]` = "the ancestor at level i+2 has a later sibling".
+    const walk = (list, level, parentId, trail) => {
+        const setsize = list.length;
+        for (let i = 0; i < setsize; i++) {
+            const node = list[i];
+            const id = getId(node);
+            const kids = getChildren(node) ?? [];
+            const hasChildren = branch(node);
+            const open = hasChildren && isOpen(opts.expanded, id, node);
+            const isLastSibling = i === setsize - 1;
+            out.push({
+                id,
+                node,
+                level,
+                posinset: i + 1,
+                setsize,
+                parentId,
+                hasChildren,
+                expanded: open,
+                isLastSibling,
+                guides: trail.slice()
+            });
+            if (open && kids.length) {
+                // Children of this row: their column level-1 trunk is this row's
+                // parent trunk, alive while this row has a later sibling.
+                walk(kids, level + 1, id, level === 1 ? trail : [...trail, !isLastSibling]);
+            }
+        }
+    };
+    walk(nodes, 1, null, []);
+    return out;
+}
+/** Every branch id in the tree (expand-all). */
+export function collectBranchIds(nodes, getId, getChildren) {
+    const ids = [];
+    const walk = (list) => {
+        for (const n of list) {
+            const kids = getChildren(n);
+            if (kids && kids.length) {
+                ids.push(getId(n));
+                walk(kids);
+            }
+        }
+    };
+    walk(nodes);
+    return ids;
+}
+/** Ids from the root down to `id` (inclusive), or null when absent. Open these to reveal a node. */
+export function pathToNode(nodes, id, getId, getChildren) {
+    for (const n of nodes) {
+        const nid = getId(n);
+        if (nid === id)
+            return [nid];
+        const kids = getChildren(n);
+        if (kids && kids.length) {
+            const sub = pathToNode(kids, id, getId, getChildren);
+            if (sub)
+                return [nid, ...sub];
+        }
+    }
+    return null;
+}

package/dist/components/tree/treeKeys.d.ts

@@ -0,0 +1,46 @@
+/**
+ * WAI-ARIA tree keyboard model over a flattened row list (jatui-6kitr).
+ *
+ * Pure: takes the visible rows + the focused id + a key and returns what
+ * should happen. TreeView applies the result. Covers the APG tree pattern:
+ *
+ *   ArrowDown / ArrowUp   next / previous enabled row
+ *   ArrowRight            closed branch → expand; open branch → first enabled
+ *                         child (the step react-aria skips); leaf → nothing
+ *   ArrowLeft             open branch → collapse; otherwise → parent
+ *   Home / End            first / last enabled row
+ *   *                     expand every sibling branch of the focused row
+ *   Enter                 action (open / activate)
+ *   Space                 toggle selection
+ *
+ * Typeahead lives in `treeTypeahead`.
+ */
+import type { FlatTreeNode } from './flattenTree';
+export type TreeKeyResult = {
+    type: 'focus';
+    id: string;
+} | {
+    type: 'expand';
+    id: string;
+} | {
+    type: 'collapse';
+    id: string;
+} | {
+    type: 'expandMany';
+    ids: string[];
+} | {
+    type: 'action';
+    id: string;
+} | {
+    type: 'select';
+    id: string;
+};
+type Row = Pick<FlatTreeNode<unknown>, 'id' | 'level' | 'parentId' | 'hasChildren' | 'expanded'>;
+export declare function resolveTreeKey(rows: readonly Row[], focusedId: string | null, key: string, isDisabled?: (id: string) => boolean): TreeKeyResult | null;
+/**
+ * Typeahead: the next enabled row (after `fromIndex`, wrapping) whose label
+ * starts with `query`, case-insensitive. A query of one repeated character
+ * ("aaa") cycles through rows starting with that character, as in the APG.
+ */
+export declare function treeTypeahead(labels: readonly string[], fromIndex: number, query: string, isDisabled?: (index: number) => boolean): number;
+export {};

package/dist/components/tree/treeKeys.js

@@ -0,0 +1,80 @@
+export function resolveTreeKey(rows, focusedId, key, isDisabled = () => false) {
+    if (!rows.length)
+        return null;
+    let i = focusedId == null ? -1 : rows.findIndex((r) => r.id === focusedId);
+    const enabled = (r) => !!r && !isDisabled(r.id);
+    const scan = (from, step) => {
+        for (let j = from; j >= 0 && j < rows.length; j += step)
+            if (enabled(rows[j]))
+                return rows[j];
+        return null;
+    };
+    const focus = (r) => (r ? { type: 'focus', id: r.id } : null);
+    if (i < 0) {
+        // Nothing focused yet: any navigation key lands on the first row.
+        return ['ArrowDown', 'ArrowUp', 'Home', 'End', 'ArrowRight', 'ArrowLeft'].includes(key)
+            ? focus(key === 'End' || key === 'ArrowUp' ? scan(rows.length - 1, -1) : scan(0, 1))
+            : null;
+    }
+    const row = rows[i];
+    switch (key) {
+        case 'ArrowDown':
+            return focus(scan(i + 1, 1));
+        case 'ArrowUp':
+            return focus(scan(i - 1, -1));
+        case 'Home':
+            return focus(scan(0, 1));
+        case 'End':
+            return focus(scan(rows.length - 1, -1));
+        case 'ArrowRight': {
+            if (!row.hasChildren)
+                return null;
+            if (!row.expanded)
+                return isDisabled(row.id) ? null : { type: 'expand', id: row.id };
+            // Open branch: step into the first enabled child (rows directly below at level+1).
+            for (let j = i + 1; j < rows.length && rows[j].level > row.level; j++) {
+                if (rows[j].level === row.level + 1 && enabled(rows[j]))
+                    return { type: 'focus', id: rows[j].id };
+            }
+            return null;
+        }
+        case 'ArrowLeft': {
+            if (row.hasChildren && row.expanded && !isDisabled(row.id))
+                return { type: 'collapse', id: row.id };
+            return row.parentId != null ? { type: 'focus', id: row.parentId } : null;
+        }
+        case '*': {
+            const ids = rows
+                .filter((r) => r.parentId === row.parentId && r.hasChildren && !r.expanded && enabled(r))
+                .map((r) => r.id);
+            return ids.length ? { type: 'expandMany', ids } : null;
+        }
+        case 'Enter':
+            return enabled(row) ? { type: 'action', id: row.id } : null;
+        case ' ':
+            return enabled(row) ? { type: 'select', id: row.id } : null;
+        default:
+            return null;
+    }
+}
+/**
+ * Typeahead: the next enabled row (after `fromIndex`, wrapping) whose label
+ * starts with `query`, case-insensitive. A query of one repeated character
+ * ("aaa") cycles through rows starting with that character, as in the APG.
+ */
+export function treeTypeahead(labels, fromIndex, query, isDisabled = () => false) {
+    if (!query || !labels.length)
+        return -1;
+    const q = query.toLocaleLowerCase();
+    const repeated = q.length > 1 && [...q].every((c) => c === q[0]);
+    const needle = repeated ? q[0] : q;
+    // A multi-char query keeps matching the current row; a fresh/repeated one moves on.
+    const start = needle.length > 1 ? fromIndex : fromIndex + 1;
+    const n = labels.length;
+    for (let k = 0; k < n; k++) {
+        const j = (((start + k) % n) + n) % n;
+        if (!isDisabled(j) && labels[j].toLocaleLowerCase().startsWith(needle))
+            return j;
+    }
+    return -1;
+}

package/dist/data/grid/cells.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Cell addressing + typed value parsing (jatui/grid, jatui-6kitr).
+ */
+/** 0 → "A", 25 → "Z", 26 → "AA", 701 → "ZZ", 702 → "AAA". */
+export declare function columnLetter(index: number): string;
+/** "A" → 0, "AA" → 26 (case-insensitive). -1 for anything that is not letters. */
+export declare function columnIndex(letters: string): number;
+/** "B3" → { col: 1, row: 2 } (0-based). Null when it is not an A1 reference. */
+export declare function parseCellRef(ref: string): {
+    col: number;
+    row: number;
+} | null;
+export type GridCellType = 'text' | 'number' | 'select' | 'boolean';
+export interface GridCellSpec {
+    type?: GridCellType;
+    required?: boolean;
+    /** number: inclusive bounds. */
+    min?: number;
+    max?: number;
+    /** number: round to this many decimals. */
+    decimals?: number;
+    /** select: allowed values (matched case-insensitively, returned in their canonical case). */
+    options?: readonly string[];
+    /** text: max length. */
+    maxLength?: number;
+}
+export type ParseCellResult<V = unknown> = {
+    ok: true;
+    value: V;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Parse what a person typed or pasted into a typed cell value, with a
+ * human-readable error. Numbers accept thousands separators, a leading
+ * currency sign and a trailing %, e.g. "$1,234.50" → 1234.5, "12%" → 0.12.
+ * Empty input is `null` unless `required`.
+ */
+export declare function parseCellValue(raw: string, spec?: GridCellSpec): ParseCellResult;

package/dist/data/grid/cells.js

@@ -0,0 +1,89 @@
+/**
+ * Cell addressing + typed value parsing (jatui/grid, jatui-6kitr).
+ */
+/** 0 → "A", 25 → "Z", 26 → "AA", 701 → "ZZ", 702 → "AAA". */
+export function columnLetter(index) {
+    if (!Number.isInteger(index) || index < 0)
+        throw new RangeError(`columnLetter: bad index ${index}`);
+    let s = '';
+    let n = index + 1;
+    while (n > 0) {
+        const r = (n - 1) % 26;
+        s = String.fromCharCode(65 + r) + s;
+        n = Math.floor((n - 1) / 26);
+    }
+    return s;
+}
+/** "A" → 0, "AA" → 26 (case-insensitive). -1 for anything that is not letters. */
+export function columnIndex(letters) {
+    if (!/^[A-Za-z]+$/.test(letters))
+        return -1;
+    let n = 0;
+    for (const ch of letters.toUpperCase())
+        n = n * 26 + (ch.charCodeAt(0) - 64);
+    return n - 1;
+}
+/** "B3" → { col: 1, row: 2 } (0-based). Null when it is not an A1 reference. */
+export function parseCellRef(ref) {
+    const m = /^\s*([A-Za-z]+)(\d+)\s*$/.exec(ref);
+    if (!m || Number(m[2]) < 1)
+        return null;
+    return { col: columnIndex(m[1]), row: Number(m[2]) - 1 };
+}
+const TRUE = new Set(['true', 'yes', 'y', '1', 'on', '✓', 'x']);
+const FALSE = new Set(['false', 'no', 'n', '0', 'off', '']);
+/**
+ * Parse what a person typed or pasted into a typed cell value, with a
+ * human-readable error. Numbers accept thousands separators, a leading
+ * currency sign and a trailing %, e.g. "$1,234.50" → 1234.5, "12%" → 0.12.
+ * Empty input is `null` unless `required`.
+ */
+export function parseCellValue(raw, spec = {}) {
+    const type = spec.type ?? 'text';
+    const s = raw.trim();
+    if (s === '' && type !== 'boolean') {
+        return spec.required ? { ok: false, error: 'Required' } : { ok: true, value: null };
+    }
+    switch (type) {
+        case 'number': {
+            const pct = s.endsWith('%');
+            const neg = /^\(.*\)$/.test(s); // accounting negatives: (12.50)
+            const cleaned = s.replace(/^\(|\)$/g, '').replace(/%$/, '').replace(/[\p{Sc},\s_]/gu, '');
+            if (!/^[-+]?(\d+\.?\d*|\.\d+)(e[-+]?\d+)?$/i.test(cleaned))
+                return { ok: false, error: 'Not a number' };
+            let v = Number(cleaned);
+            if (neg)
+                v = -v;
+            if (pct)
+                v = v / 100;
+            if (spec.decimals != null)
+                v = Number(v.toFixed(spec.decimals));
+            if (spec.min != null && v < spec.min)
+                return { ok: false, error: `Must be at least ${spec.min}` };
+            if (spec.max != null && v > spec.max)
+                return { ok: false, error: `Must be at most ${spec.max}` };
+            return { ok: true, value: v };
+        }
+        case 'select': {
+            const opts = spec.options ?? [];
+            const hit = opts.find((o) => o.toLocaleLowerCase() === s.toLocaleLowerCase());
+            return hit != null ? { ok: true, value: hit } : { ok: false, error: `Choose one of: ${opts.join(', ')}` };
+        }
+        case 'boolean': {
+            const k = s.toLocaleLowerCase();
+            if (TRUE.has(k))
+                return { ok: true, value: true };
+            if (FALSE.has(k)) {
+                if (k === '' && spec.required)
+                    return { ok: false, error: 'Required' };
+                return { ok: true, value: false };
+            }
+            return { ok: false, error: 'Not yes or no' };
+        }
+        default: {
+            if (spec.maxLength != null && raw.length > spec.maxLength)
+                return { ok: false, error: `At most ${spec.maxLength} characters` };
+            return { ok: true, value: raw };
+        }
+    }
+}

package/dist/data/grid/clipboard.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Spreadsheet clipboard + CSV I/O (jatui/grid, jatui-6kitr).
+ *
+ * Behaviour follows BoardUI's data-grid utils (MIT, © 2026 Mertcan Dundar
+ * Esmergul): TSV that round-trips quoted tabs/newlines from Excel and Google
+ * Sheets, and CSV export with a BOM and formula-injection escaping. Clean
+ * re-implementation.
+ */
+/**
+ * Parse clipboard text from Excel / Sheets / Numbers into a cell matrix.
+ *
+ * - Tab separates cells, newline (LF or CRLF) separates rows.
+ * - A cell that STARTS with `"` is quoted: tabs and newlines inside it are
+ *   literal and `""` is an escaped quote. (Sheets quotes any cell holding a
+ *   newline or a quote.) A `"` mid-cell is literal.
+ * - One trailing newline (every spreadsheet adds it) does not make an empty row.
+ * - Ragged rows are padded with '' to the widest row.
+ */
+export declare function parseClipboardTsv(text: string): string[][];
+/** Serialize a matrix as clipboard TSV, quoting cells that hold a tab, newline or quote. */
+export declare function serializeTsv(rows: readonly (readonly unknown[])[]): string;
+/**
+ * Neutralise a cell a spreadsheet would execute (`=HYPERLINK(...)`,
+ * `+cmd|...`, `@SUM(...)`) by prefixing a single quote. Only STRINGS are
+ * escaped: a real number such as -5 is data, not a formula.
+ */
+export declare function escapeCsvFormula(value: unknown): unknown;
+export interface SerializeCsvOptions {
+    /** Prefix a UTF-8 BOM so Excel opens non-ASCII text correctly. Default true. */
+    bom?: boolean;
+    /** Escape formula-looking string cells. Default true — turn off only for trusted data. */
+    escapeFormulas?: boolean;
+    /** Default ','. */
+    delimiter?: string;
+    /** Default '\r\n' (RFC 4180). */
+    newline?: string;
+}
+/** RFC 4180 CSV from a matrix (first row = header if you include one). */
+export declare function serializeCsv(rows: readonly (readonly unknown[])[], opts?: SerializeCsvOptions): string;
+export interface CsvColumn<TRow> {
+    header: string;
+    /** Field name or accessor. */
+    value: keyof TRow | ((row: TRow) => unknown);
+}
+/** CSV from objects: one header row, then one row per object. */
+export declare function serializeRowsToCsv<TRow>(data: readonly TRow[], columns: readonly CsvColumn<TRow>[], opts?: SerializeCsvOptions): string;