@vuu-ui/vuu-table-extras 2.1.18 → 2.1.19-beta.2

package/src/column-settings-panel/ColumnSettingsPanel.js

@@ -0,0 +1,173 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Button, FormField, FormFieldLabel, ToggleButton, ToggleButtonGroup } from "@salt-ds/core";
+import { useComponentCssInjection } from "@salt-ds/styles";
+import { useWindow } from "@salt-ds/window";
+import { Icon, VuuInput } from "@vuu-ui/vuu-ui-controls";
+import { getCalculatedColumnDetails, getDefaultAlignment, isCalculatedColumn } from "@vuu-ui/vuu-utils";
+import { ColumnFormattingPanel } from "../column-formatting-settings/index.js";
+import { ColumnNameLabel } from "./ColumnNameLabel.js";
+import { useColumnSettings } from "./useColumnSettings.js";
+import ColumnSettingsPanel from "./ColumnSettingsPanel.css";
+const classBase = "vuuColumnSettingsPanel";
+const getColumnLabel = (column)=>{
+    const { name, label } = column;
+    if (isCalculatedColumn(name)) return label ?? getCalculatedColumnDetails(column).name;
+    return label ?? name;
+};
+const ColumnSettingsPanel_ColumnSettingsPanel = ({ column: columnProp, columnModel, onClickEditCalculatedColumn, onConfigChange })=>{
+    const targetWindow = useWindow();
+    useComponentCssInjection({
+        testId: "vuu-column-settings-panel",
+        css: ColumnSettingsPanel,
+        window: targetWindow
+    });
+    const isNewCalculatedColumn = "::" === columnProp.name;
+    const { availableRenderers, column, navigateNextColumn, navigatePrevColumn, onChange, onChangeFormatting, onChangeRendering, onChangeToggleButton, onChangeType, onInputCommit } = useColumnSettings({
+        column: columnProp,
+        columnModel,
+        onConfigChange
+    });
+    const { serverDataType, align = getDefaultAlignment(serverDataType), pin, width = "" } = column;
+    return /*#__PURE__*/ jsxs("div", {
+        className: classBase,
+        children: [
+            /*#__PURE__*/ jsx("div", {
+                className: `${classBase}-header`,
+                children: /*#__PURE__*/ jsx(ColumnNameLabel, {
+                    column: column,
+                    onClick: onClickEditCalculatedColumn
+                })
+            }),
+            /*#__PURE__*/ jsxs(FormField, {
+                "data-field": "column-label",
+                children: [
+                    /*#__PURE__*/ jsx(FormFieldLabel, {
+                        children: "Column Label"
+                    }),
+                    /*#__PURE__*/ jsx(VuuInput, {
+                        bordered: true,
+                        className: "vuuInput",
+                        "data-embedded": true,
+                        onChange: onChange,
+                        onCommit: onInputCommit,
+                        value: getColumnLabel(column)
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsxs(FormField, {
+                "data-field": "column-width",
+                children: [
+                    /*#__PURE__*/ jsx(FormFieldLabel, {
+                        children: "Column Width"
+                    }),
+                    /*#__PURE__*/ jsx(VuuInput, {
+                        bordered: true,
+                        className: "vuuInput",
+                        "data-embedded": true,
+                        onChange: onChange,
+                        value: width,
+                        onCommit: onInputCommit
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsxs(FormField, {
+                "data-field": "column-alignment",
+                children: [
+                    /*#__PURE__*/ jsx(FormFieldLabel, {
+                        children: "Alignment"
+                    }),
+                    /*#__PURE__*/ jsxs(ToggleButtonGroup, {
+                        onChange: onChangeToggleButton,
+                        value: align,
+                        children: [
+                            /*#__PURE__*/ jsx(ToggleButton, {
+                                value: "left",
+                                children: /*#__PURE__*/ jsx(Icon, {
+                                    name: "align-left",
+                                    size: 16
+                                })
+                            }),
+                            /*#__PURE__*/ jsx(ToggleButton, {
+                                value: "right",
+                                children: /*#__PURE__*/ jsx(Icon, {
+                                    name: "align-right",
+                                    size: 16
+                                })
+                            })
+                        ]
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsxs(FormField, {
+                "data-field": "column-pin",
+                children: [
+                    /*#__PURE__*/ jsx(FormFieldLabel, {
+                        children: "Pin Column"
+                    }),
+                    /*#__PURE__*/ jsxs(ToggleButtonGroup, {
+                        onChange: onChangeToggleButton,
+                        value: pin || "false",
+                        children: [
+                            /*#__PURE__*/ jsx(ToggleButton, {
+                                value: "left",
+                                children: /*#__PURE__*/ jsx(Icon, {
+                                    name: "pin-left",
+                                    size: 16
+                                })
+                            }),
+                            /*#__PURE__*/ jsx(ToggleButton, {
+                                value: "floating",
+                                children: /*#__PURE__*/ jsx(Icon, {
+                                    name: "pin-float",
+                                    size: 16
+                                })
+                            }),
+                            /*#__PURE__*/ jsx(ToggleButton, {
+                                value: "right",
+                                children: /*#__PURE__*/ jsx(Icon, {
+                                    name: "pin-right",
+                                    size: 16
+                                })
+                            }),
+                            /*#__PURE__*/ jsx(ToggleButton, {
+                                value: "",
+                                children: /*#__PURE__*/ jsx(Icon, {
+                                    name: "cross-circle",
+                                    size: 16
+                                })
+                            })
+                        ]
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsx(ColumnFormattingPanel, {
+                availableRenderers: availableRenderers,
+                column: column,
+                onChangeFormatting: onChangeFormatting,
+                onChangeRendering: onChangeRendering,
+                onChangeColumnType: onChangeType
+            }),
+            /*#__PURE__*/ jsxs("div", {
+                className: `${classBase}-buttonBar`,
+                "data-align": isNewCalculatedColumn ? "right" : void 0,
+                children: [
+                    /*#__PURE__*/ jsx(Button, {
+                        className: `${classBase}-buttonNavPrev`,
+                        variant: "secondary",
+                        "data-icon": "arrow-left",
+                        onClick: navigatePrevColumn,
+                        children: "PREVIOUS"
+                    }),
+                    /*#__PURE__*/ jsx(Button, {
+                        className: `${classBase}-buttonNavNext`,
+                        variant: "secondary",
+                        "data-icon": "arrow-right",
+                        onClick: navigateNextColumn,
+                        children: "NEXT"
+                    })
+                ]
+            })
+        ]
+    });
+};
+export { ColumnSettingsPanel_ColumnSettingsPanel as ColumnSettingsPanel };

package/src/column-settings-panel/useColumnSettings.js

@@ -0,0 +1,205 @@
+import { getFieldName, getRegisteredCellRenderers, getServerDataType, isValidColumnAlignment, isValidPinLocation, queryClosest, setCalculatedColumnName, updateColumnFormatting, updateColumnRenderProps, updateColumnType } from "@vuu-ui/vuu-utils";
+import { useCallback, useEffect, useMemo, useState } from "react";
+const integerCellRenderers = [
+    {
+        description: "Default formatter for columns with data type integer",
+        label: "Default Renderer (int, long)",
+        name: "default-int"
+    }
+];
+const doubleCellRenderers = [
+    {
+        description: "Default formatter for columns with data type double",
+        label: "Default Renderer (double)",
+        name: "default-double"
+    }
+];
+const decimalCellRenderers = [
+    {
+        description: "Default formatter for columns with data type decimal (2,4,6 or 8)",
+        label: "Default Renderer (decimal)",
+        name: "default-decimal"
+    }
+];
+const stringCellRenderers = [
+    {
+        description: "Default formatter for columns with data type string",
+        label: "Default Renderer (string)",
+        name: "default-string"
+    }
+];
+const booleanCellRenderers = [];
+const getAvailableCellRenderers = (column)=>{
+    const serverDataType = getServerDataType(column);
+    switch(serverDataType){
+        case "char":
+        case "string":
+            return stringCellRenderers.concat(getRegisteredCellRenderers("string"));
+        case "int":
+        case "long":
+            return integerCellRenderers.concat(getRegisteredCellRenderers("int"));
+        case "double":
+            return doubleCellRenderers.concat(getRegisteredCellRenderers(column.serverDataType));
+        case "scaleddecimal2":
+        case "scaleddecimal4":
+        case "scaleddecimal6":
+        case "scaleddecimal8":
+            return decimalCellRenderers.concat(getRegisteredCellRenderers(column.serverDataType));
+        case "boolean":
+            return booleanCellRenderers.concat(getRegisteredCellRenderers("boolean"));
+        default:
+            return stringCellRenderers;
+    }
+};
+const useColumnSettings = ({ column: columnProp, columnModel })=>{
+    const [column, setColumn] = useState(columnModel.getColumn(columnProp.name));
+    useEffect(()=>{
+        setColumn(columnProp);
+    }, [
+        columnProp
+    ]);
+    const availableRenderers = useMemo(()=>getAvailableCellRenderers(column), [
+        column
+    ]);
+    const handleChangeToggleButton = useCallback((evt)=>{
+        const button = queryClosest(evt.target, "button");
+        if (button) {
+            const fieldName = getFieldName(button);
+            const { value } = button;
+            switch(fieldName){
+                case "column-alignment":
+                    if (isValidColumnAlignment(value)) {
+                        const newColumn = {
+                            ...column,
+                            align: value
+                        };
+                        setColumn(newColumn);
+                        columnModel.updateColumn(newColumn);
+                    }
+                    break;
+                case "column-pin":
+                    if (isValidPinLocation(value)) {
+                        const newColumn = {
+                            ...column,
+                            pin: value || void 0
+                        };
+                        setColumn(newColumn);
+                        columnModel.updateColumn(newColumn);
+                        break;
+                    }
+            }
+        }
+    }, [
+        column,
+        columnModel
+    ]);
+    const handleChange = useCallback((evt)=>{
+        const input = evt.target;
+        const fieldName = getFieldName(input);
+        const { value } = input;
+        switch(fieldName){
+            case "column-label":
+                setColumn((state)=>({
+                        ...state,
+                        label: value
+                    }));
+                break;
+            case "column-name":
+                setColumn((state)=>setCalculatedColumnName(state, value));
+                break;
+            case "column-width":
+                {
+                    const numericValue = parseInt(value, 10);
+                    isNaN(numericValue) ? setColumn((state)=>({
+                            ...state,
+                            width: void 0
+                        })) : setColumn((state)=>({
+                            ...state,
+                            width: numericValue
+                        }));
+                }
+                break;
+        }
+    }, []);
+    const handleInputCommit = useCallback(()=>{
+        columnModel.updateColumn(column);
+    }, [
+        column,
+        columnModel
+    ]);
+    const handleChangeCalculatedColumnName = useCallback((name)=>{
+        setColumn((state)=>({
+                ...state,
+                name
+            }));
+    }, []);
+    const handleChangeRendering = useCallback((renderProps)=>{
+        if (renderProps) {
+            const newColumn = updateColumnRenderProps(column, renderProps);
+            setColumn(newColumn);
+            columnModel.updateColumn(newColumn);
+        }
+    }, [
+        column,
+        columnModel
+    ]);
+    const handleChangeFormatting = useCallback((formatting)=>{
+        const newColumn = updateColumnFormatting(column, formatting);
+        setColumn(newColumn);
+        columnModel.updateColumn(newColumn);
+    }, [
+        column,
+        columnModel
+    ]);
+    const handleChangeType = useCallback((type)=>{
+        const updatedColumn = updateColumnType(column, type);
+        setColumn(updatedColumn);
+        columnModel.updateColumn(updatedColumn);
+    }, [
+        column,
+        columnModel
+    ]);
+    const handleChangeServerDataType = useCallback((serverDataType)=>{
+        setColumn((col)=>({
+                ...col,
+                serverDataType
+            }));
+    }, []);
+    const navigateColumn = useCallback(({ moveBy })=>{
+        const index = columnModel.selectedColumns.indexOf(column) + moveBy;
+        const newColumn = columnModel.selectedColumns[index];
+        if (newColumn) setColumn(newColumn);
+    }, [
+        column,
+        columnModel
+    ]);
+    const navigateNextColumn = useCallback(()=>{
+        navigateColumn({
+            moveBy: 1
+        });
+    }, [
+        navigateColumn
+    ]);
+    const navigatePrevColumn = useCallback(()=>{
+        navigateColumn({
+            moveBy: -1
+        });
+    }, [
+        navigateColumn
+    ]);
+    return {
+        availableRenderers,
+        column,
+        navigateNextColumn,
+        navigatePrevColumn,
+        onChange: handleChange,
+        onChangeCalculatedColumnName: handleChangeCalculatedColumnName,
+        onChangeFormatting: handleChangeFormatting,
+        onChangeRendering: handleChangeRendering,
+        onChangeServerDataType: handleChangeServerDataType,
+        onChangeToggleButton: handleChangeToggleButton,
+        onChangeType: handleChangeType,
+        onInputCommit: handleInputCommit
+    };
+};
+export { useColumnSettings };

package/src/csv-upload/CsvUpload.css.js

@@ -0,0 +1,28 @@
+const css = `
+.vuuCsvUpload {
+  gap: var(--salt-spacing-200);
+  display: grid;
+}
+
+.vuuCsvUpload-dropZone {
+  align-items: center;
+  gap: var(--salt-spacing-100);
+  min-height: calc(var(--salt-size-base) * 4);
+  padding: var(--salt-spacing-300);
+  text-align: center;
+  justify-items: center;
+  display: grid;
+}
+
+.vuuCsvUpload-errors {
+  border: solid 1px var(--salt-status-error-borderColor);
+  border-radius: var(--salt-size-borderRadius);
+  color: var(--salt-status-error-foreground);
+  gap: var(--salt-spacing-100);
+  padding: var(--salt-spacing-200);
+  display: grid;
+}
+
+
+`;
+export default css;

package/src/csv-upload/CsvUpload.js

@@ -0,0 +1,95 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Button, Dialog, DialogActions, DialogContent, DialogHeader, FileDropZone, FileDropZoneIcon, FileDropZoneTrigger } from "@salt-ds/core";
+import { useComponentCssInjection } from "@salt-ds/styles";
+import { useWindow } from "@salt-ds/window";
+import { useCallback, 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", onCancel, onClose, open } = props;
+    const isControlledOpen = void 0 !== open;
+    const [internalOpen, setInternalOpen] = useState(open ?? true);
+    const handleCancel = useCallback(()=>{
+        if (!isControlledOpen) setInternalOpen(false);
+        onCancel?.();
+    }, [
+        isControlledOpen,
+        onCancel
+    ]);
+    const dialogOpen = isControlledOpen ? open : internalOpen;
+    const targetWindow = useWindow();
+    useComponentCssInjection({
+        testId: "vuu-csv-upload",
+        css: CsvUpload,
+        window: targetWindow
+    });
+    const { canImport, isProcessingFile, isImporting, importData, onDrop, onTriggerChange, schema, validation } = useCsvUpload(props);
+    const handleImport = useCallback(async ()=>{
+        await importData();
+        onClose?.();
+    }, [
+        importData,
+        onClose
+    ]);
+    return /*#__PURE__*/ jsxs(Dialog, {
+        open: dialogOpen,
+        children: [
+            /*#__PURE__*/ jsx(DialogHeader, {
+                header: dialogTitle
+            }),
+            /*#__PURE__*/ jsx(DialogContent, {
+                children: /*#__PURE__*/ jsxs("div", {
+                    className: classBase,
+                    children: [
+                        /*#__PURE__*/ jsxs(FileDropZone, {
+                            className: `${classBase}-dropZone`,
+                            disabled: void 0 === schema || isProcessingFile || isImporting,
+                            onDrop: onDrop,
+                            status: validation && validation.errors.length > 0 ? "error" : void 0,
+                            children: [
+                                /*#__PURE__*/ jsx(FileDropZoneIcon, {}),
+                                validation && validation.errors.length > 0 ? /*#__PURE__*/ jsxs(Fragment, {
+                                    children: [
+                                        /*#__PURE__*/ jsx("div", {
+                                            children: "Your file contains errors"
+                                        }),
+                                        /*#__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"
+                                })
+                            ]
+                        }),
+                        children
+                    ]
+                })
+            }),
+            /*#__PURE__*/ jsxs(DialogActions, {
+                children: [
+                    /*#__PURE__*/ jsx(Button, {
+                        appearance: "solid",
+                        sentiment: "negative",
+                        onClick: handleCancel,
+                        children: "Cancel"
+                    }),
+                    /*#__PURE__*/ jsx(Button, {
+                        disabled: !canImport,
+                        appearance: "solid",
+                        sentiment: "accented",
+                        onClick: handleImport,
+                        children: isProcessingFile ? "Validating..." : isImporting ? "Importing..." : "Import"
+                    })
+                ]
+            })
+        ]
+    });
+};
+export { CsvUpload_CsvUpload as CsvUpload };

package/src/csv-upload/index.js

@@ -0,0 +1,7 @@
+export { CsvUpload } from "./CsvUpload.js";
+export { useCsvUpload } from "./useCsvUpload.js";
+export { useCsvUploadSessionPreview } from "./useCsvUploadSessionPreview.js";
+export { validateCsvAgainstSchema } from "./parse/csv-schema-validation.js";
+export { parseCsv } from "./parse/csv-parse.js";
+export { CsvParseErrorEnum, CsvValidationErrorEnum } from "./parse/csv-errors.js";
+export { CSV_FIRST_DATA_ROW_NUMBER, CSV_HEADER_ROW_NUMBER } from "./parse/csv-constants.js";

package/{esm/packages/vuu-table-extras/src → src}/csv-upload/parse/csv-constants.js

@@ -1,5 +1,3 @@
 const CSV_HEADER_ROW_NUMBER = 1;
 const CSV_FIRST_DATA_ROW_NUMBER = 2;
-
 export { CSV_FIRST_DATA_ROW_NUMBER, CSV_HEADER_ROW_NUMBER };
-//# sourceMappingURL=csv-constants.js.map

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

@@ -0,0 +1,54 @@
+import { CSV_HEADER_ROW_NUMBER } from "./csv-constants.js";
+var csv_errors_CsvParseErrorEnum = /*#__PURE__*/ function(CsvParseErrorEnum) {
+    CsvParseErrorEnum["EMPTY_FILE"] = "EMPTY_FILE";
+    CsvParseErrorEnum["INVALID_SEPARATOR"] = "INVALID_SEPARATOR";
+    CsvParseErrorEnum["INVALID_FORMAT"] = "INVALID_FORMAT";
+    CsvParseErrorEnum["UNQUOTED_VALUE"] = "UNQUOTED_VALUE";
+    CsvParseErrorEnum["EMPTY_HEADER_COLUMN"] = "EMPTY_HEADER_COLUMN";
+    CsvParseErrorEnum["DUPLICATE_HEADER_COLUMN"] = "DUPLICATE_HEADER_COLUMN";
+    CsvParseErrorEnum["ROW_COLUMN_COUNT_MISMATCH"] = "ROW_COLUMN_COUNT_MISMATCH";
+    return CsvParseErrorEnum;
+}({});
+var csv_errors_CsvValidationErrorEnum = /*#__PURE__*/ function(CsvValidationErrorEnum) {
+    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["TYPE_MISMATCH"] = "TYPE_MISMATCH";
+    return CsvValidationErrorEnum;
+}({});
+const createCsvErrorState = ()=>({
+        errorMap: {
+            rowErrors: {},
+            fileErrors: {}
+        },
+        errors: []
+    });
+const addCsvFileError = (state, columnName, error, message, value = "")=>{
+    const existing = state.errorMap.fileErrors[columnName] ?? [];
+    existing.push(error);
+    state.errorMap.fileErrors[columnName] = existing;
+    state.errors.push({
+        rowNum: CSV_HEADER_ROW_NUMBER,
+        column: columnName,
+        value,
+        message,
+        errorEnum: error
+    });
+};
+const addCsvRowError = (state, rowNum, columnName, error, message, value = "")=>{
+    const rowErrors = state.errorMap.rowErrors[rowNum] ?? {};
+    const existing = rowErrors[columnName] ?? [];
+    existing.push(error);
+    rowErrors[columnName] = existing;
+    state.errorMap.rowErrors[rowNum] = rowErrors;
+    state.errors.push({
+        rowNum,
+        column: columnName,
+        value,
+        message,
+        errorEnum: error
+    });
+};
+const hasCsvErrors = (errorMap)=>Object.keys(errorMap.fileErrors).length > 0 || Object.keys(errorMap.rowErrors).length > 0;
+export { addCsvFileError, addCsvRowError, createCsvErrorState, csv_errors_CsvParseErrorEnum as CsvParseErrorEnum, csv_errors_CsvValidationErrorEnum as CsvValidationErrorEnum, hasCsvErrors };

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

@@ -0,0 +1,79 @@
+import { parse } from "csv-parse/browser/esm/sync";
+import { CsvParseErrorEnum, addCsvFileError, addCsvRowError, createCsvErrorState, hasCsvErrors } from "./csv-errors.js";
+import { CSV_FIRST_DATA_ROW_NUMBER, CSV_HEADER_ROW_NUMBER } from "./csv-constants.js";
+const normaliseLineEndings = (input)=>input.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+const quotedCsvLinePattern = /^\s*"(?:""|[^"])*"\s*(,\s*"(?:""|[^"])*"\s*)*$/;
+const withError = (message, errorMap, errors, header = [], rows = [])=>({
+        error: {
+            errorMap,
+            errors,
+            message
+        },
+        header,
+        rows
+    });
+const parseCsv = (csvText, options)=>{
+    const errorState = createCsvErrorState();
+    const text = normaliseLineEndings(csvText);
+    if (0 === text.trim().length) {
+        addCsvFileError(errorState, "*", CsvParseErrorEnum.EMPTY_FILE, "CSV file is empty.");
+        return withError("CSV file is empty.", errorState.errorMap, errorState.errors);
+    }
+    const allLines = text.split("\n");
+    const nonEmptyLines = allLines.filter((line)=>line.trim().length > 0);
+    if (0 === nonEmptyLines.length) {
+        addCsvFileError(errorState, "*", CsvParseErrorEnum.EMPTY_FILE, "CSV file is empty.");
+        return withError("CSV file is empty.", errorState.errorMap, errorState.errors);
+    }
+    const firstLine = nonEmptyLines[0];
+    if (firstLine.includes(";") && !firstLine.includes(",")) {
+        addCsvFileError(errorState, "*", CsvParseErrorEnum.INVALID_SEPARATOR, "CSV must use comma separators.", firstLine);
+        return withError("CSV must use comma separators.", errorState.errorMap, errorState.errors);
+    }
+    if (options?.requireQuotedValues === true) {
+        nonEmptyLines.forEach((line, lineIndex)=>{
+            if (!quotedCsvLinePattern.test(line)) if (0 === lineIndex) addCsvFileError(errorState, "*", CsvParseErrorEnum.UNQUOTED_VALUE, "CSV values must be enclosed in double quotes.", line);
+            else addCsvRowError(errorState, lineIndex + CSV_HEADER_ROW_NUMBER, "*", CsvParseErrorEnum.UNQUOTED_VALUE, "CSV values must be enclosed in double quotes.", line);
+        });
+        if (hasCsvErrors(errorState.errorMap)) return withError("CSV values must be enclosed in double quotes.", errorState.errorMap, errorState.errors);
+    }
+    let records;
+    try {
+        records = parse(text, {
+            bom: true,
+            delimiter: ",",
+            escape: '"',
+            quote: '"',
+            relax_column_count: true,
+            skip_empty_lines: true
+        });
+    } catch (err) {
+        addCsvFileError(errorState, "*", CsvParseErrorEnum.INVALID_FORMAT, err instanceof Error ? err.message : "Invalid CSV format.");
+        return withError("Invalid CSV format.", errorState.errorMap, errorState.errors);
+    }
+    if (0 === records.length) {
+        addCsvFileError(errorState, "*", CsvParseErrorEnum.EMPTY_FILE, "CSV file is empty.");
+        return withError("CSV file is empty.", errorState.errorMap, errorState.errors);
+    }
+    const header = records[0].map((value)=>value.trim());
+    if (0 === header.length) addCsvFileError(errorState, "*", CsvParseErrorEnum.EMPTY_HEADER_COLUMN, "CSV header contains empty column names.");
+    header.forEach((col, columnIndex)=>{
+        if (0 === col.length) addCsvFileError(errorState, `column_${columnIndex + 1}`, CsvParseErrorEnum.EMPTY_HEADER_COLUMN, "CSV header contains empty column names.");
+    });
+    if (hasCsvErrors(errorState.errorMap)) return withError("CSV header contains empty column names.", errorState.errorMap, errorState.errors);
+    const duplicateHeader = header.find((col, idx)=>header.indexOf(col) !== idx);
+    if (duplicateHeader) {
+        addCsvFileError(errorState, duplicateHeader, CsvParseErrorEnum.DUPLICATE_HEADER_COLUMN, `CSV header contains duplicate column '${duplicateHeader}'.`, duplicateHeader);
+        return withError(`CSV header contains duplicate column '${duplicateHeader}'.`, errorState.errorMap, errorState.errors, header, []);
+    }
+    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 (hasCsvErrors(errorState.errorMap)) return withError("CSV rows must have the same number of columns as the header.", errorState.errorMap, errorState.errors, header, rows);
+    return {
+        header,
+        rows
+    };
+};
+export { CsvParseErrorEnum, parseCsv };