fuse-importer 0.1.4-testing → 0.1.6-testing

package/lib/esm/Importer/common/Spreadsheet/useFieldSorting.js

@@ -0,0 +1,81 @@
+import { get } from "lodash";
+import { DateTime } from "luxon";
+import { useImporterContext } from "../../contexts/ImporterContextProvider";
+export var useFieldSorting = function () {
+    var templateHeaders = useImporterContext().templateHeaders;
+    var getDefaultSortCompareFn = function (sortBy) {
+        return function (a, b) {
+            var aField = get(a, sortBy.field);
+            var bField = get(b, sortBy.field);
+            var fieldTypes = templateHeaders.reduce(function (acc, header) {
+                var type = header.column_type;
+                var pattern = header.pattern || null;
+                acc[header.internal_key] = { type: type, pattern: pattern };
+                return acc;
+            }, {});
+            var fieldType = fieldTypes[sortBy.field];
+            var isAEmpty = aField === undefined || aField === null || aField === "";
+            var isBEmpty = bField === undefined || bField === null || bField === "";
+            // sort empty values to the end
+            if (isAEmpty && isBEmpty) {
+                if (a._meta.rowIndex === b._meta.rowIndex)
+                    return 0;
+                return a._meta.rowIndex < b._meta.rowIndex ? -1 : 1;
+            }
+            if (isAEmpty)
+                return 1;
+            if (isBEmpty)
+                return -1;
+            if (fieldType && fieldType.type === "boolean") {
+                var aString = aField ? "true" : "false";
+                var bString = bField ? "true" : "false";
+                if (aString === bString) {
+                    if (a._meta.rowIndex === b._meta.rowIndex)
+                        return 0;
+                    return a._meta.rowIndex < b._meta.rowIndex ? -1 : 1;
+                }
+                if (aString === "true")
+                    return sortBy.direction === "asc" ? -1 : 1;
+                if (bString === "true")
+                    return sortBy.direction === "asc" ? 1 : -1;
+            }
+            else if (fieldType &&
+                (fieldType.type === "date" ||
+                    fieldType.type === "datetime" ||
+                    fieldType.type === "time")) {
+                var aDateTime = aField
+                    ? DateTime.fromFormat(aField, fieldType.pattern)
+                    : null;
+                var bDateTime = bField
+                    ? DateTime.fromFormat(bField, fieldType.pattern)
+                    : null;
+                // sort invalid date values to the end before empty values
+                if (aDateTime && !aDateTime.isValid)
+                    return 1;
+                if (bDateTime && !bDateTime.isValid)
+                    return -1;
+                if (aDateTime && bDateTime && aDateTime.equals(bDateTime)) {
+                    if (a._meta.rowIndex === b._meta.rowIndex)
+                        return 0;
+                    return a._meta.rowIndex < b._meta.rowIndex ? -1 : 1;
+                }
+                if (sortBy.direction === "asc") {
+                    return (aDateTime === null || aDateTime === void 0 ? void 0 : aDateTime.valueOf()) - (bDateTime === null || bDateTime === void 0 ? void 0 : bDateTime.valueOf());
+                }
+                return (bDateTime === null || bDateTime === void 0 ? void 0 : bDateTime.valueOf()) - (aDateTime === null || aDateTime === void 0 ? void 0 : aDateTime.valueOf());
+            }
+            else {
+                if (aField === bField) {
+                    if (a._meta.rowIndex === b._meta.rowIndex)
+                        return 0;
+                    return a._meta.rowIndex < b._meta.rowIndex ? -1 : 1;
+                }
+                if (sortBy.direction === "asc") {
+                    return aField > bField ? 1 : -1;
+                }
+                return aField < bField ? 1 : -1;
+            }
+        };
+    };
+    return { getDefaultSortCompareFn: getDefaultSortCompareFn };
+};

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

