@vuu-ui/vuu-table-extras 3.3.2 → 3.3.4

package/README.md

@@ -0,0 +1,32 @@
+# @vuu-ui/vuu-table-extras
+
+Extended components and utilities for Vuu tables, including CSV export, CSV upload and validation, column settings, column pickers, custom cell renderers, and table footer controls.
+
+---
+
+## Features
+
+### [CSV Export](./src/csv-export/README.md)
+Standalone utilities and a React hook for exporting table data and template schemas to CSV:
+- `exportToCsv(dataSource, options)`: Subscribes to a session table, collects rows in memory in index order, formats values, and triggers browser downloads.
+- `exportCsvTemplate(dataSource, options)`: Generates a header-only CSV template for import workflows.
+- `useCsvExport(dataSource)`: React hook with built-in `isExporting` state, error handling, and helper methods.
+
+### [CSV Upload](./src/csv-upload/README.md)
+Dialog and hook workflow for importing CSV data into Vuu tables via server-side session tables:
+- `CsvUpload`: Complete dialog component with file drag-and-drop, client-side validation, error summaries, and staging controls.
+- `useCsvUpload`: Headless hook managing file parsing, schema validation, session table staging, and RPC row batching.
+- `DataUploadPreview`: Inline editable table preview for inspecting and correcting invalid staged rows before commit.
+
+### Column Management
+- `ColumnMenu` & `useColumnActions`: Context menus for sorting, grouping, filtering, and column configuration.
+- `ColumnPicker` & `useTableColumnPicker`: Dialog and drawer controls for selecting and reordering visible columns.
+- `CalculatedColumnPanel`: UI panel for defining custom expression-based columns.
+
+### Cell Renderers & Formatters
+- Pre-built cell renderers including `BackgroundCell`, `DropdownCell`, `IconButtonCell`, and undo support.
+- Cell edit validators for ensuring valid data entry.
+
+### Table Footer & Status Controls
+- `TableFooter` & `TableFooterTray`: Status bar and pagination trays.
+- `DataSourceStats`: Live indicators for row count, connection state, freeze status, and filter metrics.

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.3.2",
+  "version": "3.3.4",
   "author": "heswell",
   "main": "./src/index.js",
   "license": "Apache-2.0",
