@vuu-ui/vuu-table-extras 4.0.0-alpha.2 → 4.0.0-alpha.21

package/src/csv-upload/CsvUpload.js

@@ -2,12 +2,12 @@ import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { Button, Dialog, DialogActions, DialogContent, DialogHeader, FileDropZone, FileDropZoneIcon, FileDropZoneTrigger, Text } from "@salt-ds/core";
 import { useComponentCssInjection } from "@salt-ds/styles";
 import { useWindow } from "@salt-ds/window";
-import { useCallback, useState } from "react";
+import { useCallback, useMemo, useState } from "react";
 import { useCsvUpload } from "./useCsvUpload.js";
 import CsvUpload from "./CsvUpload.css";
 const classBase = "vuuCsvUpload";
 const CsvUpload_CsvUpload = (props)=>{
-    const { children, dialogTitle = "Import CSV", embedded = false, onCancel, onClose, open, renderError } = props;
+    const { children, dialogTitle = "Import CSV", embedded = false, onCancel, onClose, open } = props;
     const isControlledOpen = void 0 !== open;
     const [internalOpen, setInternalOpen] = useState(open ?? true);
     const dialogOpen = isControlledOpen ? open : internalOpen;
@@ -18,7 +18,23 @@ const CsvUpload_CsvUpload = (props)=>{
         window: targetWindow
     });
     const { canImport, cancelImport, isProcessingFile, isImporting, importData, onDrop, onTriggerChange, schema, validation, error } = useCsvUpload(props);
-    const fileErrors = validation?.errors.filter((e)=>e.column in validation.errorMap.fileErrors) ?? [];
+    const errorsToRender = useMemo(()=>{
+        if (validation?.errors && validation.errors.length > 0) return validation.errors;
+        const parseErrors = error?.errors.schemaError?.parseError?.errors || error?.errors.validationError?.parseError?.errors;
+        if (parseErrors && parseErrors.length > 0) return parseErrors;
+        return [];
+    }, [
+        validation,
+        error
+    ]);
+    const parsedSchemaErrors = useMemo(()=>{
+        const schemaErrorMsg = error?.errors.schemaError?.message || error?.errors.validationError?.message;
+        if (!schemaErrorMsg) return [];
+        const cleanedMsg = schemaErrorMsg.replace(/^CSV validation failed:\s*/, "");
+        return cleanedMsg.split(";").map((item)=>item.trim()).filter((item)=>item.length > 0);
+    }, [
+        error
+    ]);
     const hasErrors = !!error || validation && validation.errors.length > 0;
     const isUploaded = canImport || isImporting;
     const status = hasErrors ? "error" : isUploaded ? "success" : void 0;
@@ -37,73 +53,101 @@ const CsvUpload_CsvUpload = (props)=>{
         importData,
         onClose
     ]);
