@vuu-ui/vuu-table-extras 3.5.3 → 3.5.4

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.5.3",
+  "version": "3.5.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.5.3",
-    "@vuu-ui/vuu-protocol-types": "3.5.3"
+    "@vuu-ui/vuu-filter-types": "3.5.4",
+    "@vuu-ui/vuu-protocol-types": "3.5.4"
   },
   "dependencies": {
-    "@vuu-ui/vuu-codemirror": "3.5.3",
-    "@vuu-ui/vuu-data-editing": "3.5.3",
-    "@vuu-ui/vuu-data-react": "3.5.3",
-    "@vuu-ui/vuu-data-types": "3.5.3",
-    "@vuu-ui/vuu-table-types": "3.5.3",
-    "@vuu-ui/vuu-popups": "3.5.3",
-    "@vuu-ui/vuu-table": "3.5.3",
-    "@vuu-ui/vuu-utils": "3.5.3",
-    "@vuu-ui/vuu-ui-controls": "3.5.3",
+    "@vuu-ui/vuu-codemirror": "3.5.4",
+    "@vuu-ui/vuu-data-editing": "3.5.4",
+    "@vuu-ui/vuu-data-react": "3.5.4",
+    "@vuu-ui/vuu-data-types": "3.5.4",
+    "@vuu-ui/vuu-table-types": "3.5.4",
+    "@vuu-ui/vuu-popups": "3.5.4",
+    "@vuu-ui/vuu-table": "3.5.4",
+    "@vuu-ui/vuu-utils": "3.5.4",
+    "@vuu-ui/vuu-ui-controls": "3.5.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

@@ -51,8 +51,9 @@ const isExportableColumn = (descriptor)=>{
 const exportCsvTemplate = async (dataSource, options = {})=>{
     const { filename = "template.csv", excludeColumns = [], columns, overrides, timeout = DEFAULT_TEMPLATE_TIMEOUT, onError, onSuccess } = options;
     const targetColumnNames = columns ? columns.filter((col)=>"string" == typeof col ? true : isExportableColumn(col) && "client" !== col.source).map((col)=>"string" == typeof col ? col : col.name) : void 0;
-    const sessionOverrides = overrides ?? (targetColumnNames ? {
-        columns: targetColumnNames
+    const targetColumns = targetColumnNames ?? overrides?.columns;
+    const sessionOverrides = overrides ?? (targetColumns ? {
+        columns: targetColumns
     } : void 0);
     if (!isSessionTable(dataSource.table) && dataSource.createSessionDataSource && "initialising" !== dataSource.status && "unsubscribed" !== dataSource.status) try {
         const sessionDataSource = await dataSource.createSessionDataSource("Empty", "export", sessionOverrides);
@@ -80,7 +81,16 @@ const exportCsvTemplate = async (dataSource, options = {})=>{
             }, (message)=>{
                 if ("subscribed" === message.type) {
                     const { columns: subColumns } = message;
-                    const exportCols = subColumns.filter((name)=>!excluded.has(name));
+                    const exportCols = targetColumns ? targetColumns.filter((name)=>!excluded.has(name)) : subColumns.filter((name)=>!excluded.has(name));
+                    if (0 === exportCols.length) {
+                        cleanup();
+                        const error = new Error("exportCsvTemplate: no columns available for export");
+                        if (onError) {
+                            onError(error);
+                            resolve();
+                        } else reject(error);
+                        return;
+                    }
                     const header = exportCols.map(csvCell).join(",");
                     triggerCsvDownload(`${header}\r\n`, filename);
                     cleanup();
@@ -93,7 +103,6 @@ const exportCsvTemplate = async (dataSource, options = {})=>{
         console.warn("[exportCsvTemplate] createSessionDataSource failed, falling back to tableSchema", error);
     }
     const schema = dataSource.tableSchema;
-    const targetColumns = targetColumnNames ?? overrides?.columns;
     if (void 0 !== targetColumns) {
         if (schema) {
             const schemaColumnNames = new Set(schema.columns.map((col)=>col.name));

package/src/csv-upload/parse/csv-upload-utils.js

@@ -1,4 +1,4 @@
-import { isRpcError } from "@vuu-ui/vuu-utils";
+import { isRpcError, metadataKeys } from "@vuu-ui/vuu-utils";
 import { CSV_FIRST_DATA_ROW_NUMBER } from "./csv-constants.js";
 const isRecord = (value)=>"object" == typeof value && null !== value;
 const toErrorMessage = (error)=>error instanceof Error ? error.message : String(error);
@@ -56,4 +56,46 @@ const executeBatchRpcCalls = async (items, executor, errorFormatter)=>{
         results
     };
 };
-export { buildRowErrorMessage, createUploadError, executeBatchRpcCalls, hasFileParseErrors, isCsvParseError, mergeValidationWithParseErrors, normalizeTableData, toErrorMessage, toValidationErrorsFromParseRowErrors };
+const getInlineRowErrorMessage = (result)=>{
+    if (isRecord(result) && "data" in result && isRecord(result.data)) {
+        const data = result.data;
+        const msg = data.vuuMsg ?? data.msg;
+        if ("string" == typeof msg && "" !== msg.trim()) return msg;
+    }
+};
+const getRowVuuMsgError = (row, vuuMsgDataIndex, vuuRowNumDataIndex)=>{
+    if (-1 === vuuMsgDataIndex) return;
+    const msg = Array.isArray(row) ? row[vuuMsgDataIndex] : row?.vuuMsg;
+    if ("string" == typeof msg && "" !== msg.trim()) {
+        const rowNum = -1 !== vuuRowNumDataIndex && void 0 !== row[vuuRowNumDataIndex] ? row[vuuRowNumDataIndex] : Number(row[metadataKeys.IDX]) + CSV_FIRST_DATA_ROW_NUMBER;
+        return `Row ${rowNum}: ${msg}`;
+    }
+};
+const waitForSessionErrors = (isRemote, sessionErrors, receivedRowKeys, expectedRowCount, listeners, timeoutMs = 500)=>{
+    if (sessionErrors.size > 0 || !isRemote) return Promise.resolve([
+        ...sessionErrors.values()
+    ]);
+    return new Promise((resolve)=>{
+        let timeoutId;
+        const onUpdate = ()=>{
+            if (sessionErrors.size > 0 || receivedRowKeys.size >= expectedRowCount) {
+                cleanup();
+                resolve([
+                    ...sessionErrors.values()
+                ]);
+            }
+        };
+        const cleanup = ()=>{
+            clearTimeout(timeoutId);
+            listeners.delete(onUpdate);
+        };
+        listeners.add(onUpdate);
+        timeoutId = setTimeout(()=>{
+            cleanup();
+            resolve([
+                ...sessionErrors.values()
+            ]);
+        }, timeoutMs);
+    });
+};
+export { buildRowErrorMessage, createUploadError, executeBatchRpcCalls, getInlineRowErrorMessage, getRowVuuMsgError, hasFileParseErrors, isCsvParseError, mergeValidationWithParseErrors, normalizeTableData, toErrorMessage, toValidationErrorsFromParseRowErrors, waitForSessionErrors };

package/src/csv-upload/session/index.js

@@ -0,0 +1,2 @@
+export * from "./useImportSchema.js";
+export * from "./useImportSession.js";

package/src/csv-upload/session/useImportSchema.js

@@ -0,0 +1,44 @@
+import { useData } from "@vuu-ui/vuu-utils";
+import { useEffect, useMemo, useState } from "react";
+const useImportSchema = ({ dataSource, importSchema, importTable })=>{
+    const { getServerAPI } = useData();
+    const [fetchedImportSchema, setFetchedImportSchema] = useState();
+    useEffect(()=>{
+        if (importSchema || void 0 === importTable) return void setFetchedImportSchema(void 0);
+        let cancelled = false;
+        (async ()=>{
+            try {
+                const server = await getServerAPI();
+                const tableSchema = await server.getTableSchema(importTable);
+                if (!cancelled) setFetchedImportSchema(tableSchema);
+            } catch (error) {
+                console.error("[useImportSchema] failed to fetch import table schema", error);
+            }
+        })();
+        return ()=>{
+            cancelled = true;
+        };
+    }, [
+        getServerAPI,
+        importSchema,
+        importTable
+    ]);
+    const resolvedImportSchema = importSchema ?? fetchedImportSchema;
+    const sessionOverrides = useMemo(()=>{
+        const columns = resolvedImportSchema?.columns.map(({ name })=>name);
+        return columns || importTable ? {
+            columns,
+            table: importTable
+        } : void 0;
+    }, [
+        resolvedImportSchema,
+        importTable
+    ]);
+    const schema = importTable ? resolvedImportSchema : resolvedImportSchema ?? dataSource.tableSchema;
+    return {
+        resolvedImportSchema,
+        schema,
+        sessionOverrides
+    };
+};
+export { useImportSchema };

package/src/csv-upload/session/useImportSession.js

@@ -0,0 +1,201 @@
+import { EditSession } from "@vuu-ui/vuu-data-editing";
+import { Range, buildColumnMap, isRpcError, isSessionTable, metadataKeys } from "@vuu-ui/vuu-utils";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { buildRowErrorMessage, getInlineRowErrorMessage, getRowVuuMsgError, toErrorMessage, waitForSessionErrors } from "../parse/csv-upload-utils.js";
+import { CSV_FIRST_DATA_ROW_NUMBER } from "../parse/csv-constants.js";
+const useImportSession = ({ dataSource, sessionOverrides, rowDefaults, processingPromiseRef, onImportSessionEnded })=>{
+    const sessionErrorsRef = useRef(new Map());
+    const receivedRowKeysRef = useRef(new Set());
+    const sessionRowUpdateListenersRef = useRef(new Set());
+    const importDataSource = useMemo(()=>({
+            tableSchema: dataSource.tableSchema,
+            createSessionDataSource: async (copyOption, sessionType)=>{
+                if (!dataSource.createSessionDataSource) throw Error("[useCsvUpload] dataSource does not support createSessionDataSource");
+                const sessionDs = await dataSource.createSessionDataSource(copyOption, sessionType, sessionOverrides);
+                if (!sessionDs) throw Error("[useCsvUpload] Failed to create session datasource");
+                if (!sessionDs.columns.includes("vuuMsg")) sessionDs.columns = sessionDs.columns.concat("vuuMsg");
+                const columnMap = buildColumnMap(sessionDs.columns);
+                const vuuMsgDataIndex = columnMap.vuuMsg ?? -1;
+                const vuuRowNumDataIndex = columnMap.vuuRowNum ?? -1;
+                const handleSessionMessage = (message)=>{
+                    if ("viewport-update" === message.type && message.rows) {
+                        for (const row of message.rows){
+                            const rowKey = row[metadataKeys.KEY] ?? row[metadataKeys.IDX];
+                            receivedRowKeysRef.current.add(rowKey);
+                            const error = getRowVuuMsgError(row, vuuMsgDataIndex, vuuRowNumDataIndex);
+                            if (error) sessionErrorsRef.current.set(rowKey, error);
+                        }
+                        for (const listener of sessionRowUpdateListenersRef.current)listener();
+                    } else if ("viewport-clear" === message.type) {
+                        sessionErrorsRef.current.clear();
+                        receivedRowKeysRef.current.clear();
+                    }
+                };
+                if (sessionDs.isRemote) return new Promise((resolve, reject)=>{
+                    const handleSubscribed = ()=>{
+                        sessionDs.removeListener("subscribed", handleSubscribed);
+                        resolve(sessionDs);
+                    };
+                    sessionDs.on("subscribed", handleSubscribed);
+                    try {
+                        sessionDs.subscribe({
+                            range: Range(0, 0)
+                        }, handleSessionMessage);
+                    } catch (err) {
+                        sessionDs.removeListener("subscribed", handleSubscribed);
+                        reject(err);
+                    }
+                });
+                if ("function" == typeof sessionDs.subscribe && "initialising" === sessionDs.status) try {
+                    sessionDs.subscribe({
+                        range: Range(0, 0)
+                    }, handleSessionMessage);
+                } catch  {}
+                return sessionDs;
+            }
+        }), [
+        dataSource,
+        sessionOverrides
+    ]);
+    const editSession = useMemo(()=>new EditSession({
+            dataSource: importDataSource,
+            editSessionApi: "createSessionDataSource",
+            rowDefaults
+        }), [
+        importDataSource,
+        rowDefaults
+    ]);
+    const ownsEditSessionRef = useRef(true);
+    const sessionDataSourceRef = useRef(void 0);
+    const [sessionTable, setSessionTable] = useState();
+    useEffect(()=>()=>{
+            const processingPromise = processingPromiseRef?.current;
+            (async ()=>{
+                try {
+                    await processingPromise;
+                } finally{
+                    if (ownsEditSessionRef.current) try {
+                        const sessionDs = sessionDataSourceRef.current ?? editSession.sessionDataSource;
+                        if (sessionDs?.status !== "unsubscribed") await editSession.end(false);
+                    } catch (error) {
+                        console.error("[useCsvUpload] failed to discard edit session during cleanup", error);
+                    }
+                }
+            })();
+        }, [
+        editSession,
+        processingPromiseRef
+    ]);
+    const setActiveSessionDataSource = useCallback((sessionDataSource)=>{
+        sessionDataSourceRef.current = sessionDataSource;
+        const table = sessionDataSource?.table;
+        setSessionTable(table && isSessionTable(table) ? table : void 0);
+    }, []);
+    const endEditSessionAndNotify = useCallback(async (save, reason)=>{
+        ownsEditSessionRef.current = false;
+        const sessionDataSource = sessionDataSourceRef.current;
+        if (!sessionDataSource) throw Error("CsvUpload has no active edit session.");
+        if (!sessionDataSource.endEditSession) throw Error("CsvUpload requires the session datasource to support endEditSession.");
+        const currentSessionTable = sessionDataSource.table;
+        try {
+            await editSession.end(save);
+        } finally{
+            if ("unsubscribed" !== sessionDataSource.status && "function" == typeof sessionDataSource.unsubscribe) sessionDataSource.unsubscribe();
+            setActiveSessionDataSource(void 0);
+        }
+        onImportSessionEnded?.({
+            reason,
+            sessionTable: currentSessionTable && isSessionTable(currentSessionTable) ? currentSessionTable : void 0
+        });
+    }, [
+        editSession,
+        onImportSessionEnded,
+        setActiveSessionDataSource
+    ]);
+    const beginEditSession = useCallback(async ()=>{
+        sessionErrorsRef.current.clear();
+        receivedRowKeysRef.current.clear();
+        ownsEditSessionRef.current = true;
+        const sessionDataSource = await editSession.begin("Empty", "import");
+        const sessionVuuTable = sessionDataSource?.table;
+        if (void 0 === sessionDataSource || void 0 === sessionVuuTable || !isSessionTable(sessionVuuTable)) throw Error("CsvUpload createSessionDataSource returned no session datasource.");
+        setActiveSessionDataSource(sessionDataSource);
+        return sessionDataSource;
+    }, [
+        editSession,
+        setActiveSessionDataSource
+    ]);
+    const closePendingEditSession = useCallback(async (save)=>{
+        if (void 0 === sessionDataSourceRef.current) return;
+        await endEditSessionAndNotify(save, save ? "saved" : "discarded");
+    }, [
+        endEditSessionAndNotify
+    ]);
+    const releaseEditSessionOwnership = useCallback(()=>{
+        ownsEditSessionRef.current = false;
+    }, []);
+    const addAllRows = useCallback(async (mergedValidation, isCancelled)=>{
+        const vuuMsgByRow = new Map();
+        for (const { rowNum, column, message } of mergedValidation.errors){
+            if (rowNum < CSV_FIRST_DATA_ROW_NUMBER) continue;
+            const existing = vuuMsgByRow.get(rowNum);
+            const columnError = `${column}: ${message}`;
+            vuuMsgByRow.set(rowNum, existing ? `${existing}; ${columnError}` : columnError);
+        }
+        const parsedRowCount = mergedValidation.rows.length;
+        const unparsedErrorRows = [
+            ...vuuMsgByRow.keys()
+        ].filter((rowNum)=>rowNum - CSV_FIRST_DATA_ROW_NUMBER >= parsedRowCount).map((rowNum)=>({
+                rowNum,
+                rowData: {},
+                vuuMsg: vuuMsgByRow.get(rowNum) ?? ""
+            }));
+        const allRows = [
+            ...mergedValidation.rows.map((rowData, idx)=>({
+                    rowNum: idx + CSV_FIRST_DATA_ROW_NUMBER,
+                    rowData: rowData ?? {},
+                    vuuMsg: vuuMsgByRow.get(idx + CSV_FIRST_DATA_ROW_NUMBER) ?? ""
+                })),
+            ...unparsedErrorRows
+        ];
+        const rpcErrors = [];
+        for (const { rowNum, rowData, vuuMsg } of allRows){
+            if (isCancelled()) return false;
+            try {
+                const payload = vuuMsg ? {
+                    vuuRowNum: rowNum,
+                    vuuMsg
+                } : {
+                    ...rowData,
+                    vuuRowNum: rowNum,
+                    vuuMsg
+                };
+                const result = await editSession.addRow(payload);
+                if (isRpcError(result)) throw Error(result.errorMessage);
+                if ("string" == typeof result) throw Error(result);
+                const inlineMsg = getInlineRowErrorMessage(result);
+                if (inlineMsg) rpcErrors.push(`${0 === rowNum ? "Header" : `Row ${rowNum}`}: ${inlineMsg}`);
+            } catch (error) {
+                rpcErrors.push(`${0 === rowNum ? "Header" : `Row ${rowNum}`}: ${toErrorMessage(error)}`);
+            }
+        }
+        if (rpcErrors.length > 0) throw Error(buildRowErrorMessage("Import failed", rpcErrors));
+        return allRows.length;
+    }, [
+        editSession
+    ]);
+    const checkSessionTableErrors = useCallback(async (sessionDs, expectedRowCount)=>waitForSessionErrors(sessionDs.isRemote ?? false, sessionErrorsRef.current, receivedRowKeysRef.current, expectedRowCount, sessionRowUpdateListenersRef.current), []);
+    return {
+        addAllRows,
+        beginEditSession,
+        checkSessionTableErrors,
+        closePendingEditSession,
+        editSession,
+        endEditSessionAndNotify,
+        releaseEditSessionOwnership,
+        sessionDataSourceRef,
+        sessionTable,
+        setActiveSessionDataSource
+    };
+};
+export { useImportSession };

package/src/csv-upload/useCsvUpload.js

@@ -1,203 +1,36 @@
-import { EditSession } from "@vuu-ui/vuu-data-editing";
-import { Range, isRpcError, isSessionTable, useData } from "@vuu-ui/vuu-utils";
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Range, isSessionTable } from "@vuu-ui/vuu-utils";
+import { useCallback, useMemo, useRef, useState } from "react";
 import { parseCsv } from "./parse/csv-parse.js";
 import { validateCsvAgainstSchema } from "./parse/csv-schema-validation.js";
 import { buildRowErrorMessage, createUploadError, hasFileParseErrors, isCsvParseError, mergeValidationWithParseErrors, toErrorMessage } from "./parse/csv-upload-utils.js";
-import { CSV_FIRST_DATA_ROW_NUMBER } from "./parse/csv-constants.js";
+import { useImportSchema } from "./session/useImportSchema.js";
+import { useImportSession } from "./session/useImportSession.js";
 const useCsvUpload = ({ dataSource, importMode = "direct", importSchema, importTable, onImportSessionEnded, onImportSessionReady, onError, onImported, onPreview, onProcessingStarted, maxRows, parseOptions, rowDefaults, validators })=>{
-    const { getServerAPI } = useData();
     const [validation, setValidation] = useState();
-    const [sessionTable, setSessionTable] = useState();
     const [isProcessingFile, setIsProcessingFile] = useState(false);
     const [isImporting, setIsImporting] = useState(false);
-    const [fetchedImportSchema, setFetchedImportSchema] = useState();
     const [error, setError] = useState();
+    const operationIdRef = useRef(0);
+    const processingPromiseRef = useRef(void 0);
     const handleError = useCallback((errResult)=>{
         setError(errResult);
         onError?.(errResult);
     }, [
         onError
     ]);
-    useEffect(()=>{
-        if (importSchema || void 0 === importTable) return void setFetchedImportSchema(void 0);
-        let cancelled = false;
-        (async ()=>{
-            try {
-                const server = await getServerAPI();
-                const tableSchema = await server.getTableSchema(importTable);
-                if (!cancelled) setFetchedImportSchema(tableSchema);
-            } catch (error) {
-                console.error("[useCsvUpload] failed to fetch import table schema", error);
-            }
-        })();
-        return ()=>{
-            cancelled = true;
-        };
-    }, [
-        getServerAPI,
+    const { schema, sessionOverrides } = useImportSchema({
+        dataSource,
         importSchema,
         importTable
-    ]);
-    const resolvedImportSchema = importSchema ?? fetchedImportSchema;
-    const sessionOverrides = useMemo(()=>{
-        const columns = resolvedImportSchema?.columns.map(({ name })=>name);
-        return columns || importTable ? {
-            columns,
-            table: importTable
-        } : void 0;
-    }, [
-        resolvedImportSchema,
-        importTable
-    ]);
-    const importDataSource = useMemo(()=>({
-            tableSchema: dataSource.tableSchema,
-            createSessionDataSource: async (copyOption, sessionType)=>{
-                if (!dataSource.createSessionDataSource) throw Error("[useCsvUpload] dataSource does not support createSessionDataSource");
-                const sessionDs = await dataSource.createSessionDataSource(copyOption, sessionType, sessionOverrides);
-                if (!sessionDs) throw Error("[useCsvUpload] Failed to create session datasource");
-                if (!sessionDs.columns.includes("vuuMsg")) sessionDs.columns = sessionDs.columns.concat("vuuMsg");
-                if (sessionDs.isRemote) return new Promise((resolve, reject)=>{
-                    const handleSubscribed = ()=>{
-                        sessionDs.removeListener("subscribed", handleSubscribed);
-                        resolve(sessionDs);
-                    };
-                    sessionDs.on("subscribed", handleSubscribed);
-                    try {
-                        sessionDs.subscribe({
-                            range: Range(0, 0)
-                        }, ()=>{});
-                    } catch (err) {
-                        sessionDs.removeListener("subscribed", handleSubscribed);
-                        reject(err);
-                    }
-                });
-                return sessionDs;
-            }
-        }), [
+    });
+    const { addAllRows, beginEditSession, checkSessionTableErrors, closePendingEditSession, editSession, endEditSessionAndNotify, releaseEditSessionOwnership, sessionDataSourceRef, sessionTable, setActiveSessionDataSource } = useImportSession({
         dataSource,
-        sessionOverrides
-    ]);
-    const editSession = useMemo(()=>new EditSession({
-            dataSource: importDataSource,
-            editSessionApi: "createSessionDataSource",
-            rowDefaults
-        }), [
-        importDataSource,
-        rowDefaults
-    ]);
-    const ownsEditSessionRef = useRef(true);
-    const operationIdRef = useRef(0);
-    const processingPromiseRef = useRef(void 0);
-    const sessionDataSourceRef = useRef(void 0);
-    useEffect(()=>()=>{
-            operationIdRef.current++;
-            const processingPromise = processingPromiseRef.current;
-            (async ()=>{
-                try {
-                    await processingPromise;
-                } finally{
-                    if (ownsEditSessionRef.current) try {
-                        await editSession.end(false);
-                    } catch (error) {
-                        console.error("[useCsvUpload] failed to discard edit session during cleanup", error);
-                    }
-                }
-            })();
-        }, [
-        editSession
-    ]);
-    const setActiveSessionDataSource = useCallback((sessionDataSource)=>{
-        sessionDataSourceRef.current = sessionDataSource;
-        const table = sessionDataSource?.table;
-        setSessionTable(table && isSessionTable(table) ? table : void 0);
-    }, []);
-    const endEditSessionAndNotify = useCallback(async (save, reason)=>{
-        const sessionDataSource = sessionDataSourceRef.current;
-        if (!sessionDataSource) throw Error("CsvUpload has no active edit session.");
-        if (!sessionDataSource.endEditSession) throw Error("CsvUpload requires the session datasource to support endEditSession.");
-        const currentSessionTable = sessionDataSource.table;
-        try {
-            await editSession.end(save);
-        } finally{
-            if ("unsubscribed" !== sessionDataSource.status && "function" == typeof sessionDataSource.unsubscribe) sessionDataSource.unsubscribe();
-            setActiveSessionDataSource(void 0);
-        }
-        onImportSessionEnded?.({
-            reason,
-            sessionTable: currentSessionTable && isSessionTable(currentSessionTable) ? currentSessionTable : void 0
-        });
-    }, [
-        editSession,
-        onImportSessionEnded,
-        setActiveSessionDataSource
-    ]);
+        sessionOverrides,
+        rowDefaults,
+        processingPromiseRef,
+        onImportSessionEnded
+    });
     const table = dataSource.table;
-    const schema = importTable ? resolvedImportSchema : resolvedImportSchema ?? dataSource.tableSchema;
-    const addAllRows = useCallback(async (mergedValidation, operationId)=>{
-        const vuuMsgByRow = new Map();
-        for (const { rowNum, column, message } of mergedValidation.errors){
-            if (rowNum < CSV_FIRST_DATA_ROW_NUMBER) continue;
-            const existing = vuuMsgByRow.get(rowNum);
-            const columnError = `${column}: ${message}`;
-            vuuMsgByRow.set(rowNum, existing ? `${existing}; ${columnError}` : columnError);
-        }
-        const parsedRowCount = mergedValidation.rows.length;
-        const unparsedErrorRows = [
-            ...vuuMsgByRow.keys()
-        ].filter((rowNum)=>rowNum - CSV_FIRST_DATA_ROW_NUMBER >= parsedRowCount).map((rowNum)=>({
-                rowNum,
-                rowData: {},
-                vuuMsg: vuuMsgByRow.get(rowNum) ?? ""
-            }));
-        const allRows = [
-            ...mergedValidation.rows.map((rowData, idx)=>({
-                    rowNum: idx + CSV_FIRST_DATA_ROW_NUMBER,
-                    rowData: rowData ?? {},
-                    vuuMsg: vuuMsgByRow.get(idx + CSV_FIRST_DATA_ROW_NUMBER) ?? ""
-                })),
-            ...unparsedErrorRows
-        ];
-        const rpcErrors = [];
-        for (const { rowNum, rowData, vuuMsg } of allRows){
-            if (operationId !== operationIdRef.current) return false;
-            try {
-                const payload = vuuMsg ? {
-                    vuuRowNum: rowNum,
-                    vuuMsg
-                } : {
-                    ...rowData,
-                    vuuRowNum: rowNum,
-                    vuuMsg
-                };
-                const result = await editSession.addRow(payload);
-                if (isRpcError(result)) throw Error(result.errorMessage);
-                if ("string" == typeof result) throw Error(result);
-            } catch (error) {
-                rpcErrors.push(`${0 === rowNum ? "Header" : `Row ${rowNum}`}: ${toErrorMessage(error)}`);
-            }
-        }
-        if (rpcErrors.length > 0) throw Error(buildRowErrorMessage("Import failed", rpcErrors));
-        return true;
-    }, [
-        editSession
-    ]);
-    const beginEditSession = useCallback(async ()=>{
-        const sessionDataSource = await editSession.begin("Empty", "import");
-        const sessionVuuTable = sessionDataSource?.table;
-        if (void 0 === sessionDataSource || void 0 === sessionVuuTable || !isSessionTable(sessionVuuTable)) throw Error("CsvUpload createSessionDataSource returned no session datasource.");
-        setActiveSessionDataSource(sessionDataSource);
-        return sessionDataSource;
-    }, [
-        editSession,
-        setActiveSessionDataSource
-    ]);
-    const closePendingEditSession = useCallback(async (save)=>{
-        if (void 0 === sessionDataSourceRef.current) return;
-        await endEditSessionAndNotify(save, save ? "saved" : "discarded");
-    }, [
-        endEditSessionAndNotify
-    ]);
     const cancelImport = useCallback(async ()=>{
         operationIdRef.current++;
         processingPromiseRef.current = void 0;
@@ -256,8 +89,13 @@ const useCsvUpload = ({ dataSource, importMode = "direct", importSchema, importT
         if (mergedValidation.rows.length > 0) try {
             const sessionDataSource = await beginEditSession();
             if (operationId !== operationIdRef.current) return;
-            const rowsAdded = await addAllRows(mergedValidation, operationId);
-            if (!rowsAdded) return;
+            const rowsAddedCount = await addAllRows(mergedValidation, ()=>operationId !== operationIdRef.current);
+            if (false === rowsAddedCount) return;
+            const expectedRowCount = rowsAddedCount;
+            sessionDataSource.range = Range(0, expectedRowCount);
+            const sessionErrors = await checkSessionTableErrors(sessionDataSource, expectedRowCount);
+            if (operationId !== operationIdRef.current) return;
+            if (sessionErrors.length > 0) throw Error(buildRowErrorMessage("Import failed", sessionErrors));
             onImportSessionReady?.(sessionDataSource);
         } catch (error) {
             if (void 0 !== sessionDataSourceRef.current) await endEditSessionAndNotify(false, "failed");
@@ -277,6 +115,7 @@ const useCsvUpload = ({ dataSource, importMode = "direct", importSchema, importT
         handleError,
         editSession,
         addAllRows,
+        checkSessionTableErrors,
         maxRows,
         parseOptions,
         beginEditSession,
@@ -287,7 +126,8 @@ const useCsvUpload = ({ dataSource, importMode = "direct", importSchema, importT
         endEditSessionAndNotify,
         schema,
         validators,
-        onImportSessionReady
+        onImportSessionReady,
+        sessionDataSourceRef
     ]);
     const handleFiles = useCallback(async (files)=>{
         const file = files[0];
@@ -355,7 +195,7 @@ const useCsvUpload = ({ dataSource, importMode = "direct", importSchema, importT
                     editSession,
                     tableData
                 });
-                ownsEditSessionRef.current = false;
+                releaseEditSessionOwnership();
             } else {
                 await endEditSessionAndNotify(true, "saved");
                 onImported?.({
@@ -383,6 +223,8 @@ const useCsvUpload = ({ dataSource, importMode = "direct", importSchema, importT
         onImported,
         onPreview,
         importMode,
+        releaseEditSessionOwnership,
+        sessionDataSourceRef,
         validation
     ]);
     return {

package/types/csv-upload/parse/csv-upload-utils.d.ts

@@ -1,4 +1,5 @@
 import type { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import type { DataSourceRow } from "@vuu-ui/vuu-data-types";
 import type { CsvUploadError } from "../CsvUpload";
 import type { CsvParseError } from "./csv-parse";
 import type { CsvValidationError, CsvValidationResult } from "./csv-schema-validation";
@@ -19,3 +20,7 @@ export type RpcBatchResult = {
     results: unknown[];
 };
 export declare const executeBatchRpcCalls: <T>(items: T[], executor: (item: T) => Promise<unknown>, errorFormatter: (item: T, error: string) => string) => Promise<RpcBatchResult>;
+export type SessionRowUpdateListener = () => void;
+export declare const getInlineRowErrorMessage: (result: unknown) => string | undefined;
+export declare const getRowVuuMsgError: (row: DataSourceRow, vuuMsgDataIndex: number, vuuRowNumDataIndex: number) => string | undefined;
+export declare const waitForSessionErrors: (isRemote: boolean, sessionErrors: Map<string | number, string>, receivedRowKeys: Set<string | number>, expectedRowCount: number, listeners: Set<SessionRowUpdateListener>, timeoutMs?: number) => Promise<string[]>;

package/types/csv-upload/session/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./useImportSchema";
+export * from "./useImportSession";

package/types/csv-upload/session/useImportSchema.d.ts

@@ -0,0 +1,13 @@
+import type { DataSource, SessionDataSourceOverrides, TableSchema } from "@vuu-ui/vuu-data-types";
+import type { VuuTable } from "@vuu-ui/vuu-protocol-types";
+export interface UseImportSchemaProps {
+    dataSource: DataSource;
+    importSchema?: TableSchema;
+    importTable?: VuuTable;
+}
+export interface UseImportSchemaResult {
+    resolvedImportSchema: TableSchema | undefined;
+    schema: TableSchema | undefined;
+    sessionOverrides: SessionDataSourceOverrides | undefined;
+}
+export declare const useImportSchema: ({ dataSource, importSchema, importTable, }: UseImportSchemaProps) => UseImportSchemaResult;

package/types/csv-upload/session/useImportSession.d.ts

@@ -0,0 +1,25 @@
+import type { DataSource, SessionDataSourceOverrides } from "@vuu-ui/vuu-data-types";
+import { EditSession, type RowDefaultDataItemValues } from "@vuu-ui/vuu-data-editing";
+import { type RefObject } from "react";
+import type { CsvValidationResult } from "../parse/csv-schema-validation";
+import type { CsvUploadSessionEndReason, CsvUploadSessionEndResult, CsvUploadSessionTable } from "../CsvUpload";
+export interface UseImportSessionProps {
+    dataSource: DataSource;
+    sessionOverrides?: SessionDataSourceOverrides;
+    rowDefaults?: RowDefaultDataItemValues;
+    processingPromiseRef?: RefObject<Promise<void> | undefined>;
+    onImportSessionEnded?: (result: CsvUploadSessionEndResult) => void;
+}
+export interface UseImportSessionReturn {
+    addAllRows: (mergedValidation: CsvValidationResult, isCancelled: () => boolean) => Promise<number | false>;
+    beginEditSession: () => Promise<DataSource>;
+    checkSessionTableErrors: (sessionDs: DataSource, expectedRowCount: number) => Promise<string[]>;
+    closePendingEditSession: (save: boolean) => Promise<void>;
+    editSession: EditSession;
+    endEditSessionAndNotify: (save: boolean, reason: CsvUploadSessionEndReason) => Promise<void>;
+    releaseEditSessionOwnership: () => void;
+    sessionDataSourceRef: React.MutableRefObject<DataSource | undefined>;
+    sessionTable: CsvUploadSessionTable | undefined;
+    setActiveSessionDataSource: (sessionDataSource?: DataSource) => void;
+}
+export declare const useImportSession: ({ dataSource, sessionOverrides, rowDefaults, processingPromiseRef, onImportSessionEnded, }: UseImportSessionProps) => UseImportSessionReturn;

package/types/csv-upload/useCsvUpload.d.ts

@@ -1,5 +1,5 @@
 import type { DataSource, TableSchema } from "@vuu-ui/vuu-data-types";
-import { type RowDefaultDataItemValues } from "@vuu-ui/vuu-data-editing";
+import type { RowDefaultDataItemValues } from "@vuu-ui/vuu-data-editing";
 import type { VuuTable } from "@vuu-ui/vuu-protocol-types";
 import { type CsvParseOptions } from "./parse/csv-parse";
 import { type CsvValidationResult, type CsvColumnValidator } from "./parse/csv-schema-validation";