@@ -1,4 +1,5 @@
-import { Field, FieldValidation, OnValidateRecord, Record, ValidationErrors } from "../../../../types";
+import { MutableRefObject } from "react";
+import { DuplicateValuesCollection, Field, FieldValidation, OnValidateRecord, Record, ValidationErrors } from "../../../../types";
 import { FieldValidator } from "./validators";
 type SelectedValidator = {
     validator: FieldValidation;
@@ -13,10 +14,11 @@ type ValidateRecordArgs = {
     validatorsCache?: SelectedFieldValidators[];
     record: Record;
     fields: Field[];
-    data: Record[];
+    duplicateValues: MutableRefObject<DuplicateValuesCollection>;
+    backendErrors?: ValidationErrors;
 };
 export declare function selectValidatorsFor(fields: Field[]): SelectedFieldValidators[];
-export declare function validateRecord({ record, fields, data, onValidateRecord, validatorsCache, }: ValidateRecordArgs): Promise<{
+export declare function validateRecord({ record, fields, onValidateRecord, validatorsCache, duplicateValues, backendErrors, }: ValidateRecordArgs): Promise<{
     errors?: ValidationErrors;
     warnings?: ValidationErrors;
 }>;

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,5 +1,5 @@
 import React from "react";
-import { ColumnMapping, CustomAction, FormatRecord, ImporterOptions, Integration, OnSubmit, OnValidateRecord, Record, TemplateHeader } from "../../types";
+import { CustomAction, FormatRecord, ImporterOptions, Integration, OnSubmit, OnValidateRecord, Record, TemplateHeader } from "../../types";
 import { FuseApi } from "../common/FuseApi";
 export type HeaderMatchings = {
     [templateHeaderLabel: string]: string;
@@ -23,6 +23,7 @@ export type State = {
     initialRecords: Record[];
     enumFieldValueMatchings: EnumFieldValueMatchings;
     templateHeaders: TemplateHeader[];
+    userDynamicColumns: string[];
     templateHeaderMatchings: HeaderMatchings;
     uploadedDataHeaders: string[];
     matcherSubstep: number;
@@ -55,8 +56,9 @@ export type State = {
     isUsingManualImport: React.MutableRefObject<boolean>;
     resetImporterWhenUsingManualImport: () => void;
     manualDataImportSelected: () => void;
-    columnMappingsAttributes: ColumnMapping[];
     customActions: CustomAction[];
+    headerMappingsLoaded: boolean;
+    valueMappingsLoaded: boolean;
 };
 export type Props = {
     templateSlug: string;

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

@@ -71,22 +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(null), columnMappingsAttributes = _k[0], setColumnMappingsAttributes = _k[1];
-    var _l = useState(null), headersMappings = _l[0], setHeadersMappings = _l[1];
-    var _m = useState({
+    var _k = useState(null), headersMappings = _k[0], setHeadersMappings = _k[1];
+    var _l = useState({
         theme: theme,
         logoURL: null,
-    }), style = _m[0], setStyle = _m[1];
-    var _o = useState(null), templateHeaderMatchings = _o[0], setTemplateHeaderMatchings = _o[1];
-    var _p = useState(null), enumFieldValueMatchings = _p[0], setEnumFieldValueMatchings = _p[1];
-    var _q = useState(null), uploadedDataEnumFieldValues = _q[0], setUploadedDataEnumFieldValues = _q[1];
-    var _r = useState([]), selectedRows = _r[0], setSelectedRows = _r[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 _s = useState(0), headerRowIndex = _s[0], setHeaderRowIndex = _s[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)
@@ -101,6 +130,79 @@ 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 = {};
@@ -150,10 +252,11 @@ export var ImporterContextProvider = function (_a) {
             });
         });
         setUploadedDataEnumFieldValues(_uploadedDataEnumFieldValues);
+        loadValueMappings(_uploadedDataEnumFieldValues);
     }, [templateHeaderMatchings, uploadedDataHeaders]);
     useEffect(function () {
         (function () { return __awaiter(void 0, void 0, void 0, function () {
-            var _a, organization_1, columns_1, importer_style_preferences, integrations_1, preview_first_time, column_mappings_attributes, error_1, errorMsg;
+            var _a, organization_1, columns_1, importer_style_preferences, integrations_1, preview_first_time, error_1, errorMsg;
             var _b, _c;
             return __generator(this, function (_d) {
                 switch (_d.label) {
@@ -161,7 +264,7 @@ export var ImporterContextProvider = function (_a) {
                         _d.trys.push([0, 2, , 3]);
                         return [4 /*yield*/, fuseApi.get("/api/v1/importer/templates/".concat(templateSlug))];
                     case 1:
-                        _a = (_d.sent()).data, organization_1 = _a.organization, columns_1 = _a.columns, importer_style_preferences = _a.importer_style_preferences, integrations_1 = _a.integrations, preview_first_time = _a.preview_first_time, column_mappings_attributes = _a.column_mappings_attributes;
+                        _a = (_d.sent()).data, organization_1 = _a.organization, columns_1 = _a.columns, importer_style_preferences = _a.importer_style_preferences, integrations_1 = _a.integrations, preview_first_time = _a.preview_first_time;
                         setOrganization(organization_1);
                         setTemplateHeaders(function () {
                             // user has created dynamic columns
@@ -178,7 +281,6 @@ export var ImporterContextProvider = function (_a) {
                         });
                         setIntegrations(integrations_1);
                         setPreviewFirstTime(preview_first_time);
-                        setColumnMappingsAttributes(column_mappings_attributes);
                         if (organization_1.plan && organization_1.plan.allow_style_customization) {
                             setStyle(getCustomTheme(importer_style_preferences));
                         }
@@ -197,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);
@@ -216,6 +322,7 @@ export var ImporterContextProvider = function (_a) {
         initialRecords: initialRecords,
         currentStepIndex: currentStepIndex,
         templateHeaders: templateHeaders,
+        userDynamicColumns: userDynamicColumns,
         enumFieldValueMatchings: enumFieldValueMatchings,
         templateHeaderMatchings: templateHeaderMatchings,
         uploadedDataEnumFieldValues: uploadedDataEnumFieldValues,
@@ -231,7 +338,6 @@ export var ImporterContextProvider = function (_a) {
         theme: style.theme,
         logoURL: style.logoURL,
         integrations: integrations,
-        columnMappingsAttributes: columnMappingsAttributes,
         previewFirstTime: previewFirstTime,
         headerRowIndex: headerRowIndex,
         setHeaderRowIndex: setHeaderRowIndex,
@@ -253,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.d.ts

@@ -7,6 +7,7 @@ export declare const addEmptyRows: (data: Record[], fields: Field[]) => (Record
     };
 })[];
 export declare const addMeta: (record: any, index: number, uploadedRow?: any, transformedRow?: TransformedRecord) => Record;
+export declare const calculatePossibleDateFormats: (fieldsWithDateTransformations: Field[], sample: Record[]) => string[];
 export declare const recordListToDataSet: (data: Record[], fields: Field[]) => RecordDataSet;
 type transformToRecordsArgs = {
     templateHeaderMatchings: HeaderMatchings;

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

@@ -18,13 +18,16 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
+import { datesDateTimesAndTimesTransformations } from "../../Importer/common/Spreadsheet/transformation/transformators";
 import { transformRecord } from "../../Importer/common/Spreadsheet/transformation";
 import { FieldTypes, } from "../../types";
 import { parseValue } from "../common/Spreadsheet/common";
+import { DateTime } from "luxon";
+import { allowedPatternValues } from "../../common/datePatterns";
+import _ from "lodash";
 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 +46,30 @@ 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 calculatePossibleDateFormats = function (fieldsWithDateTransformations, sample) {
+    var possibleDateFormats = [];
+    for (var _i = 0, sample_1 = sample; _i < sample_1.length; _i++) {
+        var record = sample_1[_i];
+        for (var _a = 0, fieldsWithDateTransformations_1 = fieldsWithDateTransformations; _a < fieldsWithDateTransformations_1.length; _a++) {
+            var field = fieldsWithDateTransformations_1[_a];
+            var value = record[field.name];
+            if (!value)
+                continue;
+            for (var i = 0; i < allowedPatternValues.length; i++) {
+                var format = allowedPatternValues[i];
+                try {
+                    var currentDate = DateTime.fromFormat(value, format);
+                    if (currentDate.isValid) {
+                        possibleDateFormats.push(format);
+                    }
+                }
+                catch (e) { }
+            }
+        }
+    }
+    return Array.from(new Set(possibleDateFormats));
 };
 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; });
@@ -51,12 +77,22 @@ export var recordListToDataSet = function (data, fields) {
     if (data.length < MINIMUM_ROW_COUNT) {
         initialData = addEmptyRows(data, fields);
     }
+    var fieldsWithDateTransformations = fieldWithTransformations.filter(function (field) {
+        return field.transformations.some(function (t) {
+            return Object.keys(datesDateTimesAndTimesTransformations).includes(t.transformation_type);
+        });
+    });
+    var possibleDateFormats = [];
+    if (fieldsWithDateTransformations.length > 0) {
+        possibleDateFormats.push.apply(possibleDateFormats, calculatePossibleDateFormats(fieldsWithDateTransformations, _.sampleSize(initialData, 100)));
+    }
     return initialData.reduce(function (dataSet, record, i) {
         var transformedRecord = null;
         if (fieldWithTransformations.length > 0) {
             transformedRecord = transformRecord({
                 record: record,
                 fields: fieldWithTransformations,
+                possibleDateFormats: possibleDateFormats,
             });
         }
         var recordWithMeta = addMeta(record, i, undefined, transformedRecord);
@@ -119,7 +155,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 +168,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;
+};