bo-grid 0.8.0 → 0.25.0

package/dist/grid/export.js

@@ -1,4 +1,4 @@
-import { formatCell, isNumeric } from './column';
+import { formatCell, isNumeric, cellValue } from './column';
 function rawValue(col, v) {
     if (col.type === 'date')
         return formatCell(col, v); // epoch ms isn't useful raw
@@ -19,7 +19,10 @@ export function rowsToMatrix(rows, columns, opts = {}) {
     if (opts.header !== false)
         matrix.push(cols.map((c) => c.header));
     for (const row of rows) {
-        matrix.push(cols.map((c) => (opts.formatted ? formatCell(c, row[c.key], row) : rawValue(c, row[c.key]))));
+        matrix.push(cols.map((c) => {
+            const v = cellValue(c, row);
+            return opts.formatted ? formatCell(c, v, row) : rawValue(c, v);
+        }));
     }
     return matrix;
 }
@@ -46,3 +49,156 @@ export function download(filename, content, mime = 'text/csv;charset=utf-8') {
 export function exportCSV(filename, rows, columns, opts = {}) {
     download(filename, toCSV(rows, columns, opts));
 }
+/**
+ * Parse delimited text (CSV/TSV) into a 2-D string matrix — handles quoted fields
+ * with embedded delimiters, doubled quotes and newlines, and CRLF or LF endings.
+ */
+function parseDelimited(text, delim) {
+    const rows = [];
+    let row = [];
+    let field = '';
+    let inQuotes = false;
+    let i = 0;
+    const endField = () => {
+        row.push(field);
+        field = '';
+    };
+    const endRow = () => {
+        endField();
+        rows.push(row);
+        row = [];
+    };
+    while (i < text.length) {
+        const c = text[i];
+        if (inQuotes) {
+            if (c === '"') {
+                if (text[i + 1] === '"') {
+                    field += '"';
+                    i += 2;
+                }
+                else {
+                    inQuotes = false;
+                    i++;
+                }
+            }
+            else {
+                field += c;
+                i++;
+            }
+            continue;
+        }
+        if (c === '"') {
+            inQuotes = true;
+            i++;
+        }
+        else if (c === delim) {
+            endField();
+            i++;
+        }
+        else if (c === '\n') {
+            endRow();
+            i++;
+        }
+        else if (c === '\r') {
+            i++; // CRLF: the \n ends the row
+        }
+        else {
+            field += c;
+            i++;
+        }
+    }
+    if (field !== '' || row.length > 0)
+        endRow(); // trailing line without a newline
+    return rows;
+}
+/** Parse RFC4180 CSV text into a 2-D string matrix. Pure; inverse of `rowsToMatrix`. */
+export function parseCSVMatrix(text) {
+    return parseDelimited(text, ',');
+}
+// Header-row matrix → grid rows: map each header to a column (by `header` or
+// `key`), coerce numeric columns to numbers and `date` columns to epoch ms, leave
+// blanks/unparseable as-is, and stamp id + flash fields. Drops blank lines.
+function matrixToRows(matrix, columns) {
+    const m = matrix.filter((r) => !(r.length === 1 && r[0] === ''));
+    if (m.length < 1)
+        return [];
+    const headers = m[0];
+    const cols = headers.map((h) => columns.find((c) => c.header === h || c.key === h));
+    return m.slice(1).map((cells, i) => {
+        const row = { id: i, flashSeq: 0, flashDir: 'up' };
+        headers.forEach((h, c) => {
+            const col = cols[c];
+            const raw = cells[c] ?? '';
+            const key = col ? col.key : h;
+            if (raw === '') {
+                row[key] = '';
+            }
+            else if (col?.type === 'date') {
+                const ms = Date.parse(raw);
+                row[key] = Number.isFinite(ms) ? ms : raw;
+            }
+            else if (col && isNumeric(col)) {
+                const n = Number(raw);
+                row[key] = Number.isFinite(n) ? n : raw;
+            }
+            else {
+                row[key] = raw;
+            }
+        });
+        return row;
+    });
+}
+/**
+ * Parse CSV text into grid rows. The first line is the header (mapped to columns
+ * by `header` or `key`); numeric columns coerce to numbers, `date` columns to
+ * epoch ms. Rows get `id` + flash fields so they're `GridRow`-ready. Inverse of
+ * `toCSV` — round-trips. Pure; unit-tested.
+ */
+export function parseCSV(text, columns = []) {
+    return matrixToRows(parseDelimited(text, ','), columns);
+}
+/** Parse TAB-separated text into grid rows (same mapping as `parseCSV`). Handy for
+    spreadsheet/clipboard data — `Ctrl/⌘+C` copies the selection as TSV. */
+export function parseTSV(text, columns = []) {
+    return matrixToRows(parseDelimited(text, '\t'), columns);
+}
+/**
+ * Adapt plain objects (e.g. a JSON API response) to grid rows: stamp `id` (the
+ * object's own `id`, else the index) and `flashSeq`/`flashDir` if absent, keeping
+ * all fields. The cheapest path from `await res.json()` to `<Grid rows>`.
+ */
+export function rowsFromObjects(objects) {
+    return objects.map((o, i) => ({ id: i, flashSeq: 0, flashDir: 'up', ...o }));
+}
+/** Parse a JSON array of objects into grid rows (`JSON.parse` + `rowsFromObjects`).
+    Throws on invalid JSON or a non-array top level. */
+export function parseJSON(text) {
+    const data = JSON.parse(text);
+    if (!Array.isArray(data))
+        throw new Error('parseJSON: expected a JSON array of objects');
+    return rowsFromObjects(data);
+}
+/**
+ * Smart import: detect the format of `text` — a JSON array, TSV, or CSV — and
+ * parse it into grid rows. Ideal for a paste handler where the source is unknown:
+ *
+ *   el.addEventListener('paste', (e) => {
+ *     rows = parseRows(e.clipboardData.getData('text'), columns);
+ *   });
+ *
+ * Leading `[` → JSON (falls through to delimited if it isn't valid JSON); a tab in
+ * the first line → TSV; otherwise CSV. Pure; unit-tested.
+ */
+export function parseRows(text, columns = []) {
+    if (text.trimStart().startsWith('[')) {
+        try {
+            return parseJSON(text);
+        }
+        catch {
+            // Not valid JSON after all — treat it as delimited text below.
+        }
+    }
+    const nl = text.indexOf('\n');
+    const firstLine = nl === -1 ? text : text.slice(0, nl);
+    return firstLine.includes('\t') ? parseTSV(text, columns) : parseCSV(text, columns);
+}

package/dist/grid/filtering.d.ts

@@ -35,7 +35,10 @@ export declare function emptyFilter(kind: FilterKind): ColumnFilter;
 export declare function isFilterActive(f: ColumnFilter | undefined | null): boolean;
 /** Does one cell value satisfy one filter? An inactive filter passes everything. */
 export declare function matchesFilter(value: unknown, f: ColumnFilter): boolean;
+/** Resolve a column's value for filtering — `row[key]` by default; Grid passes a
+    computed-aware resolver so computed columns filter on their derived value. */
+export type ValueResolver = (row: GridRow, key: string) => unknown;
 /** AND across every active per-column filter. */
-export declare function passesFilters(row: GridRow, filters: Record<string, ColumnFilter>): boolean;
+export declare function passesFilters(row: GridRow, filters: Record<string, ColumnFilter>, valueOf?: ValueResolver): boolean;
 /** Sorted unique string values for a column — the set-filter checklist. */
-export declare function distinctValues(rows: readonly GridRow[], key: string): string[];
+export declare function distinctValues(rows: readonly GridRow[], key: string, valueOf?: ValueResolver): string[];

package/dist/grid/filtering.js

@@ -89,19 +89,20 @@ export function matchesFilter(value, f) {
     }
     return true; // unreachable fallback
 }
+const byKey = (row, key) => row[key];
 /** AND across every active per-column filter. */
-export function passesFilters(row, filters) {
+export function passesFilters(row, filters, valueOf = byKey) {
     for (const key in filters) {
         const f = filters[key];
-        if (isFilterActive(f) && !matchesFilter(row[key], f))
+        if (isFilterActive(f) && !matchesFilter(valueOf(row, key), f))
             return false;
     }
     return true;
 }
 /** Sorted unique string values for a column — the set-filter checklist. */
-export function distinctValues(rows, key) {
+export function distinctValues(rows, key, valueOf = byKey) {
     const seen = new Set();
     for (const row of rows)
-        seen.add(String(row[key] ?? ''));
+        seen.add(String(valueOf(row, key) ?? ''));
     return [...seen].sort((a, b) => a.localeCompare(b, undefined, { numeric: true, sensitivity: 'base' }));
 }

package/dist/grid/grouping.d.ts

@@ -10,6 +10,19 @@ export interface GroupNode {
     rows: GridRow[];
     count: number;
     collapsed: boolean;
+    /** Server-provided aggregate display strings, keyed by column key (lazy groups).
+        When present, the group header shows these instead of computing from `rows`. */
+    aggText?: Record<string, string>;
+}
+/** A server-side group summary (lazy grouping): the header data without the leaf
+    rows, which load on expand via `loadGroup`. */
+export interface LazyGroup {
+    key: string;
+    /** Header label (defaults to `key`). */
+    label?: string;
+    count?: number;
+    /** Preformatted aggregate strings keyed by column key, shown in the header. */
+    agg?: Record<string, string>;
 }
 export type VisualRow = {
     kind: 'data';
@@ -19,6 +32,9 @@ export type VisualRow = {
 } | {
     kind: 'group';
     group: GroupNode;
+} | {
+    kind: 'treeloading';
+    depth: number;
 };
 /**
  * Flatten data rows into the visual row list the grid renders: a stream of
@@ -36,3 +52,17 @@ export declare function buildFlatRows(rows: GridRow[], groupBy: string[], collap
  * nearest preceding header at each depth until the depth-0 group is found.
  */
 export declare function activeGroupsAt(flat: VisualRow[], idx: number): GroupNode[];
+/** How lazy grouping reads expand/loading state and the rows loaded per group. */
+export interface LazyGroupAccess {
+    isExpanded: (key: string) => boolean;
+    /** Loaded leaf rows for a group, or undefined when not yet loaded. */
+    rowsOf: (key: string) => readonly GridRow[] | undefined;
+    isLoading: (key: string) => boolean;
+}
+/**
+ * Flatten server-side group summaries into visual rows: a group header per group,
+ * then — when expanded — its loaded leaf rows, or a single `treeloading`
+ * placeholder while they load. Aggregates come from the summary (not computed).
+ * Pure; unit-tested.
+ */
+export declare function buildLazyGroupRows(groups: readonly LazyGroup[], access: LazyGroupAccess): VisualRow[];

package/dist/grid/grouping.js

@@ -60,3 +60,36 @@ export function activeGroupsAt(flat, idx) {
     }
     return [...found.values()].sort((a, b) => a.depth - b.depth);
 }
+/**
+ * Flatten server-side group summaries into visual rows: a group header per group,
+ * then — when expanded — its loaded leaf rows, or a single `treeloading`
+ * placeholder while they load. Aggregates come from the summary (not computed).
+ * Pure; unit-tested.
+ */
+export function buildLazyGroupRows(groups, access) {
+    const out = [];
+    for (const g of groups) {
+        const expanded = access.isExpanded(g.key);
+        out.push({
+            kind: 'group',
+            group: {
+                path: g.key,
+                depth: 0,
+                value: g.label ?? g.key,
+                rows: [],
+                count: g.count ?? 0,
+                collapsed: !expanded,
+                aggText: g.agg,
+            },
+        });
+        if (!expanded)
+            continue;
+        const loaded = access.rowsOf(g.key);
+        if (loaded)
+            for (const row of loaded)
+                out.push({ kind: 'data', row });
+        else if (access.isLoading(g.key))
+            out.push({ kind: 'treeloading', depth: 1 });
+    }
+    return out;
+}

package/dist/grid/print.d.ts

@@ -0,0 +1,17 @@
+import type { ColumnDef, GridRow } from './column';
+/** Escape a string for safe HTML text/attribute interpolation. */
+export declare function escapeHTML(s: string): string;
+/**
+ * Render rows to a semantic `<table>` HTML string (formatted via the column
+ * formatters; numeric columns right-aligned; sparkline/custom columns skipped).
+ * Values are HTML-escaped. Pure; unit-tested. Embed it, or use `printTable`.
+ */
+export declare function toHTMLTable(rows: readonly GridRow[], columns: readonly ColumnDef[]): string;
+/**
+ * Open a print window with all rows as a clean table and trigger the print
+ * dialog. No-op outside the browser (or if a popup is blocked). For PDFs, users
+ * "Save as PDF" from the print dialog.
+ */
+export declare function printTable(rows: readonly GridRow[], columns: readonly ColumnDef[], opts?: {
+    title?: string;
+}): void;

package/dist/grid/print.js

@@ -0,0 +1,55 @@
+import { formatCell, cellValue, isNumeric } from './column';
+const ESC = {
+    '&': '&',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#39;',
+};
+/** Escape a string for safe HTML text/attribute interpolation. */
+export function escapeHTML(s) {
+    return s.replace(/[&<>"']/g, (c) => ESC[c]);
+}
+/**
+ * Render rows to a semantic `<table>` HTML string (formatted via the column
+ * formatters; numeric columns right-aligned; sparkline/custom columns skipped).
+ * Values are HTML-escaped. Pure; unit-tested. Embed it, or use `printTable`.
+ */
+export function toHTMLTable(rows, columns) {
+    const cols = columns.filter((c) => c.type !== 'sparkline' && c.type !== 'custom');
+    const align = (c) => (isNumeric(c) ? ' style="text-align:right"' : '');
+    const head = cols.map((c) => `<th${align(c)}>${escapeHTML(c.header)}</th>`).join('');
+    const body = rows
+        .map((row) => '<tr>' +
+        cols.map((c) => `<td${align(c)}>${escapeHTML(formatCell(c, cellValue(c, row), row))}</td>`).join('') +
+        '</tr>')
+        .join('');
+    return `<table><thead><tr>${head}</tr></thead><tbody>${body}</tbody></table>`;
+}
+const PRINT_CSS = `
+*{box-sizing:border-box}
+body{font:12px -apple-system,system-ui,sans-serif;color:#111;margin:24px}
+h1{font-size:16px;margin:0 0 12px}
+table{border-collapse:collapse;width:100%}
+th,td{padding:4px 8px;border:1px solid #ddd;white-space:nowrap;text-align:left}
+thead th{background:#f4f4f4;font-weight:600}
+tbody tr:nth-child(even){background:#fafafa}
+@media print{body{margin:0}}`;
+/**
+ * Open a print window with all rows as a clean table and trigger the print
+ * dialog. No-op outside the browser (or if a popup is blocked). For PDFs, users
+ * "Save as PDF" from the print dialog.
+ */
+export function printTable(rows, columns, opts = {}) {
+    if (typeof window === 'undefined' || typeof window.open !== 'function')
+        return;
+    const win = window.open('', '_blank');
+    if (!win)
+        return; // popup blocked
+    const title = opts.title ?? 'Grid';
+    win.document.write(`<!doctype html><html><head><meta charset="utf-8"><title>${escapeHTML(title)}</title>` +
+        `<style>${PRINT_CSS}</style></head><body><h1>${escapeHTML(title)}</h1>` +
+        `${toHTMLTable(rows, columns)}` +
+        `<script>window.onload=function(){window.print()}<\/script></body></html>`);
+    win.document.close();
+}

package/dist/grid/theme.d.ts

@@ -35,3 +35,18 @@ export interface GridTheme {
 export declare function themeVars(theme: GridTheme): string;
 export declare const darkTheme: GridTheme;
 export declare const lightTheme: GridTheme;
+export declare const highContrastDark: GridTheme;
+export declare const highContrastLight: GridTheme;
+export declare const midnightTheme: GridTheme;
+export declare const terminalTheme: GridTheme;
+/** All built-in presets, keyed by name (handy for a theme picker). */
+export declare const themePresets: {
+    dark: GridTheme;
+    light: GridTheme;
+    'high-contrast-dark': GridTheme;
+    'high-contrast-light': GridTheme;
+    midnight: GridTheme;
+    terminal: GridTheme;
+};
+/** Built-in preset name. */
+export type ThemePreset = keyof typeof themePresets;

package/dist/grid/theme.js

@@ -64,3 +64,81 @@ export const lightTheme = {
     selBorder: '#6366f1',
     scheme: 'light',
 };
+// High-contrast dark (accessibility): pure black, white text, strong borders and
+// vivid status colours — comfortably exceeds WCAG AA, toward AAA.
+export const highContrastDark = {
+    bg: '#000000',
+    headerBg: '#0a0a0a',
+    rowA: '#000000',
+    rowB: '#0a0a0a',
+    rowHover: '#1c1c1c',
+    text: '#ffffff',
+    textDim: '#c8c8c8',
+    border: 'rgba(255,255,255,0.34)',
+    up: '#00e676',
+    down: '#ff5252',
+    amber: '#ffd740',
+    selFill: 'rgba(255,255,255,0.20)',
+    selBorder: '#ffffff',
+    scheme: 'dark',
+};
+// High-contrast light (accessibility): white, near-black text, strong borders.
+export const highContrastLight = {
+    bg: '#ffffff',
+    headerBg: '#eeeeee',
+    rowA: '#ffffff',
+    rowB: '#f5f5f5',
+    rowHover: '#e3e3e3',
+    text: '#000000',
+    textDim: '#383838',
+    border: 'rgba(0,0,0,0.42)',
+    up: '#007a36',
+    down: '#c20000',
+    amber: '#7a5c00',
+    selFill: 'rgba(0,0,0,0.10)',
+    selBorder: '#000000',
+    scheme: 'light',
+};
+// Midnight: a deep navy/indigo dark theme — a calmer, "premium" alternative.
+export const midnightTheme = {
+    bg: '#0f172a',
+    headerBg: '#0b1120',
+    rowA: '#0f172a',
+    rowB: '#121d35',
+    rowHover: '#1e293b',
+    text: '#e2e8f0',
+    textDim: '#94a3b8',
+    border: 'rgba(148,163,184,0.16)',
+    up: '#34d399',
+    down: '#fb7185',
+    amber: '#fbbf24',
+    selFill: 'rgba(129,140,248,0.22)',
+    selBorder: '#818cf8',
+    scheme: 'dark',
+};
+// Terminal: green phosphor on near-black — a retro fintech/console look.
+export const terminalTheme = {
+    bg: '#0a0f0a',
+    headerBg: '#0d140d',
+    rowA: '#0a0f0a',
+    rowB: '#0e160e',
+    rowHover: '#16241a',
+    text: '#4ade80',
+    textDim: '#3f9e60',
+    border: 'rgba(74,222,128,0.20)',
+    up: '#4ade80',
+    down: '#f87171',
+    amber: '#fde047',
+    selFill: 'rgba(74,222,128,0.16)',
+    selBorder: '#4ade80',
+    scheme: 'dark',
+};
+/** All built-in presets, keyed by name (handy for a theme picker). */
+export const themePresets = {
+    dark: darkTheme,
+    light: lightTheme,
+    'high-contrast-dark': highContrastDark,
+    'high-contrast-light': highContrastLight,
+    midnight: midnightTheme,
+    terminal: terminalTheme,
+};

package/dist/grid/tree.d.ts

@@ -1,12 +1,24 @@
 import type { GridRow } from './column';
 import type { VisualRow } from './grouping';
-/** Resolve a row's children (undefined/empty = leaf). */
+/** Resolve a row's children (undefined/empty = leaf). Sync. */
 export type GetChildren = (row: GridRow) => GridRow[] | undefined;
+/** How the flattener reads a tree: which rows have children, which are expanded,
+    the children currently available (sync result or async cache), and which
+    expanded nodes are still loading. */
+export interface TreeAccess {
+    /** Children available now (sync result or loaded cache); undefined = not loaded. */
+    childrenOf: (row: GridRow) => readonly GridRow[] | undefined;
+    /** Cheap predicate: does this row have children? (Drives the expand chevron.) */
+    hasChildren: (row: GridRow) => boolean;
+    isExpanded: (row: GridRow) => boolean;
+    /** Whether an expanded row's children are still loading (async trees). */
+    isLoading?: (row: GridRow) => boolean;
+}
 /**
- * Flatten a tree of rows into the visible, depth-tagged data rows the grid
- * renders. Pre-order DFS: each node is emitted, then — if it has children and
- * `isExpanded` returns true — its children, one level deeper. Collapsed or leaf
- * nodes contribute only themselves. Pure: no row values are read, so a realtime
- * tick never rebuilds this list.
+ * Flatten a tree of rows into the visible, depth-tagged rows the grid renders.
+ * Pre-order DFS: each node is emitted, then — if it has children and is expanded
+ * — its loaded children one level deeper, or a single `treeloading` placeholder
+ * while they load. Pure: no row values are read, so a realtime tick never rebuilds
+ * this list.
  */
-export declare function buildTreeRows(roots: readonly GridRow[], getChildren: GetChildren, isExpanded: (row: GridRow) => boolean): VisualRow[];
+export declare function buildTreeRows(roots: readonly GridRow[], access: TreeAccess): VisualRow[];

package/dist/grid/tree.js

@@ -1,19 +1,24 @@
 /**
- * Flatten a tree of rows into the visible, depth-tagged data rows the grid
- * renders. Pre-order DFS: each node is emitted, then — if it has children and
- * `isExpanded` returns true — its children, one level deeper. Collapsed or leaf
- * nodes contribute only themselves. Pure: no row values are read, so a realtime
- * tick never rebuilds this list.
+ * Flatten a tree of rows into the visible, depth-tagged rows the grid renders.
+ * Pre-order DFS: each node is emitted, then — if it has children and is expanded
+ * — its loaded children one level deeper, or a single `treeloading` placeholder
+ * while they load. Pure: no row values are read, so a realtime tick never rebuilds
+ * this list.
  */
-export function buildTreeRows(roots, getChildren, isExpanded) {
+export function buildTreeRows(roots, access) {
+    const { childrenOf, hasChildren, isExpanded, isLoading } = access;
     const out = [];
     const walk = (nodes, depth) => {
         for (const row of nodes) {
-            const children = getChildren(row);
-            const hasChildren = !!children && children.length > 0;
-            out.push({ kind: 'data', row, depth, hasChildren });
-            if (hasChildren && isExpanded(row))
-                walk(children, depth + 1);
+            const has = hasChildren(row);
+            out.push({ kind: 'data', row, depth, hasChildren: has });
+            if (has && isExpanded(row)) {
+                const children = childrenOf(row);
+                if (children && children.length > 0)
+                    walk(children, depth + 1);
+                else if (isLoading?.(row))
+                    out.push({ kind: 'treeloading', depth: depth + 1 });
+            }
         }
     };
     walk(roots, 0);

package/dist/index.d.ts

@@ -1,20 +1,22 @@
 export { default as Grid } from './grid/Grid.svelte';
 export { default as Sparkline } from './sparkline/Sparkline.svelte';
-export type { ColumnDef, Align, GridRow, SortDir, SortState, CellEditEvent } from './grid/column';
+export type { LazyGroup } from './grid/grouping';
+export type { ColumnDef, Align, GridRow, SortDir, SortState, CellEditEvent, BadgeTone, DataBarConfig, IconRule, ColorScaleConfig, } from './grid/column';
 export type { AggKind, AggResult } from './grid/aggregate';
 export type { ColumnFilter, FilterKind, TextOp, NumberOp, DateOp } from './grid/filtering';
-export { fmtPrice, fmtPercent, fmtVolume, fmtDate } from './format/format';
+export { fmtPrice, fmtPercent, fmtVolume, fmtDate, fmtCurrency, relativeTime } from './format/format';
 export type { DateStyle } from './format/format';
 export { aggregate } from './grid/aggregate';
 export { heatColor } from './grid/heatmap';
 export { pivot } from './grid/pivot';
 export type { PivotConfig, PivotResult } from './grid/pivot';
-export { themeVars, darkTheme, lightTheme } from './grid/theme';
-export type { GridTheme } from './grid/theme';
+export { themeVars, darkTheme, lightTheme, highContrastDark, highContrastLight, midnightTheme, terminalTheme, themePresets, } from './grid/theme';
+export type { GridTheme, ThemePreset } from './grid/theme';
 export { drawCandles, setupHiDpiCanvas } from './sparkline/sparkline-render';
-export { toCSV, exportCSV } from './grid/export';
+export { toCSV, exportCSV, parseCSV, parseCSVMatrix, parseTSV, parseJSON, parseRows, rowsFromObjects, } from './grid/export';
 export { exportXLSX } from './grid/export-xlsx';
 export type { ExportOptions } from './grid/export';
+export { toHTMLTable, printTable, escapeHTML } from './grid/print';
 export { createArraySource } from './grid/source';
 export type { RowSource, RowRange, RowSourceParams, RowSourceResult, ArraySourceOptions, } from './grid/source';
 export type { Candle } from './types';

package/dist/index.js

@@ -8,17 +8,19 @@
 export { default as Grid } from './grid/Grid.svelte';
 export { default as Sparkline } from './sparkline/Sparkline.svelte';
 // Value formatters (handy when building custom cell content)
-export { fmtPrice, fmtPercent, fmtVolume, fmtDate } from './format/format';
+export { fmtPrice, fmtPercent, fmtVolume, fmtDate, fmtCurrency, relativeTime } from './format/format';
 // Standalone helpers
 export { aggregate } from './grid/aggregate';
 export { heatColor } from './grid/heatmap';
 export { pivot } from './grid/pivot';
 // Theming
-export { themeVars, darkTheme, lightTheme } from './grid/theme';
+export { themeVars, darkTheme, lightTheme, highContrastDark, highContrastLight, midnightTheme, terminalTheme, themePresets, } from './grid/theme';
 // Sparkline canvas primitives (draw candlesticks on your own canvas)
 export { drawCandles, setupHiDpiCanvas } from './sparkline/sparkline-render';
-// Export (CSV is dependency-free; XLSX dynamic-imports the optional `xlsx` peer)
-export { toCSV, exportCSV } from './grid/export';
+// Export + import (CSV is dependency-free; XLSX dynamic-imports the optional `xlsx` peer)
+export { toCSV, exportCSV, parseCSV, parseCSVMatrix, parseTSV, parseJSON, parseRows, rowsFromObjects, } from './grid/export';
 export { exportXLSX } from './grid/export-xlsx';
+// Printable / export HTML (renders ALL rows, unlike the virtualized grid)
+export { toHTMLTable, printTable, escapeHTML } from './grid/print';
 // Server-side / windowed data source
 export { createArraySource } from './grid/source';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bo-grid",
-  "version": "0.8.0",
+  "version": "0.25.0",
   "type": "module",
   "license": "MIT",
   "description": "Tiny, fast Svelte 5 data grid: canvas sparklines, batched realtime cell updates, and virtual scrolling. A free, fintech-focused alternative to heavyweight grids.",
@@ -33,6 +33,14 @@
       "svelte": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./charts": {
+      "types": "./dist/charts/index.d.ts",
+      "svelte": "./dist/charts/index.js",
+      "default": "./dist/charts/index.js"
+    },
+    "./element": {
+      "default": "./dist/bo-grid.element.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -53,12 +61,15 @@
     "demo:build": "vite build",
     "pages:build": "vite build --base=/bo-grid/ --outDir demo-dist",
     "preview": "vite preview",
-    "package": "svelte-package -i src/lib -o dist && node scripts/clean-dist.mjs",
+    "package": "svelte-package -i src/lib -o dist && node scripts/clean-dist.mjs && pnpm run build:wc",
+    "build:wc": "vite build --config vite.wc.config.ts",
     "prepublishOnly": "pnpm run package",
     "check": "svelte-check --tsconfig ./tsconfig.json",
     "size": "vite build && node scripts/size-check.mjs",
     "size:lib": "vite build --config vite.lib.config.ts && node scripts/size-lib.mjs",
     "smoke": "vite build --base=./ --outDir demo-dist && node scripts/smoke.mjs",
+    "smoke:wc": "node scripts/wc-smoke.mjs",
+    "check:examples": "node scripts/check-examples.mjs",
     "ssr": "node scripts/ssr.mjs",
     "bench": "node scripts/bench.mjs",
     "test": "vitest run",