@@ -11,19 +11,19 @@
     "lezer-generate:column": "lezer-generator --output ./src/column-expression-input/column-language-parser/generated/column-parser.js ./src/column-expression-input/column-language-parser/grammar/column.grammar"
   },
   "devDependencies": {
-    "@vuu-ui/vuu-filter-types": "3.3.2",
-    "@vuu-ui/vuu-protocol-types": "3.3.2"
+    "@vuu-ui/vuu-filter-types": "3.3.4",
+    "@vuu-ui/vuu-protocol-types": "3.3.4"
   },
   "dependencies": {
-    "@vuu-ui/vuu-codemirror": "3.3.2",
-    "@vuu-ui/vuu-data-editing": "3.3.2",
-    "@vuu-ui/vuu-data-react": "3.3.2",
-    "@vuu-ui/vuu-data-types": "3.3.2",
-    "@vuu-ui/vuu-table-types": "3.3.2",
-    "@vuu-ui/vuu-popups": "3.3.2",
-    "@vuu-ui/vuu-table": "3.3.2",
-    "@vuu-ui/vuu-utils": "3.3.2",
-    "@vuu-ui/vuu-ui-controls": "3.3.2",
+    "@vuu-ui/vuu-codemirror": "3.3.4",
+    "@vuu-ui/vuu-data-editing": "3.3.4",
+    "@vuu-ui/vuu-data-react": "3.3.4",
+    "@vuu-ui/vuu-data-types": "3.3.4",
+    "@vuu-ui/vuu-table-types": "3.3.4",
+    "@vuu-ui/vuu-popups": "3.3.4",
+    "@vuu-ui/vuu-table": "3.3.4",
+    "@vuu-ui/vuu-utils": "3.3.4",
+    "@vuu-ui/vuu-ui-controls": "3.3.4",
     "@lezer/lr": "1.4.2",
     "@salt-ds/core": "1.54.1",
     "@salt-ds/lab": "1.0.0-alpha.83",

package/src/csv-export/export-utils.js

@@ -6,9 +6,11 @@ const EXPORT_EXCLUDED_COLUMNS = new Set([
 ]);
 const MAX_EXPORT_ROWS = 10000;
 const CHUNK_SIZE = 1000;
+const DEFAULT_EXPORT_TIMEOUT = 30000;
+const DEFAULT_TEMPLATE_TIMEOUT = 10000;
 const csvCell = (value)=>{
     const s = null == value ? "" : String(value);
-    return s.includes(",") || s.includes('"') || s.includes("\n") ? `"${s.replace(/"/g, '""')}` : s;
+    return s.includes(",") || s.includes('"') || s.includes("\n") || s.includes("\r") ? `"${s.replace(/"/g, '""')}"` : s;
 };
 const triggerCsvDownload = (csv, filename)=>{
     const blob = new Blob([
@@ -26,13 +28,27 @@ const triggerCsvDownload = (csv, filename)=>{
     document.body.removeChild(a);
     setTimeout(()=>URL.revokeObjectURL(url), 10000);
 };
-const exportCsvTemplate = async (dataSource, filename = "template.csv", excludeColumns = [], columns, overrides)=>{
+const exportCsvTemplate = async (dataSource, options = {})=>{
+    const { filename = "template.csv", excludeColumns = [], columns, overrides, timeout = DEFAULT_TEMPLATE_TIMEOUT, onError, onSuccess } = options;
     const sessionOverrides = overrides ?? (columns ? {
         columns
     } : void 0);
-    if (!isSessionTable(dataSource.table) && dataSource.createSessionDataSource) try {
+    if (!isSessionTable(dataSource.table) && dataSource.createSessionDataSource && "initialising" !== dataSource.status && "unsubscribed" !== dataSource.status) try {
         const sessionDataSource = await dataSource.createSessionDataSource("Empty", "export", sessionOverrides);
-        if (sessionDataSource) return new Promise((resolve)=>{
+        if (sessionDataSource) return new Promise((resolve, reject)=>{
+            let timer;
+            const cleanup = ()=>{
+                if (timer) clearTimeout(timer);
+                sessionDataSource.unsubscribe();
+            };
+            if (timeout > 0) timer = setTimeout(()=>{
+                cleanup();
+                const err = new Error(`exportCsvTemplate: timed out after ${timeout}ms waiting for subscription`);
+                if (onError) {
+                    onError(err);
+                    resolve();
+                } else reject(err);
+            }, timeout);
             const excluded = new Set([
                 ...EXPORT_EXCLUDED_COLUMNS,
                 ...excludeColumns
@@ -46,7 +62,8 @@ const exportCsvTemplate = async (dataSource, filename = "template.csv", excludeC
                     const exportCols = subColumns.filter((name)=>!excluded.has(name));
                     const header = exportCols.map(csvCell).join(",");
                     triggerCsvDownload(`${header}\r\n`, filename);
-                    sessionDataSource.unsubscribe();
+                    cleanup();
+                    onSuccess?.();
                     resolve();
                 }
             });
@@ -62,26 +79,47 @@ const exportCsvTemplate = async (dataSource, filename = "template.csv", excludeC
             const unknown = targetColumns.filter((name)=>!schemaColumnNames.has(name));
             if (unknown.length > 0) console.warn(`[exportCsvTemplate] unknown column(s) in view tableSchema: ${unknown.join(", ")}`);
         }
-    } else if (!schema) throw Error("exportCsvTemplate: tableSchema not available on dataSource");
+    } else if (!schema) {
+        const error = new Error("exportCsvTemplate: tableSchema not available on dataSource");
+        if (onError) return void onError(error);
+        throw error;
+    }
     const excluded = new Set([
         ...EXPORT_EXCLUDED_COLUMNS,
         ...excludeColumns
     ]);
     const exportCols = targetColumns ? targetColumns.filter((name)=>!excluded.has(name)) : schema?.columns.filter((col)=>!excluded.has(col.name)).map((col)=>col.name) ?? [];
-    if (0 === exportCols.length) throw Error("exportCsvTemplate: no columns available for export");
+    if (0 === exportCols.length) {
+        const error = new Error("exportCsvTemplate: no columns available for export");
+        if (onError) return void onError(error);
+        throw error;
+    }
     const header = exportCols.map(csvCell).join(",");
     triggerCsvDownload(`${header}\r\n`, filename);
+    onSuccess?.();
 };
-const exportSessionTableToCsv = async (dataSource, filename = "export.csv", excludeColumns = [], onError, onSuccess, maxRows = MAX_EXPORT_ROWS, columnDescriptors, copyOption = "All", overrides)=>{
+const exportSessionTableToCsv = async (dataSource, options = {})=>{
+    const { filename = "export.csv", copyOption = "All", excludeColumns = [], maxRows = MAX_EXPORT_ROWS, columnDescriptors, overrides, timeout = DEFAULT_EXPORT_TIMEOUT, onError, onSuccess } = options;
+    const isRemote = !!dataSource.isRemote;
+    if (isRemote && !isSessionTable(dataSource.table) && ("initialising" === dataSource.status || "unsubscribed" === dataSource.status)) {
+        const error = new Error(`exportSessionTableToCsv: dataSource must be subscribed before exporting (current status: "${dataSource.status}")`);
+        if (onError) return void onError(error);
+        throw error;
+    }
     let sessionDataSource;
     if (!isSessionTable(dataSource.table) && dataSource.createSessionDataSource) try {
         sessionDataSource = await dataSource.createSessionDataSource(copyOption, "export", overrides);
     } catch (err) {
-        onError?.(err instanceof Error ? err : new Error(String(err)));
-        return;
+        const error = err instanceof Error ? err : new Error(String(err));
+        if (onError) return void onError(error);
+        throw error;
     }
     else sessionDataSource = dataSource;
-    if (!sessionDataSource) return void onError?.(new Error("exportSessionTableToCsv: unable to obtain sessionDataSource"));
+    if (!sessionDataSource) {
+        const error = new Error("exportSessionTableToCsv: unable to obtain sessionDataSource");
+        if (onError) return void onError(error);
+        throw error;
+    }
     const activeSessionDataSource = sessionDataSource;
     const excluded = new Set([
         ...EXPORT_EXCLUDED_COLUMNS,
@@ -91,20 +129,31 @@ const exportSessionTableToCsv = async (dataSource, filename = "export.csv", excl
     let colNameToRowIdx = {};
     let descriptorMap = {};
     let totalSize = 0;
-    const collectedRows = [];
-    return new Promise((resolve)=>{
+    let nextRequestedFrom = 0;
+    const collectedRows = new Map();
+    return new Promise((resolve, reject)=>{
+        let timer;
+        const cleanup = ()=>{
+            if (timer) clearTimeout(timer);
+            activeSessionDataSource.unsubscribe();
+        };
+        const fail = (err)=>{
+            cleanup();
+            if (onError) {
+                onError(err);
+                resolve();
+            } else reject(err);
+        };
+        if (timeout > 0) timer = setTimeout(()=>{
+            fail(new Error(`exportToCsv: export timed out after ${timeout}ms waiting for data`));
+        }, timeout);
         const handleMessage = (message)=>{
             if ("subscribed" === message.type) {
                 const { columns } = message;
                 if (columnDescriptors) {
                     const subscribedSet = new Set(columns);
                     const unknown = columnDescriptors.filter((d)=>!excluded.has(d.name) && !subscribedSet.has(d.name)).map((d)=>d.name);
-                    if (unknown.length > 0) {
-                        activeSessionDataSource.unsubscribe();
-                        onError?.(new Error(`exportToCsv: unknown column(s) in columnDescriptors: ${unknown.join(", ")}`));
-                        resolve();
-                        return;
-                    }
+                    if (unknown.length > 0) return void fail(new Error(`exportToCsv: unknown column(s) in columnDescriptors: ${unknown.join(", ")}`));
                     descriptorMap = Object.fromEntries(columnDescriptors.map((d)=>[
                             d.name,
                             d
@@ -119,37 +168,45 @@ const exportSessionTableToCsv = async (dataSource, filename = "export.csv", excl
                 if ("size-only" === message.mode) {
                     totalSize = message.size ?? 0;
                     if (0 === totalSize) {
-                        activeSessionDataSource.unsubscribe();
+                        cleanup();
+                        const header = exportCols.map((name)=>csvCell(descriptorMap[name]?.label ?? name)).join(",");
+                        triggerCsvDownload(`${header}\r\n`, filename);
                         onSuccess?.();
                         resolve();
                         return;
                     }
-                    if (totalSize > maxRows) {
-                        activeSessionDataSource.unsubscribe();
-                        onError?.(new Error(`exportToCsv: row count ${totalSize} exceeds the ${maxRows} row limit`));
-                        resolve();
-                        return;
+                    if (totalSize > maxRows) return void fail(new Error(`exportToCsv: row count ${totalSize} exceeds the ${maxRows} row limit`));
+                    nextRequestedFrom = Math.min(CHUNK_SIZE, totalSize);
+                    activeSessionDataSource.range = Range(0, nextRequestedFrom);
+                } else if (("batch" === message.mode || "update" === message.mode) && message.rows) {
+                    for (const row of message.rows){
+                        const rowIndex = row[metadataKeys.IDX];
+                        if ("number" == typeof rowIndex) collectedRows.set(rowIndex, row);
                     }
-                    activeSessionDataSource.range = Range(0, Math.min(CHUNK_SIZE, totalSize));
-                } else if ("batch" === message.mode && message.rows) {
-                    collectedRows.push(...message.rows);
                     if (void 0 !== message.size) totalSize = message.size;
-                    if (collectedRows.length >= totalSize) {
-                        activeSessionDataSource.unsubscribe();
+                    if (collectedRows.size >= totalSize) {
+                        cleanup();
                         const lines = [
                             exportCols.map((name)=>csvCell(descriptorMap[name]?.label ?? name)).join(",")
                         ];
-                        for (const row of collectedRows)lines.push(exportCols.map((c)=>{
-                            const raw = row[colNameToRowIdx[c]];
-                            const formatter = descriptorMap[c]?.exportFormatter;
-                            return csvCell(formatter ? formatter(raw) : raw);
-                        }).join(","));
+                        for(let i = 0; i < totalSize; i++){
+                            const row = collectedRows.get(i);
+                            if (row) lines.push(exportCols.map((c)=>{
+                                const raw = row[colNameToRowIdx[c]];
+                                const formatter = descriptorMap[c]?.exportFormatter;
+                                return csvCell(formatter ? formatter(raw) : raw);
+                            }).join(","));
+                        }
                         triggerCsvDownload(lines.join("\r\n"), filename);
                         onSuccess?.();
                         resolve();
-                    } else {
-                        const nextFrom = collectedRows.length;
-                        activeSessionDataSource.range = Range(nextFrom, Math.min(nextFrom + CHUNK_SIZE, totalSize));
+                    } else if (collectedRows.size >= nextRequestedFrom && nextRequestedFrom < totalSize) {
+                        const nextTo = Math.min(nextRequestedFrom + CHUNK_SIZE, totalSize);
+                        const requestedFrom = nextRequestedFrom;
+                        nextRequestedFrom = nextTo;
+                        setTimeout(()=>{
+                            activeSessionDataSource.range = Range(requestedFrom, nextTo);
+                        }, 0);
                     }
                 }
             }
@@ -160,5 +217,5 @@ const exportSessionTableToCsv = async (dataSource, filename = "export.csv", excl
         }, handleMessage);
     });
 };
-const exportToCsv = async (dataSource, copyOption = "All", filename = "export.csv", excludeColumns = [], onError, onSuccess, maxRows = MAX_EXPORT_ROWS, columnDescriptors, overrides)=>exportSessionTableToCsv(dataSource, filename, excludeColumns, onError, onSuccess, maxRows, columnDescriptors, copyOption, overrides);
+const exportToCsv = async (dataSource, options)=>exportSessionTableToCsv(dataSource, options);
 export { exportCsvTemplate, exportSessionTableToCsv, exportToCsv };

package/src/csv-export/index.js

@@ -1 +1,2 @@
 export { exportCsvTemplate, exportSessionTableToCsv, exportToCsv } from "./export-utils.js";
+export { useCsvExport } from "./useCsvExport.js";

package/src/csv-export/useCsvExport.js

@@ -0,0 +1,93 @@
+import { useCallback, useState } from "react";
+import { exportCsvTemplate, exportToCsv } from "./export-utils.js";
+function useCsvExport(propsOrDataSource) {
+    const [isExporting, setIsExporting] = useState(false);
+    const [error, setError] = useState(null);
+    const config = propsOrDataSource && "table" in propsOrDataSource ? {
+        dataSource: propsOrDataSource
+    } : propsOrDataSource ?? {};
+    const { dataSource: defaultDataSource, onError, onSuccess } = config;
+    const exportCsv = useCallback(async (options, overrideDataSource)=>{
+        const activeDataSource = overrideDataSource ?? defaultDataSource;
+        if (!activeDataSource) {
+            const err = new Error("useCsvExport: dataSource is required to export to CSV");
+            setError(err);
+            onError?.(err);
+            options?.onError?.(err);
+            throw err;
+        }
+        setIsExporting(true);
+        setError(null);
+        try {
+            await exportToCsv(activeDataSource, {
+                ...options,
+                onError: (err)=>{
+                    setError(err);
+                    onError?.(err);
+                    options?.onError?.(err);
+                },
+                onSuccess: ()=>{
+                    onSuccess?.();
+                    options?.onSuccess?.();
+                }
+            });
+        } catch (err) {
+            const catchedError = err instanceof Error ? err : new Error(String(err));
+            setError(catchedError);
+            onError?.(catchedError);
+            options?.onError?.(catchedError);
+            throw catchedError;
+        } finally{
+            setIsExporting(false);
+        }
+    }, [
+        defaultDataSource,
+        onError,
+        onSuccess
+    ]);
+    const exportTemplate = useCallback(async (options, overrideDataSource)=>{
+        const activeDataSource = overrideDataSource ?? defaultDataSource;
+        if (!activeDataSource) {
+            const err = new Error("useCsvExport: dataSource is required to export CSV template");
+            setError(err);
+            onError?.(err);
+            options?.onError?.(err);
+            throw err;
+        }
+        setIsExporting(true);
+        setError(null);
+        try {
+            await exportCsvTemplate(activeDataSource, {
+                ...options,
+                onError: (err)=>{
+                    setError(err);
+                    onError?.(err);
+                    options?.onError?.(err);
+                },
+                onSuccess: ()=>{
+                    onSuccess?.();
+                    options?.onSuccess?.();
+                }
+            });
+        } catch (err) {
+            const catchedError = err instanceof Error ? err : new Error(String(err));
+            setError(catchedError);
+            onError?.(catchedError);
+            options?.onError?.(catchedError);
+            throw catchedError;
+        } finally{
+            setIsExporting(false);
+        }
+    }, [
+        defaultDataSource,
+        onError,
+        onSuccess
+    ]);
+    return {
+        isExporting,
+        error,
+        exportCsv,
+        exportTemplate
+    };
+}
+export { useCsvExport };

package/src/csv-upload/parse/csv-schema-validation.js

@@ -1,6 +1,9 @@
 import { getTypedValue } from "@vuu-ui/vuu-utils";
 import { CsvValidationErrorEnum, addCsvFileError, addCsvRowError, createCsvErrorState } from "./csv-errors.js";
 import { CSV_FIRST_DATA_ROW_NUMBER, MAX_ROWS_IN_CSV } from "./csv-constants.js";
+const INTERNAL_KEY_COLUMNS = new Set([
+    "vuuRowNum"
+]);
 const validateCsvAgainstSchema = (parsed, tableSchema, options)=>{
     const schemaColumns = new Map(tableSchema.columns.map((col)=>[
             col.name,
@@ -8,7 +11,7 @@ const validateCsvAgainstSchema = (parsed, tableSchema, options)=>{
         ]));
     const maxRows = options?.maxRows ?? MAX_ROWS_IN_CSV;
     const errorState = createCsvErrorState();
-    if (!parsed.header.includes(tableSchema.key)) addCsvFileError(errorState, tableSchema.key, CsvValidationErrorEnum.MISSING_KEY_COLUMN, `CSV must include key column '${tableSchema.key}'.`);
+    if (tableSchema.key && !INTERNAL_KEY_COLUMNS.has(tableSchema.key) && !parsed.header.includes(tableSchema.key)) addCsvFileError(errorState, tableSchema.key, CsvValidationErrorEnum.MISSING_KEY_COLUMN, `CSV must include key column '${tableSchema.key}'.`);
     parsed.header.forEach((column)=>{
         if (!schemaColumns.has(column)) addCsvFileError(errorState, column, CsvValidationErrorEnum.UNKNOWN_COLUMN, `Column ${column} is not present in table schema.`, column);
     });

package/src/csv-upload/useCsvUpload.js

@@ -189,6 +189,15 @@ const useCsvUpload = ({ dataSource, importMode = "direct", importSchema, importT
         onError?.(void 0);
         await closePendingEditSession(false);
         if (operationId !== operationIdRef.current) return;
+        if (!isSessionTable(dataSource.table) && ("initialising" === dataSource.status || "unsubscribed" === dataSource.status)) {
+            const errorMessage = `CsvUpload requires dataSource to be subscribed before uploading (current status: "${dataSource.status}").`;
+            onError?.({
+                errors: {
+                    validationError: createUploadError("validation", errorMessage)
+                }
+            });
+            return;
+        }
         if (void 0 === schema) throw Error("Table schema is not yet available.");
         if (void 0 === table) throw Error("CsvUpload requires dataSource.table to be defined.");
         const fileContents = await file.text();
@@ -244,6 +253,8 @@ const useCsvUpload = ({ dataSource, importMode = "direct", importSchema, importT
         parseOptions,
         beginEditSession,
         closePendingEditSession,
+        dataSource.status,
+        dataSource.table,
         table,
         endEditSessionAndNotify,
         schema

package/src/inline-add-row/useInlineAddRow.js

@@ -52,7 +52,7 @@ const useInlineAddRow = ({ columns })=>{
         cell?.querySelector("input, button, [tabindex]")?.focus();
     }, []);
     useEffect(()=>{
-        editSession.configureNewRow(visibleInsertColumns.map(({ name })=>name));
+        editSession.configureNewRow(visibleInsertColumns.map(({ name })=>name), visibleInsertColumns.filter((column)=>false !== column.required).map(({ name })=>name));
     }, [
         editSession,
         visibleInsertColumns

package/types/csv-export/export-utils.d.ts

@@ -5,16 +5,38 @@ export type ExportColumnDescriptor<TName extends string = string> = {
     label?: string;
     exportFormatter?: (value: unknown) => string;
 };
+export interface ExportToCsvOptions<TName extends string = string> {
+    filename?: string;
+    copyOption?: CopyOption;
+    excludeColumns?: string[];
+    maxRows?: number;
+    columnDescriptors?: ExportColumnDescriptor<TName>[];
+    overrides?: SessionDataSourceOverrides;
+    /** Timeout in milliseconds before the export times out. Default: 30_000ms (0 to disable). */
+    timeout?: number;
+    onError?: (error: Error) => void;
+    onSuccess?: () => void;
+}
+export interface ExportCsvTemplateOptions {
+    filename?: string;
+    excludeColumns?: string[];
+    columns?: string[];
+    overrides?: SessionDataSourceOverrides;
+    /** Timeout in milliseconds before template generation times out. Default: 10_000ms (0 to disable). */
+    timeout?: number;
+    onError?: (error: Error) => void;
+    onSuccess?: () => void;
+}
 /** Downloads a single-row CSV containing only the column headers, for use as an import template. */
-export declare const exportCsvTemplate: (dataSource: DataSource, filename?: string, excludeColumns?: string[], columns?: string[], overrides?: SessionDataSourceOverrides) => Promise<void>;
+export declare const exportCsvTemplate: (dataSource: DataSource, options?: ExportCsvTemplateOptions) => Promise<void>;
 /**
- * Subscribes to `dataSource` (creating an export session data source if a view data source is passed)
- * with a full-range request to drain all rows, serialises them to CSV (excluding internal session columns),
+ * Subscribes to `dataSource` (creating an export session data source if a view data source is passed),
+ * collects all rows in memory in index order, serialises them to CSV (excluding internal session columns),
  * then triggers a browser download. The session data source is unsubscribed automatically once the download
  * is initiated.
  */
-export declare const exportSessionTableToCsv: <TName extends string = string>(dataSource: DataSource, filename?: string, excludeColumns?: string[], onError?: (error: Error) => void, onSuccess?: () => void, maxRows?: number, columnDescriptors?: ExportColumnDescriptor<TName>[], copyOption?: CopyOption, overrides?: SessionDataSourceOverrides) => Promise<void>;
+export declare const exportSessionTableToCsv: <TName extends string = string>(dataSource: DataSource, options?: ExportToCsvOptions<TName>) => Promise<void>;
 /**
- * Creates an export session table from `dataSource` then streams all rows to a CSV download.
+ * Creates an export session table from `dataSource`, collects all rows in memory, then triggers a CSV download.
  */
-export declare const exportToCsv: <TName extends string = string>(dataSource: DataSource, copyOption?: CopyOption, filename?: string, excludeColumns?: string[], onError?: (error: Error) => void, onSuccess?: () => void, maxRows?: number, columnDescriptors?: ExportColumnDescriptor<TName>[], overrides?: SessionDataSourceOverrides) => Promise<void>;
+export declare const exportToCsv: <TName extends string = string>(dataSource: DataSource, options?: ExportToCsvOptions<TName>) => Promise<void>;

package/types/csv-export/index.d.ts

@@ -1 +1,2 @@
-export { exportCsvTemplate, exportSessionTableToCsv, exportToCsv, type ExportColumnDescriptor, } from "./export-utils";
+export { exportCsvTemplate, exportSessionTableToCsv, exportToCsv, type ExportColumnDescriptor, type ExportCsvTemplateOptions, type ExportToCsvOptions, } from "./export-utils";
+export { useCsvExport, type UseCsvExportProps, type UseCsvExportResult, } from "./useCsvExport";

package/types/csv-export/useCsvExport.d.ts

@@ -0,0 +1,14 @@
+import type { DataSource } from "@vuu-ui/vuu-data-types";
+import { type ExportCsvTemplateOptions, type ExportToCsvOptions } from "./export-utils";
+export interface UseCsvExportProps {
+    dataSource?: DataSource;
+    onError?: (error: Error) => void;
+    onSuccess?: () => void;
+}
+export interface UseCsvExportResult {
+    isExporting: boolean;
+    error: Error | null;
+    exportCsv: <TName extends string = string>(options?: ExportToCsvOptions<TName>, overrideDataSource?: DataSource) => Promise<void>;
+    exportTemplate: (options?: ExportCsvTemplateOptions, overrideDataSource?: DataSource) => Promise<void>;
+}
+export declare function useCsvExport(propsOrDataSource?: DataSource | UseCsvExportProps): UseCsvExportResult;

package/types/inline-add-row/useInlineAddRow.d.ts

@@ -52,6 +52,7 @@ export declare const useInlineAddRow: ({ columns }: UseInlineAddRowProps) => {
         status?: import("@salt-ds/core").ValidationStatus;
         editableBulk?: import("@vuu-ui/vuu-data-types").BulkEdit;
         name: string;
+        required?: boolean;
         serverDataType?: import("@vuu-ui/vuu-protocol-types").VuuColumnDataType;
         type?: import("@vuu-ui/vuu-data-types").DataValueType;
     }[];