-    const content = /*#__PURE__*/ jsxs("div", {
-        className: classBase,
-        children: [
-            /*#__PURE__*/ jsx(FileDropZone, {
-                className: `${classBase}-dropZone`,
-                disabled: void 0 === schema || isProcessingFile || isImporting,
-                onDrop: onDrop,
-                status: status,
-                children: isUploaded ? /*#__PURE__*/ jsxs(Fragment, {
-                    children: [
-                        /*#__PURE__*/ jsx(FileDropZoneIcon, {
-                            status: "success"
-                        }),
-                        /*#__PURE__*/ jsx("strong", {
-                            children: "Upload completed"
-                        })
-                    ]
-                }) : /*#__PURE__*/ jsxs(Fragment, {
-                    children: [
-                        /*#__PURE__*/ jsx(FileDropZoneIcon, {
-                            status: hasErrors ? "error" : void 0
-                        }),
-                        validation && validation.errors.length > 0 ? /*#__PURE__*/ jsxs(Fragment, {
-                            children: [
-                                /*#__PURE__*/ jsx("div", {
-                                    children: "Your file contains errors"
-                                }),
-                                fileErrors.length > 0 && /*#__PURE__*/ jsx("ul", {
-                                    className: `${classBase}-errorList`,
-                                    children: fileErrors.map((error, i)=>/*#__PURE__*/ jsx("li", {
-                                            className: `${classBase}-errorItem`,
-                                            children: error.message
-                                        }, `${error.column}-${error.message}-${i}`))
-                                }),
-                                /*#__PURE__*/ jsx("div", {
-                                    children: "Please rectify and reupload"
-                                })
-                            ]
-                        }) : /*#__PURE__*/ jsx("div", {
-                            children: "Drop a file here or"
-                        }),
-                        /*#__PURE__*/ jsx(FileDropZoneTrigger, {
-                            accept: ".csv,text/csv",
-                            onChange: onTriggerChange,
-                            children: "BROWSE FILES"
-                        }),
-                        /*#__PURE__*/ jsx(Text, {
-                            children: "Only .csv files"
-                        }),
-                        children
-                    ]
+    const renderErrorsContent = useMemo(()=>{
+        if (error?.errors.importError) return /*#__PURE__*/ jsxs(Fragment, {
+            children: [
+                /*#__PURE__*/ jsx("strong", {
+                    children: "Import failed"
+                }),
+                /*#__PURE__*/ jsx("div", {
+                    className: `${classBase}-errorContainer`,
+                    children: /*#__PURE__*/ jsx("div", {
+                        className: `${classBase}-errorItem ${classBase}-importErrorItem`,
+                        children: error.errors.importError.message
+                    })
                 })
-            }),
-            error && (renderError ? renderError(error) : /*#__PURE__*/ jsxs("div", {
-                className: `${classBase}-errors`,
+            ]
+        });
+        if (hasErrors) {
+            const headingText = error ? "Validation failed" : "Your file contains errors";
+            return /*#__PURE__*/ jsxs(Fragment, {
                 children: [
+                    /*#__PURE__*/ jsx("strong", {
+                        children: headingText
+                    }),
                     /*#__PURE__*/ jsx("div", {
-                        children: /*#__PURE__*/ jsx("strong", {
-                            children: "Import Error:"
+                        className: `${classBase}-errorContainer`,
+                        children: errorsToRender.length > 0 ? /*#__PURE__*/ jsx("ul", {
+                            className: `${classBase}-errorList`,
+                            children: errorsToRender.map((error, i)=>/*#__PURE__*/ jsxs("li", {
+                                    className: `${classBase}-errorItem`,
+                                    children: [
+                                        error.rowNum > 0 ? `Row ${error.rowNum}: ` : "",
+                                        "*" === error.column ? "" : `${error.column}: `,
+                                        error.message
+                                    ]
+                                }, `${error.column}-${error.message}-${i}`))
+                        }) : parsedSchemaErrors.length > 0 ? /*#__PURE__*/ jsx("ul", {
+                            className: `${classBase}-errorList`,
+                            children: parsedSchemaErrors.map((errMsg)=>/*#__PURE__*/ jsx("li", {
+                                    className: `${classBase}-errorItem`,
+                                    children: errMsg
+                                }, errMsg))
+                        }) : /*#__PURE__*/ jsx("div", {
+                            className: `${classBase}-errorItem ${classBase}-importErrorItem`,
+                            children: error?.errors.schemaError?.message || error?.errors.validationError?.message || "An unexpected error occurred during import"
                         })
+                    })
+                ]
+            });
+        }
+        return /*#__PURE__*/ jsx("div", {
+            children: "Drop a file here or"
+        });
+    }, [
+        error,
+        hasErrors,
+        errorsToRender,
+        parsedSchemaErrors
+    ]);
+    const content = /*#__PURE__*/ jsx("div", {
+        className: classBase,
+        children: /*#__PURE__*/ jsx(FileDropZone, {
+            className: `${classBase}-dropZone`,
+            disabled: void 0 === schema || isProcessingFile || isImporting,
+            onDrop: onDrop,
+            status: status,
+            children: isUploaded ? /*#__PURE__*/ jsxs(Fragment, {
+                children: [
+                    /*#__PURE__*/ jsx(FileDropZoneIcon, {
+                        status: "success"
                     }),
-                    /*#__PURE__*/ jsx("div", {
-                        children: error.errors.importError?.message || error.errors.schemaError?.message || error.errors.validationError?.message || "An unexpected error occurred during import."
+                    /*#__PURE__*/ jsx("strong", {
+                        children: "Upload completed"
                     })
                 ]
-            }))
-        ]
+            }) : /*#__PURE__*/ jsxs(Fragment, {
+                children: [
+                    /*#__PURE__*/ jsx(FileDropZoneIcon, {
+                        status: hasErrors ? "error" : void 0
+                    }),
+                    renderErrorsContent,
+                    hasErrors && /*#__PURE__*/ jsx(Text, {
+                        className: `${classBase}-rectifyPrompt`,
+                        children: "Please rectify and reupload"
+                    }),
+                    /*#__PURE__*/ jsx(FileDropZoneTrigger, {
+                        accept: ".csv,text/csv",
+                        onChange: onTriggerChange,
+                        children: "BROWSE FILES"
+                    }),
+                    /*#__PURE__*/ jsx(Text, {
+                        children: "Only .csv files"
+                    }),
+                    children
+                ]
+            })
+        })
     });
     const actions = /*#__PURE__*/ jsxs(DialogActions, {
         children: [

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

@@ -13,7 +13,7 @@ var csv_errors_CsvValidationErrorEnum = /*#__PURE__*/ function(CsvValidationErro
     CsvValidationErrorEnum["MISSING_KEY_COLUMN"] = "MISSING_KEY_COLUMN";
     CsvValidationErrorEnum["UNKNOWN_COLUMN"] = "UNKNOWN_COLUMN";
     CsvValidationErrorEnum["MAX_ROWS_EXCEEDED"] = "MAX_ROWS_EXCEEDED";
-    CsvValidationErrorEnum["EMPTY_NON_STRING_VALUE"] = "EMPTY_NON_STRING_VALUE";
+    CsvValidationErrorEnum["REQUIRED_FIELD_MISSING"] = "REQUIRED_FIELD_MISSING";
     CsvValidationErrorEnum["TYPE_MISMATCH"] = "TYPE_MISMATCH";
     CsvValidationErrorEnum["CUSTOM_VALIDATION"] = "CUSTOM_VALIDATION";
     return CsvValidationErrorEnum;

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

@@ -68,7 +68,7 @@ const parseCsv = (csvText, options)=>{
     }
     const rows = records.slice(1);
     rows.forEach((row, rowIndex)=>{
-        if (row.length !== header.length) addCsvRowError(errorState, rowIndex + CSV_FIRST_DATA_ROW_NUMBER, "*", CsvParseErrorEnum.ROW_COLUMN_COUNT_MISMATCH, "CSV rows must have the same number of columns as the header.", row.join(","));
+        if (row.length !== header.length) addCsvRowError(errorState, rowIndex + CSV_FIRST_DATA_ROW_NUMBER, "*", CsvParseErrorEnum.ROW_COLUMN_COUNT_MISMATCH, "This row has too many or too few columns compared to the header line. Check for extra or missing commas.", row.join(","));
     });
     if (hasCsvErrors(errorState.errorMap)) return withError("CSV rows must have the same number of columns as the header.", errorState.errorMap, errorState.errors, header, rows);
     return {

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

@@ -4,10 +4,44 @@ import { CSV_FIRST_DATA_ROW_NUMBER, MAX_ROWS_IN_CSV } from "./csv-constants.js";
 const INTERNAL_KEY_COLUMNS = new Set([
     "vuuRowNum"
 ]);
+const getFriendlyTypeName = (type)=>{
+    switch(type){
+        case "int":
+        case "long":
+            return "whole number";
+        case "double":
+        case "number":
+        case "decimal":
+        case "scaleddecimal":
+        case "scaleddecimal2":
+        case "scaleddecimal4":
+        case "scaleddecimal6":
+        case "scaleddecimal8":
+            return "decimal or number";
+        case "time":
+            return "time in 'HH:MM:SS' format";
+        case "epochtimestamp":
+        case "epochtimestampnano":
+        case "date/time":
+            return "date/time";
+        case "char":
+            return "single character";
+        case "boolean":
+            return "boolean (true/false)";
+        case "json":
+            return "JSON value";
+        default:
+            return type;
+    }
+};
+const getFriendlyErrorMessage = (errMessage, rawValue, toType)=>{
+    if (errMessage.includes("is not a valid")) return `'${rawValue}' is not a valid ${getFriendlyTypeName(toType)}`;
+    return errMessage;
+};
 const validateCsvAgainstSchema = (parsed, tableSchema, options)=>{
     const schemaColumns = new Map(tableSchema.columns.map((col)=>[
             col.name,
-            col.serverDataType
+            col
         ]));
     const maxRows = options?.maxRows ?? MAX_ROWS_IN_CSV;
     const errorState = createCsvErrorState();
@@ -21,22 +55,27 @@ const validateCsvAgainstSchema = (parsed, tableSchema, options)=>{
         const rowNum = rowIndex + CSV_FIRST_DATA_ROW_NUMBER;
         const typedRow = {};
         const rawRow = parsed.header.reduce((acc, headerCol, idx)=>{
-            acc[headerCol] = rowValues[idx];
+            acc[headerCol] = rowValues[idx] ?? "";
             return acc;
         }, {});
         parsed.header.forEach((columnName, columnIndex)=>{
-            const rawValue = rowValues[columnIndex];
-            const schemaType = schemaColumns.get(columnName);
-            if (0 === rawValue.length && "string" !== schemaType) return void addCsvRowError(errorState, rowNum, columnName, CsvValidationErrorEnum.EMPTY_NON_STRING_VALUE, "Empty value is not allowed for non-string columns.", rawValue);
+            const rawValue = rowValues[columnIndex] ?? "";
+            const schemaColumn = schemaColumns.get(columnName);
+            const schemaType = schemaColumn?.serverDataType;
+            const isRequired = schemaColumn?.required === true;
+            if (0 === rawValue.length) {
+                if (isRequired) addCsvRowError(errorState, rowNum, columnName, CsvValidationErrorEnum.REQUIRED_FIELD_MISSING, "This field is required and cannot be left blank", rawValue);
+                return;
+            }
             let value;
             const toType = schemaType ?? "string";
             try {
                 value = getTypedValue(rawValue, toType);
             } catch (err) {
-                addCsvRowError(errorState, rowNum, columnName, CsvValidationErrorEnum.TYPE_MISMATCH, err instanceof Error ? err.message : String(err), rawValue);
+                addCsvRowError(errorState, rowNum, columnName, CsvValidationErrorEnum.TYPE_MISMATCH, getFriendlyErrorMessage(err instanceof Error ? err.message : String(err), rawValue, toType), rawValue);
                 return;
             }
-            if (void 0 === value) return void addCsvRowError(errorState, rowNum, columnName, CsvValidationErrorEnum.TYPE_MISMATCH, `Value '${rawValue}' is not a valid ${toType}`, rawValue);
+            if (void 0 === value) return void addCsvRowError(errorState, rowNum, columnName, CsvValidationErrorEnum.TYPE_MISMATCH, `'${rawValue}' is not a valid ${getFriendlyTypeName(toType)}`, rawValue);
             const customValidator = options?.validators?.[columnName];
             if (customValidator) {
                 const validationResult = customValidator(rawValue, columnName, rawRow);

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,49 @@ 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.trim();
+    }
+};
+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] ? Number(row[vuuRowNumDataIndex]) : Number(row[metadataKeys.IDX]) + CSV_FIRST_DATA_ROW_NUMBER;
+        return {
+            rowNum,
+            message: msg.trim()
+        };
+    }
+};
+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,204 @@
+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) sessionErrorsRef.current.set(rowNum, {
+                    rowNum,
+                    message: 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 };