fuse-importer 0.1.7-testing → 0.2.0-testing

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

@@ -1,15 +1,11 @@
-import { datesDateTimesAndTimesTransformations, fieldTransformations, } from "./transformators";
-var runTransformation = function (fieldValue, transformation, field, possibleDateFormats) {
+import { fieldTransformations } from "./transformators";
+var runTransformation = function (fieldValue, transformation, field) {
     var transformationType = transformation.transformation_type;
     var transformerFunction = fieldTransformations[transformationType];
-    if (Object.keys(datesDateTimesAndTimesTransformations).includes(transformationType)) {
-        var dateTimeTransformFunction = transformerFunction;
-        return dateTimeTransformFunction(fieldValue, transformation, field, possibleDateFormats);
-    }
     return transformerFunction(fieldValue, transformation, field);
 };
 export var transformRecord = function (_a) {
-    var record = _a.record, fields = _a.fields, possibleDateFormats = _a.possibleDateFormats;
+    var record = _a.record, fields = _a.fields;
     var transformedRecords = {};
     for (var _i = 0, fields_1 = fields; _i < fields_1.length; _i++) {
         var currentField = fields_1[_i];
@@ -27,7 +23,7 @@ export var transformRecord = function (_a) {
         var fieldWasTransformed = false;
         for (var i = 0; i < fieldTransformations_1.length; i++) {
             var currentTransformation = fieldTransformations_1[i];
-            var transformed = runTransformation(transformedField.transformed, currentTransformation, currentField, possibleDateFormats);
+            var transformed = runTransformation(transformedField.transformed, currentTransformation, currentField);
             if (transformed.transformationWasNeeded) {
                 fieldWasTransformed = true;
                 transformedField = {

package/lib/esm/Importer/common/Spreadsheet/transformation/transformators/dateTimeAutoformatUtils.d.ts

@@ -0,0 +1,5 @@
+import { DateTime } from "luxon";
+export declare const parseDateFromUserInput: (userInput: string) => DateTime | null;
+export declare const parseTimeFromUserInput: (input: any) => DateTime;
+export declare const parseTimeFromDateTimeorTimeInput: (userInput: any) => DateTime;
+export declare const parseDateTimeFromUserInput: (userInput: any) => DateTime;

package/lib/esm/Importer/common/Spreadsheet/transformation/transformators/dateTimeAutoformatUtils.js

@@ -0,0 +1,231 @@
+import { DateTime } from "luxon";
+var MONTH_NAMES = [
+    "january",
+    "february",
+    "march",
+    "april",
+    "may",
+    "june",
+    "july",
+    "august",
+    "september",
+    "october",
+    "november",
+    "december",
+];
+var MONTH_ABBREVIATIONS = [
+    "jan",
+    "feb",
+    "mar",
+    "apr",
+    "may",
+    "jun",
+    "jul",
+    "aug",
+    "sep",
+    "oct",
+    "nov",
+    "dec",
+];
+var DAY_NAMES = [
+    "sunday",
+    "monday",
+    "tuesday",
+    "wednesday",
+    "thursday",
+    "friday",
+    "saturday",
+];
+var DAY_ABBREVIATIONS = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+var tryParseCommonDateFormats = function (input) {
+    var _a, _b, _c;
+    var trimmedInput = input.trim();
+    var len = trimmedInput.length;
+    if (len < 6 || len > 10)
+        return null;
+    var parts = input.split(/[-/.]/);
+    if (parts.length !== 3)
+        return null;
+    var _d = parts.map(Number), first = _d[0], second = _d[1], third = _d[2];
+    var year, month, day;
+    if (parts[2].length === 4) {
+        _a = [first, second, third], month = _a[0], day = _a[1], year = _a[2];
+    }
+    else if (parts[0].length === 4) {
+        _b = [first, second, third], year = _b[0], month = _b[1], day = _b[2];
+    }
+    else if (parts[2].length === 2) {
+        // Handles the case where year is two digits
+        _c = [first, second, third], month = _c[0], day = _c[1], year = _c[2];
+        year += year < 50 ? 2000 : 1900; // Convert to 4 digits
+    }
+    else {
+        return null; // Unknown format
+    }
+    if (year >= 0 && month >= 1 && month <= 12 && day >= 1 && day <= 31) {
+        var dt = DateTime.fromObject({ day: day, month: month, year: year });
+        return dt.isValid ? dt : null;
+    }
+    return null;
+};
+export var parseDateFromUserInput = function (userInput) {
+    var datePart = userInput;
+    var hasTimePart = userInput.indexOf(":") !== -1 && userInput.split(":").length > 1;
+    if (hasTimePart) {
+        var parts = userInput.trim().split(" ");
+        datePart =
+            parts.length === 2
+                ? parts[0].indexOf(":") !== -1
+                    ? parts[1]
+                    : parts[0]
+                : userInput;
+    }
+    var commonFormatResult = tryParseCommonDateFormats(datePart);
+    if (commonFormatResult)
+        return commonFormatResult;
+    var cleanedInput = datePart
+        .trim()
+        .split(/[\s;|:.\/-]+/)
+        .filter(Boolean)
+        .map(function (word) { return word.toLowerCase(); });
+    var possibleDay = null, possibleMonth = null, possibleYear = null;
+    for (var _i = 0, cleanedInput_1 = cleanedInput; _i < cleanedInput_1.length; _i++) {
+        var word = cleanedInput_1[_i];
+        if (DAY_NAMES.includes(word) || DAY_ABBREVIATIONS.includes(word))
+            continue;
+        var num = parseInt(word, 10);
+        if (!possibleDay && num > 0 && num <= 31) {
+            possibleDay = num;
+            continue;
+        }
+        if (!possibleMonth) {
+            var monthIndex = MONTH_NAMES.indexOf(word);
+            if (monthIndex === -1)
+                monthIndex = MONTH_ABBREVIATIONS.indexOf(word);
+            if (monthIndex !== -1) {
+                possibleMonth = monthIndex + 1;
+                continue;
+            }
+            else if (num > 0 && num <= 12) {
+                possibleMonth = num;
+                continue;
+            }
+        }
+        if (!possibleYear && num >= 0) {
+            possibleYear = num < 100 ? num + (num < 50 ? 2000 : 1900) : num;
+            continue;
+        }
+    }
+    if (possibleDay && possibleMonth && possibleYear) {
+        return DateTime.fromObject({
+            day: possibleDay,
+            month: possibleMonth,
+            year: possibleYear,
+        });
+    }
+    return null;
+};
+export var parseTimeFromUserInput = function (input) {
+    var cleanedInput = input
+        .trim()
+        .replace(/\s*:\s*/g, ":")
+        .replace(/\s+(AM|PM|am|pm)\s*$/, " $1");
+    var len = cleanedInput.length;
+    if (len < 4 || len > 16)
+        return null;
+    var hour = 0, minute = 0, second = 0, millisecond = 0;
+    var meridiem = null;
+    var parts = cleanedInput.split(" ");
+    if (parts.length > 2)
+        return null;
+    if (parts.length === 2) {
+        meridiem = parts[1].toUpperCase();
+        if (meridiem !== "AM" && meridiem !== "PM")
+            return null;
+    }
+    var timeParts = parts[0].split(":");
+    if (timeParts.length < 2 || timeParts.length > 3)
+        return null;
+    hour = parseInt(timeParts[0], 10);
+    minute = parseInt(timeParts[1], 10);
+    if (isNaN(hour) || isNaN(minute))
+        return null;
+    if (timeParts.length === 3) {
+        var secondParts = timeParts[2].split("."); // Split to consider milliseconds
+        second = parseInt(secondParts[0], 10);
+        if (secondParts.length === 2) {
+            millisecond = parseInt(secondParts[1], 10);
+        }
+        if (isNaN(second) || isNaN(millisecond))
+            return null;
+    }
+    if (hour < 0 ||
+        hour > 23 ||
+        minute < 0 ||
+        minute > 59 ||
+        second < 0 ||
+        second > 59 ||
+        millisecond < 0 ||
+        millisecond > 999)
+        return null;
+    if (meridiem === "PM" && hour < 12) {
+        hour += 12;
+    }
+    else if (meridiem === "AM" && hour === 12) {
+        hour = 0;
+    }
+    var dateTime = DateTime.fromObject({ hour: hour, minute: minute, second: second, millisecond: millisecond });
+    return dateTime.isValid ? dateTime : null;
+};
+export var parseTimeFromDateTimeorTimeInput = function (userInput) {
+    var res1 = parseTimeFromUserInput(userInput);
+    if (res1)
+        return res1;
+    var res2 = parseDateTimeFromUserInput(userInput);
+    if (res2)
+        return res2;
+    return null;
+};
+export var parseDateTimeFromUserInput = function (userInput) {
+    var fromISO = DateTime.fromISO(userInput);
+    if (fromISO.isValid && userInput.includes("T"))
+        return fromISO;
+    var cleanedInput = userInput.trim().replace(/\s+/g, " ").toLowerCase();
+    var words = cleanedInput.split(" ");
+    var datePart = "";
+    var timePart = "";
+    var meridiem = "";
+    for (var _i = 0, words_1 = words; _i < words_1.length; _i++) {
+        var word = words_1[_i];
+        if (word === "am" || word === "pm") {
+            meridiem = word.toUpperCase();
+            continue;
+        }
+        if (word.includes(":")) {
+            timePart = word;
+            continue;
+        }
+        datePart = "".concat(datePart, " ").concat(word);
+    }
+    if (meridiem) {
+        timePart = "".concat(timePart, " ").concat(meridiem);
+    }
+    var dateObject = parseDateFromUserInput(datePart.trim());
+    if (!dateObject || !dateObject.isValid)
+        return null;
+    var timeObject = parseTimeFromUserInput(timePart.trim());
+    if (!timeObject || !timeObject.isValid)
+        return null;
+    if (!timeObject || !timeObject.isValid)
+        return null;
+    var combinedDateTime = DateTime.fromObject({
+        year: dateObject.year,
+        month: dateObject.month,
+        day: dateObject.day,
+        hour: timeObject.hour,
+        minute: timeObject.minute,
+        second: timeObject.second,
+        millisecond: timeObject.millisecond,
+    });
+    return combinedDateTime.isValid ? combinedDateTime : null;
+};

package/lib/esm/Importer/common/Spreadsheet/transformation/{transformators.d.ts → transformators/index.d.ts}

@@ -1,18 +1,18 @@
-import { Field, FieldTransformation } from "../../../../types";
+import { Field, FieldTransformation } from "../../../../../types";
 export type FieldTransformator = (fieldValue: any, transformation?: FieldTransformation, fieldOptions?: Field) => {
     transformationWasNeeded: boolean;
     original: any;
     transformed: any;
 };
-export type DateTimeTransformator = (fieldValue: any, transformation?: FieldTransformation, fieldOptions?: Field, possibleDateFormats?: string[]) => {
+export type FieldTransformations = Partial<{
+    [key: string]: FieldTransformator;
+}>;
+export declare const isTransformationNeeded: (fieldValue: any, transformedValue: any) => {
     transformationWasNeeded: boolean;
     original: any;
     transformed: any;
 };
-export type FieldTransformations = Partial<{
-    [key: string]: FieldTransformator | DateTimeTransformator;
-}>;
 export declare const datesDateTimesAndTimesTransformations: FieldTransformations;
 export declare const fieldTransformations: {
-    [x: string]: FieldTransformator | DateTimeTransformator;
+    [x: string]: FieldTransformator;
 };

package/lib/esm/Importer/common/Spreadsheet/transformation/{transformators.js → transformators/index.js}

@@ -9,11 +9,15 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-import { DateTime } from "luxon";
-var isTransformationNeeded = function (fieldValue, transformedValue) { return ({
-    transformationWasNeeded: fieldValue !== transformedValue,
+import { parseDateFromUserInput, parseDateTimeFromUserInput, parseTimeFromDateTimeorTimeInput, } from "./dateTimeAutoformatUtils";
+export var isTransformationNeeded = function (fieldValue, transformedValue) { return ({
+    transformationWasNeeded: !!transformedValue
+        ? fieldValue !== transformedValue
+        : false,
     original: fieldValue,
-    transformed: fieldValue === transformedValue ? null : transformedValue,
+    transformed: fieldValue === transformedValue || transformedValue === undefined
+        ? null
+        : transformedValue,
 }); };
 var isNotANumber = function (fieldValue) {
     return fieldValue === null || fieldValue === undefined || isNaN(fieldValue);
@@ -79,49 +83,24 @@ var stringFieldTransformations = {
         return isTransformationNeeded(fieldValue, transformedValue);
     },
 };
-var parseDate = function (date, possibleFormats) {
-    if (!date)
-        return null;
-    for (var i = 0; i < possibleFormats.length; i++) {
-        var format = possibleFormats[i];
-        try {
-            var currentDate = DateTime.fromFormat(date, format, { zone: "utc" });
-            if (currentDate.isValid) {
-                return currentDate;
-            }
-        }
-        catch (error) {
-            return null;
-        }
-    }
-    return null;
-};
 export var datesDateTimesAndTimesTransformations = {
-    autoformat: function (fieldValue, _, fieldOptions, possibleDateFormats) {
-        var cleanFieldValue = fieldValue === null || fieldValue === void 0 ? void 0 : fieldValue.replace(/"/g, "");
-        var normalizedFieldValue = cleanFieldValue === null || cleanFieldValue === void 0 ? void 0 : cleanFieldValue.replace(/-/g, "/");
-        var isUnixTimestamp = /^\d+$/.test(normalizedFieldValue);
-        var luxonDate = isUnixTimestamp
-            ? DateTime.fromSeconds(Number(normalizedFieldValue))
-            : parseDate(normalizedFieldValue, possibleDateFormats);
-        var pattern = fieldOptions === null || fieldOptions === void 0 ? void 0 : fieldOptions.pattern;
-        var defaultObj = {
-            transformationWasNeeded: false,
-            original: fieldValue,
-            transformed: null,
-        };
-        if (!fieldValue || !pattern || !luxonDate || isNaN(luxonDate.toSeconds())) {
-            return defaultObj;
-        }
-        if (!luxonDate.isValid) {
-            return defaultObj;
-        }
-        var transformedValue = luxonDate.toFormat(pattern);
-        return {
-            transformationWasNeeded: fieldValue !== transformedValue,
-            original: fieldValue,
-            transformed: transformedValue,
+    autoformat: function (fieldValue, _, fieldOptions) {
+        if (fieldValue === null || fieldValue === undefined)
+            return {
+                transformationWasNeeded: false,
+                original: fieldValue,
+                transformed: null,
+            };
+        var type = fieldOptions.type, pattern = fieldOptions.pattern;
+        var parseFunctions = {
+            date: parseDateFromUserInput,
+            datetime: parseDateTimeFromUserInput,
+            time: parseTimeFromDateTimeorTimeInput,
         };
+        var parseFn = parseFunctions[type];
+        var dateValue = parseFn(fieldValue);
+        var transformedValue = dateValue === null || dateValue === void 0 ? void 0 : dateValue.toFormat(pattern);
+        return isTransformationNeeded(fieldValue, transformedValue);
     },
 };
 var urlTransformations = {

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

@@ -1,5 +1,5 @@
-import { DuplicateValuesCollection, Field, FieldValidation } from "../../../../types";
 import { MutableRefObject } from "react";
+import { DuplicateValuesCollection, Field, FieldValidation } from "../../../../types";
 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

@@ -99,6 +99,7 @@ export var fieldValidations = {
         var _a;
         if (!isNullOrUndefined(fieldValue) &&
             !isNullOrUndefined(duplicateValues.current)) {
+            fieldValue = String(fieldValue);
             var isDuplicated = duplicateValues.current[field.name] &&
                 duplicateValues.current[field.name][fieldValue] &&
                 duplicateValues.current[field.name][fieldValue].length > 1;
@@ -110,6 +111,7 @@ export var fieldValidations = {
         var _a;
         if (!isNullOrUndefined(fieldValue) &&
             !isNullOrUndefined(duplicateValues.current)) {
+            fieldValue = String(fieldValue);
             var isDuplicated = duplicateValues.current[field.name] &&
                 duplicateValues.current[field.name][fieldValue.toLowerCase()] &&
                 duplicateValues.current[field.name][fieldValue.toLowerCase()].length >

package/lib/esm/Importer/common/theme.d.ts

@@ -42,6 +42,7 @@ declare const getCustomTheme: (importerStylePreferences: ImporterStylePreference
             red50: string;
             red100: string;
             red200: string;
+            red250: string;
             red300: string;
             red400: string;
             red500: string;

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

@@ -1,4 +1,4 @@
-import React from "react";
+import React, { MutableRefObject } from "react";
 import { CustomAction, FormatRecord, ImporterOptions, Integration, OnSubmit, OnValidateRecord, Record, TemplateHeader } from "../../types";
 import { FuseApi } from "../common/FuseApi";
 export type HeaderMatchings = {
@@ -31,6 +31,7 @@ export type State = {
     templateSlug: string;
     apiToken: string;
     inTrialMode: boolean;
+    hasValidSubmitFn: boolean;
     previewFirstTime: boolean;
     fuseApi: FuseApi;
     importerOptions: ImporterOptions;
@@ -59,6 +60,8 @@ export type State = {
     customActions: CustomAction[];
     headerMappingsLoaded: boolean;
     valueMappingsLoaded: boolean;
+    headersMappings: HeaderMappings[];
+    layoutRef: MutableRefObject<HTMLDivElement>;
 };
 export type Props = {
     templateSlug: string;
@@ -73,5 +76,9 @@ export type Props = {
     dynamicColumns: TemplateHeader[] | null;
     customActions: CustomAction[];
 };
+type HeaderMappings = {
+    [key: string]: string;
+};
 export declare const ImporterContextProvider: ({ templateSlug, initialRecords, apiToken, children, options, onSubmit, onClose, formatRecord, onValidateRecord, dynamicColumns, customActions, }: Props) => JSX.Element;
 export declare const useImporterContext: () => State;
+export {};

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

@@ -77,13 +77,14 @@ export var ImporterContextProvider = function (_a) {
         logoURL: null,
     }), 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 _o = useState({}), 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 _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 layoutRef = useRef(null);
     var fuseApi = useMemo(function () { return new FuseApi(options.env, apiToken); }, [
         options.env,
         apiToken,
@@ -230,7 +231,9 @@ export var ImporterContextProvider = function (_a) {
         }
     }, [uploadedDataHeaders, headersMappings]);
     useEffect(function () {
-        if (!templateHeaderMatchings || !uploadedDataHeaders)
+        if (!templateHeaderMatchings ||
+            !uploadedDataHeaders ||
+            !headerMappingsLoaded)
             return;
         var _uploadedDataEnumFieldValues = {};
         var templateLabels = Object.keys(templateHeaderMatchings);
@@ -252,8 +255,13 @@ export var ImporterContextProvider = function (_a) {
             });
         });
         setUploadedDataEnumFieldValues(_uploadedDataEnumFieldValues);
-        loadValueMappings(_uploadedDataEnumFieldValues);
-    }, [templateHeaderMatchings, uploadedDataHeaders]);
+        var valueLimitPerEnumField = Math.ceil(40 / enumFieldsLabels.length);
+        var enumFieldsLabelsLimited = {};
+        Object.keys(_uploadedDataEnumFieldValues).forEach(function (key) {
+            enumFieldsLabelsLimited[key] = _uploadedDataEnumFieldValues[key].slice(0, valueLimitPerEnumField);
+        });
+        loadValueMappings(enumFieldsLabelsLimited);
+    }, [headerMappingsLoaded, matcherSubstep]);
     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, error_1, errorMsg;
@@ -300,7 +308,8 @@ export var ImporterContextProvider = function (_a) {
         setUploadedData(null);
         setTemplateHeaderMatchings(null);
         setHeadersMappings(null);
-        setEnumFieldValueMatchings(null);
+        setEnumFieldValueMatchings({});
+        setUploadedDataEnumFieldValues(null);
         setSelectedRows([]);
         setHeaderRowIndex(0);
     };
@@ -318,6 +327,7 @@ export var ImporterContextProvider = function (_a) {
         }
     };
     var inTrialMode = organization === null || organization === void 0 ? void 0 : organization.trial_mode;
+    var hasValidSubmitFn = typeof onSubmit === "function";
     var value = {
         initialRecords: initialRecords,
         currentStepIndex: currentStepIndex,
@@ -334,6 +344,7 @@ export var ImporterContextProvider = function (_a) {
         apiToken: apiToken,
         templateSlug: templateSlug,
         inTrialMode: inTrialMode,
+        hasValidSubmitFn: hasValidSubmitFn,
         fuseApi: fuseApi,
         theme: style.theme,
         logoURL: style.logoURL,
@@ -361,6 +372,8 @@ export var ImporterContextProvider = function (_a) {
         customActions: customActions,
         headerMappingsLoaded: headerMappingsLoaded,
         valueMappingsLoaded: valueMappingsLoaded,
+        headersMappings: headersMappings,
+        layoutRef: layoutRef,
     };
     return (_jsx(ImporterContext.Provider, __assign({ value: value }, { children: children })));
 };

package/lib/esm/Importer/data/index.d.ts

@@ -7,7 +7,6 @@ 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[], withTransformations?: boolean) => {
     isDatasetTransformed: boolean;
     dataSet: RecordDataSet;

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

@@ -18,13 +18,9 @@ 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) {
     return index.toString();
@@ -48,29 +44,6 @@ export var addMeta = function (record, index, uploadedRow, transformedRow) {
     var meta = (_a = record._meta) !== null && _a !== void 0 ? _a : {};
     return __assign(__assign({}, record), { _meta: __assign(__assign({}, meta), { id: rId, rowIndex: index, uploadedRow: uploadedRow, 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, withTransformations) {
     if (withTransformations === void 0) { withTransformations = true; }
     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; });
@@ -78,15 +51,6 @@ export var recordListToDataSet = function (data, fields, withTransformations) {
     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)));
-    }
     var isDatasetTransformed = false;
     var res = initialData.reduce(function (dataSet, record, i) {
         var transformedRecord = {};
@@ -94,7 +58,6 @@ export var recordListToDataSet = function (data, fields, withTransformations) {
             transformedRecord = transformRecord({
                 record: record,
                 fields: fieldWithTransformations,
-                possibleDateFormats: possibleDateFormats,
             });
         }
         if (JSON.stringify(transformedRecord) !== "{}")

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

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