fuse-importer 0.1.3-testing → 0.1.5-testing

package/lib/esm/Importer/common/Spreadsheet/validation/index.js

@@ -89,9 +89,9 @@ function safeCallOnValidateRecord(_a) {
     });
 }
 function safeCallValidator(_a) {
-    var field = _a.field, record = _a.record, validator = _a.validator, validatorFunction = _a.validatorFunction, data = _a.data;
+    var field = _a.field, record = _a.record, validator = _a.validator, validatorFunction = _a.validatorFunction, duplicateValues = _a.duplicateValues;
     try {
-        return validatorFunction(field, record[field.name], validator, data);
+        return validatorFunction(field, record[field.name], validator, duplicateValues);
     }
     catch (e) {
         console.error("Validator ".concat(validator === null || validator === void 0 ? void 0 : validator.validation_type, " for field ").concat(JSON.stringify(field), " and value ").concat(record[field.name], " failed."), e);
@@ -102,7 +102,7 @@ function mergeErrorsAndWarnings(currentErrors, errors) {
     return __assign(__assign({}, currentErrors), { errors: __assign(__assign({}, (currentErrors.errors || {})), errors), warnings: __assign({}, (currentErrors.warnings || {})) });
 }
 function runValidatorsFor(_a) {
-    var record = _a.record, data = _a.data, validators = _a.validators;
+    var record = _a.record, validators = _a.validators, duplicateValues = _a.duplicateValues;
     return validators.reduce(function (currentErrors, _a) {
         var field = _a.field, validators = _a.validators;
         var errors = {};
@@ -115,8 +115,8 @@ function runValidatorsFor(_a) {
                 field: field,
                 record: record,
                 validator: validator,
-                data: data,
                 validatorFunction: validatorFunction,
+                duplicateValues: duplicateValues,
             });
             if (error) {
                 errors[field.name] = error;
@@ -159,29 +159,25 @@ export function selectValidatorsFor(fields) {
     });
 }
 export function validateRecord(_a) {
-    var _b, _c;
-    var record = _a.record, fields = _a.fields, data = _a.data, onValidateRecord = _a.onValidateRecord, validatorsCache = _a.validatorsCache;
+    var record = _a.record, fields = _a.fields, onValidateRecord = _a.onValidateRecord, validatorsCache = _a.validatorsCache, duplicateValues = _a.duplicateValues, backendErrors = _a.backendErrors;
     return __awaiter(this, void 0, void 0, function () {
-        var isTouched, backendErrors, hasBackendErrors, validators, _d, validatorErrors, validatorWarnings, errors, warnings, _e, onValidateRecordErrors, onValidateRecordWarnings;
-        return __generator(this, function (_f) {
-            switch (_f.label) {
+        var validators, _b, validatorErrors, validatorWarnings, errors, warnings, _c, onValidateRecordErrors, onValidateRecordWarnings;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
                 case 0:
                     if (isRecordEmpty(record, fields)) {
                         //TODO: Check this logic because this can skip the validation of touched rows because all fields are empty
                         return [2 /*return*/, { errors: {}, warnings: {} }];
                     }
-                    isTouched = (_b = record._meta) === null || _b === void 0 ? void 0 : _b.touched;
-                    backendErrors = ((_c = record._meta) === null || _c === void 0 ? void 0 : _c.backendErrors) || {};
-                    hasBackendErrors = Object.keys(backendErrors).length > 0;
-                    if (!isTouched && hasBackendErrors) {
+                    if (backendErrors) {
                         return [2 /*return*/, { errors: backendErrors, warnings: {} }];
                     }
                     validators = validatorsCache !== null && validatorsCache !== void 0 ? validatorsCache : selectValidatorsFor(fields);
-                    _d = runValidatorsFor({
+                    _b = runValidatorsFor({
                         record: record,
-                        data: data,
                         validators: validators,
-                    }), validatorErrors = _d.errors, validatorWarnings = _d.warnings;
+                        duplicateValues: duplicateValues,
+                    }), validatorErrors = _b.errors, validatorWarnings = _b.warnings;
                     errors = ignoreNullOrUndefinedKeyValues(validatorErrors);
                     warnings = ignoreNullOrUndefinedKeyValues(validatorWarnings);
                     if (!!isNullOrUndefined(onValidateRecord)) return [3 /*break*/, 2];
@@ -190,7 +186,7 @@ export function validateRecord(_a) {
                             record: record,
                         })];
                 case 1:
-                    _e = _f.sent(), onValidateRecordErrors = _e.errors, onValidateRecordWarnings = _e.warnings;
+                    _c = _d.sent(), onValidateRecordErrors = _c.errors, onValidateRecordWarnings = _c.warnings;
                     return [2 /*return*/, {
                             errors: __assign(__assign({}, errors), onValidateRecordErrors),
                             warnings: __assign(__assign({}, warnings), onValidateRecordWarnings),

package/lib/esm/Importer/common/Spreadsheet/validation/validators.d.ts

@@ -1,5 +1,6 @@
-import { Field, FieldValidation, Record } from "../../../../types";
-export type FieldValidator = (field: Field, fieldValue: any, validation?: FieldValidation, data?: Record[], customErrorMessage?: string) => null | string;
+import { DuplicateValuesCollection, Field, FieldValidation } from "../../../../types";
+import { MutableRefObject } from "react";
+export type FieldValidator = (field: Field, fieldValue: any, validation?: FieldValidation, duplicateValues?: MutableRefObject<DuplicateValuesCollection>, customErrorMessage?: string) => null | string;
 export type FieldValidations = Partial<{
     [key: string]: FieldValidator;
 }>;

package/lib/esm/Importer/common/Spreadsheet/validation/validators.js

@@ -85,7 +85,9 @@ export var fieldValidations = {
         if (!isNullOrUndefined(field.pattern) &&
             !isNullOrUndefined(fieldValue) &&
             !DateTime.fromFormat(fieldValue, field.pattern).isValid) {
-            var randomDate = DateTime.fromISO("1990-01-15T14:35:55.150");
+            var randomDate = DateTime.fromISO("1990-01-15T14:35:55.150", {
+                zone: "utc",
+            });
             var transformedValue = randomDate === null || randomDate === void 0 ? void 0 : randomDate.toFormat(field.pattern);
             var defaultMessage = "".concat(field.label, " must match the pattern ").concat(field.pattern);
             return transformedValue
@@ -93,18 +95,25 @@ export var fieldValidations = {
                 : defaultMessage;
         }
     },
-    unique_case_sensitive: function (field, fieldValue, validator, data) {
+    unique_case_sensitive: function (field, fieldValue, validator, duplicateValues) {
         var _a;
-        if (!isNullOrUndefined(fieldValue) && !isNullOrUndefined(data)) {
-            var isDuplicated = data.filter(function (d) { return d[field.name] === fieldValue; }).length > 1;
+        if (!isNullOrUndefined(fieldValue) &&
+            !isNullOrUndefined(duplicateValues.current)) {
+            var isDuplicated = duplicateValues.current[field.name] &&
+                duplicateValues.current[field.name][fieldValue] &&
+                duplicateValues.current[field.name][fieldValue].length > 1;
             var message = (_a = validator.message) !== null && _a !== void 0 ? _a : "".concat(field.label, " must be unique case sensitive");
             return isDuplicated ? message : undefined;
         }
     },
-    unique_case_insensitive: function (field, fieldValue, validator, data) {
+    unique_case_insensitive: function (field, fieldValue, validator, duplicateValues) {
         var _a;
-        if (!isNullOrUndefined(fieldValue) && !isNullOrUndefined(data)) {
-            var isDuplicated = data.filter(function (d) { var _a; return ((_a = d[field.name]) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === fieldValue.toLowerCase(); }).length > 1;
+        if (!isNullOrUndefined(fieldValue) &&
+            !isNullOrUndefined(duplicateValues.current)) {
+            var isDuplicated = duplicateValues.current[field.name] &&
+                duplicateValues.current[field.name][fieldValue.toLowerCase()] &&
+                duplicateValues.current[field.name][fieldValue.toLowerCase()].length >
+                    1;
             var message = (_a = validator.message) !== null && _a !== void 0 ? _a : "".concat(field.label, " must be unique case insensitive");
             return isDuplicated ? message : undefined;
         }

package/lib/esm/Importer/contexts/ImporterContextProvider.d.ts

@@ -1,8 +1,6 @@
-import Fuse from "fuse.js";
 import React from "react";
 import { CustomAction, FormatRecord, ImporterOptions, Integration, OnSubmit, OnValidateRecord, Record, TemplateHeader } from "../../types";
 import { FuseApi } from "../common/FuseApi";
-export declare const fusejsOptions: Fuse.IFuseOptions<string>;
 export type HeaderMatchings = {
     [templateHeaderLabel: string]: string;
 };
@@ -25,6 +23,7 @@ export type State = {
     initialRecords: Record[];
     enumFieldValueMatchings: EnumFieldValueMatchings;
     templateHeaders: TemplateHeader[];
+    userDynamicColumns: string[];
     templateHeaderMatchings: HeaderMatchings;
     uploadedDataHeaders: string[];
     matcherSubstep: number;
@@ -46,6 +45,7 @@ export type State = {
     setCurrentStepIndex: React.Dispatch<number>;
     setEnumFieldValueMatchings: React.Dispatch<React.SetStateAction<EnumFieldValueMatchings>>;
     setUploadedData: React.Dispatch<any[]>;
+    setHeadersMappings: React.Dispatch<any[]>;
     setTemplateHeaderMatchings: React.Dispatch<React.SetStateAction<HeaderMatchings>>;
     setPreviewFirstTime: React.Dispatch<boolean>;
     formatRecord: FormatRecord;
@@ -57,6 +57,8 @@ export type State = {
     resetImporterWhenUsingManualImport: () => void;
     manualDataImportSelected: () => void;
     customActions: CustomAction[];
+    headerMappingsLoaded: boolean;
+    valueMappingsLoaded: boolean;
 };
 export type Props = {
     templateSlug: string;

package/lib/esm/Importer/contexts/ImporterContextProvider.js

@@ -55,16 +55,11 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 import { jsx as _jsx } from "react/jsx-runtime";
-import Fuse from "fuse.js";
 import { createContext, useContext, useEffect, useMemo, useRef, useState, } from "react";
 import { FieldTypes, } from "../../types";
 import { FuseApi } from "../common/FuseApi";
 import { getCustomTheme, theme } from "../common/theme";
 import { getColumnType, verifyDuplicateValue } from "../common/utils";
-export var fusejsOptions = {
-    includeScore: true,
-    threshold: 0.35,
-};
 var ImporterContext = createContext({});
 export var ImporterContextProvider = function (_a) {
     var templateSlug = _a.templateSlug, initialRecords = _a.initialRecords, apiToken = _a.apiToken, children = _a.children, options = _a.options, onSubmit = _a.onSubmit, onClose = _a.onClose, formatRecord = _a.formatRecord, onValidateRecord = _a.onValidateRecord, dynamicColumns = _a.dynamicColumns, customActions = _a.customActions;
@@ -76,20 +71,51 @@ export var ImporterContextProvider = function (_a) {
     var _g = useState(null), uploadedData = _g[0], setUploadedData = _g[1];
     var _h = useState(null), organization = _h[0], setOrganization = _h[1];
     var _j = useState(null), previewFirstTime = _j[0], setPreviewFirstTime = _j[1];
-    var _k = useState({
+    var _k = useState(null), headersMappings = _k[0], setHeadersMappings = _k[1];
+    var _l = useState({
         theme: theme,
         logoURL: null,
-    }), style = _k[0], setStyle = _k[1];
-    var _l = useState(null), templateHeaderMatchings = _l[0], setTemplateHeaderMatchings = _l[1];
-    var _m = useState(null), enumFieldValueMatchings = _m[0], setEnumFieldValueMatchings = _m[1];
-    var _o = useState(null), uploadedDataEnumFieldValues = _o[0], setUploadedDataEnumFieldValues = _o[1];
-    var _p = useState([]), selectedRows = _p[0], setSelectedRows = _p[1];
+    }), style = _l[0], setStyle = _l[1];
+    var _m = useState(null), templateHeaderMatchings = _m[0], setTemplateHeaderMatchings = _m[1];
+    var _o = useState(null), enumFieldValueMatchings = _o[0], setEnumFieldValueMatchings = _o[1];
+    var _p = useState(null), uploadedDataEnumFieldValues = _p[0], setUploadedDataEnumFieldValues = _p[1];
+    var _q = useState([]), selectedRows = _q[0], setSelectedRows = _q[1];
     var isUsingManualImport = useRef(false);
-    var _q = useState(0), headerRowIndex = _q[0], setHeaderRowIndex = _q[1];
+    var _r = useState(0), headerRowIndex = _r[0], setHeaderRowIndex = _r[1];
+    var _s = useState(false), headerMappingsLoaded = _s[0], setHeaderMappingsLoaded = _s[1];
+    var _t = useState(false), valueMappingsLoaded = _t[0], setValueMappingsLoaded = _t[1];
     var fuseApi = useMemo(function () { return new FuseApi(options.env, apiToken); }, [
         options.env,
         apiToken,
     ]);
+    var fetchColumnMappings = function (userDynamicColumns) { return __awaiter(void 0, void 0, void 0, function () {
+        var mappings;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, fuseApi.post("/api/v1/importer/templates/".concat(templateSlug, "/column_mappings"), {
+                        file_headers: uploadedDataHeaders,
+                        dynamic_columns: userDynamicColumns,
+                    })];
+                case 1:
+                    mappings = (_a.sent()).data.mappings;
+                    return [2 /*return*/, mappings];
+            }
+        });
+    }); };
+    var fetchValueMappings = function (_uploadedDataEnumFieldValues, userDynamicValues) { return __awaiter(void 0, void 0, void 0, function () {
+        var mappings;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, fuseApi.post("/api/v1/importer/templates/".concat(templateSlug, "/value_mappings"), {
+                        file_values: _uploadedDataEnumFieldValues,
+                        dynamic_values: userDynamicValues,
+                    })];
+                case 1:
+                    mappings = (_a.sent()).data.mappings;
+                    return [2 /*return*/, mappings];
+            }
+        });
+    }); };
     var uploadedDataHeaders = useMemo(function () {
         var _a;
         if (!uploadedData)
@@ -104,21 +130,105 @@ export var ImporterContextProvider = function (_a) {
             return typeof ud === "number" ? ud.toString() : ud;
         });
     }, [uploadedData, headerRowIndex]);
+    var userDynamicColumns = dynamicColumns.map(function (value) { return value.label; });
+    // use the API to match selected headers to the template
+    var loadHeaderMappings = function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mappings, e_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    setHeaderMappingsLoaded(false);
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, fetchColumnMappings(userDynamicColumns)];
+                case 2:
+                    mappings = _a.sent();
+                    setHeadersMappings(mappings);
+                    return [3 /*break*/, 4];
+                case 3:
+                    e_1 = _a.sent();
+                    setHeadersMappings([]);
+                    console.error("Error occurred while fetching header mappings", e_1);
+                    return [3 /*break*/, 4];
+                case 4:
+                    setHeaderMappingsLoaded(true);
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+    useEffect(function () {
+        (function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (uploadedDataHeaders) {
+                    loadHeaderMappings();
+                }
+                return [2 /*return*/];
+            });
+        }); })();
+    }, [uploadedDataHeaders]);
+    // Values mappings for enum columns
+    var loadValueMappings = function (_uploadedDataEnumFieldValues) { return __awaiter(void 0, void 0, void 0, function () {
+        var dynamicValues, mappings, e_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    setValueMappingsLoaded(false);
+                    if (!(!!_uploadedDataEnumFieldValues &&
+                        Object.keys(_uploadedDataEnumFieldValues).length > 0)) return [3 /*break*/, 4];
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    dynamicValues = userDynamicColumns.reduce(function (acc, column) {
+                        var _a;
+                        var values = (_a = templateHeaders.find(function (header) { return header.label === column; })) === null || _a === void 0 ? void 0 : _a.values;
+                        if (values) {
+                            acc[column] = values;
+                        }
+                        return acc;
+                    }, {});
+                    return [4 /*yield*/, fetchValueMappings(_uploadedDataEnumFieldValues, dynamicValues)];
+                case 2:
+                    mappings = _a.sent();
+                    setEnumFieldValueMatchings(mappings);
+                    return [3 /*break*/, 4];
+                case 3:
+                    e_2 = _a.sent();
+                    setEnumFieldValueMatchings({});
+                    console.error("Error occurred while fetching value mappings", e_2);
+                    return [3 /*break*/, 4];
+                case 4:
+                    setValueMappingsLoaded(true);
+                    return [2 /*return*/];
+            }
+        });
+    }); };
     useEffect(function () {
         var setHeadersFromDataset = function () {
             var _templateHeaderMatchings = {};
-            var fuse = new Fuse(uploadedDataHeaders, fusejsOptions);
             templateHeaders.forEach(function (templateHeader, _index) {
-                var _a;
-                var fuseResults = fuse.search(templateHeader.label);
-                _templateHeaderMatchings[templateHeader.label] = (_a = fuseResults[0]) === null || _a === void 0 ? void 0 : _a.item;
+                var mappedHeader = headersMappings.find(function (headerMapping) {
+                    var matchedColumn = Object.values(headerMapping)[0];
+                    if (matchedColumn) {
+                        return (matchedColumn.toLowerCase() === templateHeader.label.toLowerCase());
+                    }
+                    else {
+                        return false;
+                    }
+                });
+                if (mappedHeader) {
+                    _templateHeaderMatchings[templateHeader.label] = Object.keys(mappedHeader)[0];
+                }
+                else {
+                    _templateHeaderMatchings[templateHeader.label] = null;
+                }
             });
             setTemplateHeaderMatchings(_templateHeaderMatchings);
         };
-        if (uploadedDataHeaders) {
+        if (uploadedDataHeaders && headersMappings) {
             setHeadersFromDataset();
         }
-    }, [uploadedDataHeaders]);
+    }, [uploadedDataHeaders, headersMappings]);
     useEffect(function () {
         if (!templateHeaderMatchings || !uploadedDataHeaders)
             return;
@@ -142,6 +252,7 @@ export var ImporterContextProvider = function (_a) {
             });
         });
         setUploadedDataEnumFieldValues(_uploadedDataEnumFieldValues);
+        loadValueMappings(_uploadedDataEnumFieldValues);
     }, [templateHeaderMatchings, uploadedDataHeaders]);
     useEffect(function () {
         (function () { return __awaiter(void 0, void 0, void 0, function () {
@@ -188,6 +299,10 @@ export var ImporterContextProvider = function (_a) {
     var resetImport = function () {
         setUploadedData(null);
         setTemplateHeaderMatchings(null);
+        setHeadersMappings(null);
+        setEnumFieldValueMatchings(null);
+        setSelectedRows([]);
+        setHeaderRowIndex(0);
     };
     var resetImporterWhenUsingManualImport = function () {
         setCurrentStepIndex(0);
@@ -207,6 +322,7 @@ export var ImporterContextProvider = function (_a) {
         initialRecords: initialRecords,
         currentStepIndex: currentStepIndex,
         templateHeaders: templateHeaders,
+        userDynamicColumns: userDynamicColumns,
         enumFieldValueMatchings: enumFieldValueMatchings,
         templateHeaderMatchings: templateHeaderMatchings,
         uploadedDataEnumFieldValues: uploadedDataEnumFieldValues,
@@ -226,6 +342,7 @@ export var ImporterContextProvider = function (_a) {
         headerRowIndex: headerRowIndex,
         setHeaderRowIndex: setHeaderRowIndex,
         setUploadedData: setUploadedData,
+        setHeadersMappings: setHeadersMappings,
         formatRecord: formatRecord,
         setCurrentStepIndex: setCurrentStepIndex,
         setEnumFieldValueMatchings: setEnumFieldValueMatchings,
@@ -242,6 +359,8 @@ export var ImporterContextProvider = function (_a) {
         resetImporterWhenUsingManualImport: resetImporterWhenUsingManualImport,
         manualDataImportSelected: manualDataImportSelected,
         customActions: customActions,
+        headerMappingsLoaded: headerMappingsLoaded,
+        valueMappingsLoaded: valueMappingsLoaded,
     };
     return (_jsx(ImporterContext.Provider, __assign({ value: value }, { children: children })));
 };

package/lib/esm/Importer/data/index.js

@@ -23,8 +23,7 @@ import { FieldTypes, } from "../../types";
 import { parseValue } from "../common/Spreadsheet/common";
 var MINIMUM_ROW_COUNT = 20;
 var getRowId = function (index) {
-    var uniqueTimestamp = new Date().getTime();
-    return "r".concat(index, "-").concat(uniqueTimestamp);
+    return index.toString();
 };
 export var addEmptyRows = function (data, fields) {
     var emptyRecord = fields.reduce(function (obj, f) {
@@ -43,7 +42,7 @@ export var addMeta = function (record, index, uploadedRow, transformedRow) {
     if (transformedRow === void 0) { transformedRow = null; }
     var rId = getRowId(index);
     var meta = (_a = record._meta) !== null && _a !== void 0 ? _a : {};
-    return __assign(__assign({}, record), { _meta: __assign(__assign({}, meta), { id: rId, rowIndex: index, touched: false, uploadedRow: uploadedRow, transformedRow: __assign(__assign({}, meta.transformedRow), transformedRow) }) });
+    return __assign(__assign({}, record), { _meta: __assign(__assign({}, meta), { id: rId, rowIndex: index, uploadedRow: uploadedRow, transformedRow: __assign(__assign({}, meta.transformedRow), transformedRow) }) });
 };
 export var recordListToDataSet = function (data, fields) {
     var fieldWithTransformations = fields.filter(function (field) { var _a; return ((_a = field === null || field === void 0 ? void 0 : field.transformations) === null || _a === void 0 ? void 0 : _a.length) > 0; });
@@ -119,7 +118,8 @@ export var transformToRecords = function (_a) {
 export var getPreviewDataSet = function (_a) {
     var uploadedData = _a.uploadedData;
     var rowLen = 0;
-    for (var i = 0; i < uploadedData.length; i++)
+    var previewSize = Math.min(100, uploadedData.length);
+    for (var i = 0; i < previewSize; i++)
         rowLen = Math.max(rowLen, uploadedData[i].length);
     var fields = new Array(rowLen).fill(null).map(function (_, i) {
         var key = String.fromCharCode(65 + i);
@@ -131,7 +131,9 @@ export var getPreviewDataSet = function (_a) {
         };
     });
     var getInitialDataSet = function () {
-        var data = uploadedData.map(function (row, index) {
+        var data = uploadedData
+            .slice(0, previewSize)
+            .map(function (row, index) {
             var entry = addMeta({}, index);
             fields.forEach(function (field, index) {
                 entry[field.name] = row[index];

package/lib/esm/Importer/hooks/useExportDataToFile.d.ts

@@ -0,0 +1,5 @@
+import { RecordDataSet } from "../../types";
+import { ExportDataType } from "../Review/ReviewContextProvider";
+export declare const useExportDataToFile: () => {
+    onExport: (dataSet: RecordDataSet, dataType: ExportDataType) => void;
+};

package/lib/esm/Importer/hooks/useExportDataToFile.js

@@ -0,0 +1,54 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { useCallback } from "react";
+import Papa from "papaparse";
+import { useImporterContext } from "../contexts/ImporterContextProvider";
+function downloadCsv(data, fileName) {
+    var blob = new Blob([data], { type: "text/csv;charset=utf-8;" });
+    var link = document.createElement("a");
+    link.href = URL.createObjectURL(blob);
+    link.download = fileName;
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+}
+function csvExport(data) {
+    var valuesWithQuotesWhenNecessary = data.map(function (obj) {
+        var newObj = {};
+        for (var key in obj) {
+            var value = obj[key];
+            newObj[key] =
+                typeof value === "string" && value.includes(",") ? "\"".concat(value, "\"") : value;
+        }
+        return newObj;
+    });
+    var csv = Papa.unparse(valuesWithQuotesWhenNecessary);
+    downloadCsv(csv, "export.csv");
+}
+export var useExportDataToFile = function () {
+    var selectedRows = useImporterContext().selectedRows;
+    var onExport = useCallback(function (dataSet, dataType) {
+        if (!dataSet)
+            return;
+        var dataSetValues = Object.values(dataSet);
+        if (dataType === "csv") {
+            var valuesWithoutMeta = dataSetValues.map(function (_a) {
+                var _meta = _a._meta, rest = __rest(_a, ["_meta"]);
+                return rest;
+            });
+            csvExport(valuesWithoutMeta);
+        }
+    }, [selectedRows]);
+    return {
+        onExport: onExport,
+    };
+};

package/lib/esm/Importer/hooks/useSubmitToServer.d.ts

@@ -0,0 +1,7 @@
+import { AppResponse, RecordDataSet } from "../../types";
+export declare const useSubmitToServer: () => {
+    appResponse: AppResponse;
+    isSubmitting: boolean;
+    onSubmitToServer: (dataSet: RecordDataSet, afterSubmitCallback: (dataSet: RecordDataSet) => void) => Promise<void>;
+    importWasSuccessful: boolean;
+};