fuse-importer 0.1.7-testing → 0.1.8-testing

package/lib/esm/Importer/ImporterWithContext.js

@@ -93,6 +93,6 @@ export var ImporterWithContext = function () {
         currentStepIndex: currentStepIndex,
         templateHeaders: templateHeaders,
     };
-    return (_jsx(ThemeProvider, __assign({ theme: theme }, { children: _jsx(AppLoadingContextProvider, { children: _jsxs(EventManagerContextProvider, { children: [_jsx(Toast, {}), _jsx(GlobalStyle, {}), _jsx(ImporterFonts, {}), templateHeaders ? (_jsx(ReviewContextProvider, __assign({ initialRecords: initialRecords }, { children: _jsxs(_Fragment, { children: [isModal && _jsx(Backdrop, {}), _jsx(Layout, __assign({ zIndex: zIndex, ref: layoutRef, isModal: isModal }, { children: shouldShowPreviewFirstTime ? (_jsx(PreviewFirstTime, {})) : (_jsx(ContentRenderer, __assign({}, contentRendererProps))) }))] }) }))) : (_jsx(AppLoading, {}))] }) }) })));
+    return (_jsx(ThemeProvider, __assign({ theme: theme }, { children: _jsx(AppLoadingContextProvider, { children: _jsxs(EventManagerContextProvider, { children: [_jsx(Toast, { zIndex: zIndex + 1 }), _jsx(GlobalStyle, {}), _jsx(ImporterFonts, {}), templateHeaders ? (_jsx(ReviewContextProvider, __assign({ initialRecords: initialRecords }, { children: _jsxs(_Fragment, { children: [isModal && _jsx(Backdrop, {}), _jsx(Layout, __assign({ zIndex: zIndex, ref: layoutRef, isModal: isModal }, { children: shouldShowPreviewFirstTime ? (_jsx(PreviewFirstTime, {})) : (_jsx(ContentRenderer, __assign({}, contentRendererProps))) }))] }) }))) : (_jsx(AppLoading, {}))] }) }) })));
 };
 var templateObject_1, templateObject_2, templateObject_3, templateObject_4, templateObject_5, templateObject_6;

package/lib/esm/Importer/Review/AppResponseModal.js

@@ -11,7 +11,7 @@ var __assign = (this && this.__assign) || function () {
 };
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useState } from "react";
-import { Modal, Button } from "../..";
+import { Button, Modal } from "../..";
 import { Div } from "../../styled/utils";
 import { useImporterContext } from "../contexts/ImporterContextProvider";
 import { useReviewContext } from "./ReviewContextProvider";
@@ -31,5 +31,5 @@ export var AppResponseModal = function () {
     var defaultMessage = importWasSuccessful
         ? "Data imported successfully"
         : "Some records could not be imported. Please review the errors and resubmit.";
-    return (_jsx(Modal, __assign({ isOpen: isAppResponseModalOpen, onClose: onCloseModal }, { children: _jsxs(Div, __assign({ centered: true, flexColumn: true, p: 40 }, { children: [_jsx(Div, __assign({ h6: true, w: 300, textAlignCenter: true, mt: 20 }, { children: (appResponse === null || appResponse === void 0 ? void 0 : appResponse.message) || defaultMessage })), _jsx(Div, __assign({ dflex: true, mt: 40, w100: true, centered: true }, { children: _jsx(Button, __assign({ ml: 10, onClick: onCloseModal }, { children: "OK" })) }))] })) })));
+    return (_jsx(Modal, __assign({ isOpen: isAppResponseModalOpen, onClose: onCloseModal }, { children: _jsxs(Div, __assign({ centered: true, flexColumn: true, p: 40 }, { children: [_jsx(Div, __assign({ h6: true, w: 300, textAlignCenter: true, mt: 20 }, { children: (appResponse === null || appResponse === void 0 ? void 0 : appResponse.message) || defaultMessage })), _jsx(Div, __assign({ dflex: true, mt: 40, w100: true, centered: true }, { children: _jsx(Button, __assign({ ml: 10, onClick: onCloseModal, "data-cy": "app-response-btn" }, { children: "OK" })) }))] })) })));
 };

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

@@ -28,6 +28,7 @@ import { ConfirmCloseModal } from "./ConfirmCloseModal";
 import { Step } from "./Step";
 import { StepperSubmitModal } from "./StepperSubmitModal";
 import { UnmatchedHeadersModal } from "./UnmatchedHeadersModal";
+import { useDataSetContext } from "../common/Spreadsheet/DataSetContextProvider";
 var StepperWrapper = styled(Div)(templateObject_1 || (templateObject_1 = __makeTemplateObject(["\n  background-color: ", ";\n  border-bottom: 1px solid ", ";\n  user-select: none;\n"], ["\n  background-color: ", ";\n  border-bottom: 1px solid ", ";\n  user-select: none;\n"])), function (p) { return p.theme.colors.white; }, function (p) { return p.theme.colors.gray300; });
 var StepperContainer = styled(Div)(templateObject_2 || (templateObject_2 = __makeTemplateObject(["\n  align-items: center;\n  display: flex;\n  gap: 16px;\n  justify-content: space-between;\n  padding-left: 32px;\n  padding-right: 32px;\n  width: 100%;\n"], ["\n  align-items: center;\n  display: flex;\n  gap: 16px;\n  justify-content: space-between;\n  padding-left: 32px;\n  padding-right: 32px;\n  width: 100%;\n"])));
 var Steps = styled(Div)(templateObject_3 || (templateObject_3 = __makeTemplateObject(["\n  @media (max-width: 630px) {\n    display: none;\n  }\n"], ["\n  @media (max-width: 630px) {\n    display: none;\n  }\n"])));
@@ -44,24 +45,36 @@ export var Stepper = function (_a) {
     var t = useTranslation("general").t;
     var _c = useState(false), isSubmitModalOpen = _c[0], setIsSubmitModalOpen = _c[1];
     var _d = useState(false), isConfirmCloseModalOpen = _d[0], setIsConfirmCloseModalOpen = _d[1];
-    var _e = useState(false), isSubmitDisabled = _e[0], setIsSubmitDisabled = _e[1];
-    var _f = useReviewContext(), appResponse = _f.appResponse, onSubmit = _f.onSubmit;
-    var totalErrorCount = useValidationContext().totalErrorCount;
-    var _g = useEventManagerContext(), on = _g.on, off = _g.off, EVENTS = _g.EVENTS;
+    var _e = useDataSetContext(), dataSetLength = _e.dataSetLength, emptyRecordIds = _e.emptyRecordIds;
+    var _f = useState(true), isSubmitDisabled = _f[0], setIsSubmitDisabled = _f[1];
+    var headerMappingsLoaded = useImporterContext().headerMappingsLoaded;
+    var _g = useReviewContext(), appResponse = _g.appResponse, onSubmit = _g.onSubmit;
+    var _h = useValidationContext(), totalErrorCount = _h.totalErrorCount, spreadsheetInitialized = _h.spreadsheetInitialized;
+    var _j = useEventManagerContext(), on = _j.on, off = _j.off, EVENTS = _j.EVENTS;
+    var updateSpreadsheetDisabled = function () {
+        var isSpreadsheetEmpty = dataSetLength.current === emptyRecordIds.current.size;
+        var isDisabled = totalErrorCount.current > 0 ||
+            !spreadsheetInitialized ||
+            isSpreadsheetEmpty;
+        setIsSubmitDisabled(isDisabled);
+    };
     useEffect(function () {
-        var listener = function () {
-            var isDisabled = totalErrorCount.current > 0;
-            setIsSubmitDisabled(isDisabled);
-        };
-        on(EVENTS.UPDATE_TOTAL_ERROR_COUNT, listener);
+        on(EVENTS.UPDATE_TOTAL_ERROR_COUNT, updateSpreadsheetDisabled);
         return function () {
-            off(EVENTS.UPDATE_TOTAL_ERROR_COUNT, listener);
+            off(EVENTS.UPDATE_TOTAL_ERROR_COUNT, updateSpreadsheetDisabled);
         };
-    }, [appResponse]);
-    var _h = useImporterContext(), initialRecords = _h.initialRecords, currentStepIndex = _h.currentStepIndex, templateHeaderMatchings = _h.templateHeaderMatchings, matcherSubstep = _h.matcherSubstep, templateHeaders = _h.templateHeaders, enumFieldValueMatchings = _h.enumFieldValueMatchings, setMatcherSubstep = _h.setMatcherSubstep, setCurrentStepIndex = _h.setCurrentStepIndex, onClose = _h.onClose, isUsingManualImport = _h.isUsingManualImport, resetImporterWhenUsingManualImport = _h.resetImporterWhenUsingManualImport, uploadedData = _h.uploadedData;
+    }, [appResponse, spreadsheetInitialized]);
+    useEffect(function () {
+        updateSpreadsheetDisabled();
+    }, [spreadsheetInitialized]);
+    var _k = useImporterContext(), initialRecords = _k.initialRecords, currentStepIndex = _k.currentStepIndex, templateHeaderMatchings = _k.templateHeaderMatchings, matcherSubstep = _k.matcherSubstep, templateHeaders = _k.templateHeaders, enumFieldValueMatchings = _k.enumFieldValueMatchings, setMatcherSubstep = _k.setMatcherSubstep, setCurrentStepIndex = _k.setCurrentStepIndex, onClose = _k.onClose, isUsingManualImport = _k.isUsingManualImport, resetImporterWhenUsingManualImport = _k.resetImporterWhenUsingManualImport, uploadedData = _k.uploadedData;
+    var _l = useState(true), isContinueDisabled = _l[0], setIsContinueDisabled = _l[1];
     var templateHeaderLabels = Object.keys(templateHeaderMatchings || []);
     var unmatchedHeadersCount = templateHeaderLabels.filter(function (templateHeaderLabel) { return !templateHeaderMatchings[templateHeaderLabel]; }).length;
     var isLastSubMatchStep = matcherSubstep === 1;
+    useEffect(function () {
+        setIsContinueDisabled(currentStepIndex === 1 && !headerMappingsLoaded);
+    }, [currentStepIndex, headerMappingsLoaded]);
     var setStep = function () {
         var templateHasEnumFields = !!(templateHeaders === null || templateHeaders === void 0 ? void 0 : templateHeaders.find(function (header) { return header.column_type === ColumnType.enum; }));
         if (templateHasEnumFields) {
@@ -120,7 +133,7 @@ export var Stepper = function (_a) {
                 return (_jsxs(Div, __assign({ centered: true }, { children: [_jsx(Step, { index: index, label: label, isCompleted: isCompleted, isSelected: index === currentStepIndex }), !isLast && (_jsx(Div, __assign({ ml: 18, mr: 18, dflex: true }, { children: _jsx(ChevronRightIcon, {}) })))] }), index));
             }) })));
     var leftButtonUI = (_jsx(Div, __assign({ style: { flex: 1 } }, { children: !initialRecords && (_jsxs(StepperButtonContainer, __assign({ align: "left" }, { children: [logoURL && (_jsx(Div, __assign({ forDesktop: true }, { children: _jsx(Logo, { src: logoURL, alt: "" }) }))), currentStepIndex > 0 && !appResponse && (_jsx(GoBackButtonWrapper, { children: _jsx(Button, __assign({ variant: "secondary", onClick: goBack }, { children: t("stepper.go_back") })) }))] }))) })));
-    var rightButtonUI = (_jsxs(StepperButtonContainer, __assign({ align: "right" }, { children: [(isMatchStep || isVerifyStep) && (_jsx(Button, __assign({ "data-cy": "continue-button", variant: "primary", onClick: continueToNextStep }, { children: t("stepper.continue") }))), isReviewStep && (_jsx(Button, __assign({ variant: "primary", isDisabled: isSubmitDisabled, "data-cy": "submit_disabled_" + isSubmitDisabled, onClick: function () { return setIsSubmitModalOpen(true); } }, { children: t("stepper.submit") }))), _jsx(CloseIcon, __assign({ "data-test-id": "close-importer", centered: true, clickable: true, onClick: handleOnClose }, { children: closeIconCondensed }))] })));
+    var rightButtonUI = (_jsxs(StepperButtonContainer, __assign({ align: "right" }, { children: [(isMatchStep || isVerifyStep) && (_jsx(Button, __assign({ "data-cy": "continue-button", isDisabled: isContinueDisabled, variant: "primary", onClick: continueToNextStep }, { children: t("stepper.continue") }))), isReviewStep && (_jsx(Button, __assign({ variant: "primary", isDisabled: isSubmitDisabled, "data-cy": "submit_disabled_" + isSubmitDisabled, onClick: function () { return setIsSubmitModalOpen(true); } }, { children: t("stepper.submit") }))), _jsx(CloseIcon, __assign({ "data-test-id": "close-importer", centered: true, clickable: true, onClick: handleOnClose }, { children: closeIconCondensed }))] })));
     return (_jsxs(_Fragment, { children: [_jsx(StepperWrapper, __assign({ pRelative: true, alignCenter: true, w100: true, h: 72, centered: true }, { children: _jsxs(StepperContainer, { children: [leftButtonUI, _jsx(Steps, __assign({ alignCenter: true }, { children: stepsUI })), rightButtonUI] }) })), _jsx(UnmatchedHeadersModal, { isUnmatchedHeadersModalOpen: isUnmatchedHeadersModalOpen, unmatchedHeadersCount: unmatchedHeadersCount, onSetStep: function () { return setStep(); }, onCloseUnmatchedHeadersModal: function () {
                     return setIsUnmatchedHeadersModalOpen(false);
                 } }), _jsx(StepperSubmitModal, { isSubmitModalOpen: isSubmitModalOpen, onCloseModal: function () { return setIsSubmitModalOpen(false); }, onSubmit: onSubmit }), _jsx(ConfirmCloseModal, { isOpen: isConfirmCloseModalOpen, onClose: function () { return setIsConfirmCloseModalOpen(false); }, onCloseImporter: onClose })] }));

package/lib/esm/Importer/common/Spreadsheet/SpreadsheetContextProvider/useDataSetManipulation.d.ts

@@ -1,4 +1,5 @@
 export declare const useDataSetManipulation: () => {
     appendNewRecordToSpreadsheet: () => void;
     deleteRecordsFromSpreadsheet: (recordIds: string[]) => void;
+    findAndReplaceInSpreadsheet: (searchText: string, replaceText: string, matchCase: boolean, useRegex: boolean) => any[];
 };

package/lib/esm/Importer/common/Spreadsheet/SpreadsheetContextProvider/useDataSetManipulation.js

@@ -1,3 +1,14 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 import { useFilteredDataContext } from "../FilteredDataContextProvider";
 import { useDataSetContext } from "../DataSetContextProvider";
 import { hasValueInAnyField } from "./utils";
@@ -5,6 +16,8 @@ import { addMeta } from "../../../../Importer/data";
 import { useEventManagerContext } from "../../../../common/EventManagerContextProvider";
 import { useValidationContext } from "../ValidationContextProvider";
 import { useDuplicateDataContext } from "../DuplicateDataContextProvider";
+import { useBatchProcessing } from "./useBatchProcessing";
+import useFindAndReplace from "../../../../common/Table/TableActions/useFindAndReplace";
 export var useDataSetManipulation = function () {
     var _a = useFilteredDataContext(), lastFilteredRecordId = _a.lastFilteredRecordId, setRecalculateFilters = _a.setRecalculateFilters;
     var _b = useDataSetContext(), getRecord = _b.getRecord, setRecord = _b.setRecord, dataSet = _b.dataSet, deleteRecord = _b.deleteRecord, emptyRecordIds = _b.emptyRecordIds;
@@ -12,6 +25,8 @@ export var useDataSetManipulation = function () {
     var _d = useValidationContext(), errors = _d.errors, warnings = _d.warnings, calculateColumnErrorCounts = _d.calculateColumnErrorCounts, calculateColumnWarningCounts = _d.calculateColumnWarningCounts;
     var updateDuplicateValues = useDuplicateDataContext().updateDuplicateValues;
     var updateRecordAndRevalidate = useValidationContext().updateRecordAndRevalidate;
+    var processInBatches = useBatchProcessing().processInBatches;
+    var replaceInRecord = useFindAndReplace().replaceInRecord;
     var appendNewRecordToSpreadsheet = function () {
         var _a, _b;
         var _record = getRecord(lastFilteredRecordId.current);
@@ -39,8 +54,22 @@ export var useDataSetManipulation = function () {
         emit(EVENTS.UPDATE_TOTAL_ERROR_COUNT);
         emit(EVENTS.UPDATE_TOTAL_ROW_COUNT);
     };
+    var findAndReplaceInSpreadsheet = function (searchText, replaceText, matchCase, useRegex) {
+        var cellsWithText = [];
+        processInBatches(dataSet.current, function (batch) {
+            for (var recordKey in batch) {
+                var record = __assign({}, dataSet.current[recordKey]);
+                if (replaceInRecord(record, searchText, replaceText, matchCase, useRegex)) {
+                    cellsWithText.push(record);
+                }
+            }
+        });
+        updateRecordAndRevalidate(cellsWithText);
+        return cellsWithText;
+    };
     return {
         appendNewRecordToSpreadsheet: appendNewRecordToSpreadsheet,
         deleteRecordsFromSpreadsheet: deleteRecordsFromSpreadsheet,
+        findAndReplaceInSpreadsheet: findAndReplaceInSpreadsheet,
     };
 };

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

@@ -58,6 +58,7 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { createContext, useContext, useEffect, useMemo, useRef, useState, } from "react";
 import { useAppLoadingContext } from "../../../../common/AppLoadingContextProvider";
 import { useEventManagerContext } from "../../../../common/EventManagerContextProvider";
+import { useImporterContext } from "../../../contexts/ImporterContextProvider";
 import { useDataSetContext } from "../DataSetContextProvider";
 import { useDuplicateDataContext } from "../DuplicateDataContextProvider";
 import { useBatchProcessing } from "../SpreadsheetContextProvider/useBatchProcessing";
@@ -101,16 +102,22 @@ export var ValidationContextProvider = function (_a) {
     var columnsWithWarningCounts = useRef({});
     var totalErrorCount = useRef(0);
     var invalidRowsCountRef = useRef(0);
-    var _c = useState(false), spreadsheetInitialized = _c[0], setSpreadsheetInitialized = _c[1];
-    var _d = useEventManagerContext(), emit = _d.emit, EVENTS = _d.EVENTS;
-    var _e = useDataSetContext(), getRecord = _e.getRecord, setRecord = _e.setRecord, dataSet = _e.dataSet;
-    var _f = useDuplicateDataContext(), duplicateValues = _f.duplicateValues, updateDuplicateValues = _f.updateDuplicateValues;
+    var _c = useEventManagerContext(), emit = _c.emit, EVENTS = _c.EVENTS;
+    var _d = useDataSetContext(), getRecord = _d.getRecord, setRecord = _d.setRecord, dataSet = _d.dataSet;
+    var _e = useDuplicateDataContext(), duplicateValues = _e.duplicateValues, updateDuplicateValues = _e.updateDuplicateValues;
     var processRecordsInBatches = useBatchProcessing(10000).processRecordsInBatches;
+    var _f = useState(false), spreadsheetInitialized = _f[0], setSpreadsheetInitialized = _f[1];
+    var currentStepIndex = useImporterContext().currentStepIndex;
+    var _g = useState(false), dataSetChanged = _g[0], setDataSetChanged = _g[1];
     var reset = function () {
         columnsWithErrorCounts.current = {};
         columnsWithWarningCounts.current = {};
         totalErrorCount.current = 0;
         invalidRowsCountRef.current = 0;
+        errors.current = {};
+        warnings.current = {};
+        setSpreadsheetInitialized(false);
+        setDataSetChanged(function (prev) { return !prev; });
     };
     var calculateColumnErrorCounts = function (oldErrors, newErrors) {
         if (oldErrors === void 0) { oldErrors = {}; }
@@ -177,7 +184,7 @@ export var ValidationContextProvider = function (_a) {
                         else {
                             delete warnings.current[recordId];
                         }
-                        if (backendErrors) {
+                        if (backendErrors && spreadsheetInitialized) {
                             record._meta.backendErrors = {};
                         }
                         emit(recordId, newRecord);
@@ -253,7 +260,9 @@ export var ValidationContextProvider = function (_a) {
     // Initial data validation and update dataSet
     useEffect(function () {
         reset();
-        if (!dataSet.current || isReadOnly)
+    }, [dataSet.current]);
+    useEffect(function () {
+        if (!dataSet.current || isReadOnly || currentStepIndex !== 2)
             return;
         setIsLoadingApp(true);
         var initialValidation = function () { return __awaiter(void 0, void 0, void 0, function () {
@@ -265,7 +274,6 @@ export var ValidationContextProvider = function (_a) {
                         return [4 /*yield*/, updateRecordAndRevalidate(initialData, true)];
                     case 1:
                         _a.sent();
-                        setSpreadsheetInitialized(true);
                         return [2 /*return*/];
                 }
             });
@@ -277,11 +285,12 @@ export var ValidationContextProvider = function (_a) {
                     case 1:
                         _a.sent();
                         setIsLoadingApp(false);
+                        setSpreadsheetInitialized(true);
                         return [2 /*return*/];
                 }
             });
         }); })();
-    }, [dataSet.current]);
+    }, [spreadsheetInitialized, currentStepIndex, dataSetChanged]);
     var isValidationCompleted = validationPercentage === 100;
     var isValid = isValidationCompleted && totalErrorCount.current === 0;
     var value = {

package/lib/esm/Importer/common/Spreadsheet/components/FindAndReplace/index.d.ts

@@ -0,0 +1,6 @@
+type FindAndReplaceModalProps = {
+    initialText: string;
+    onClose: () => void;
+};
+export declare const FindAndReplaceModal: ({ initialText, onClose, }: FindAndReplaceModalProps) => JSX.Element;
+export {};

package/lib/esm/Importer/common/Spreadsheet/components/FindAndReplace/index.js

@@ -0,0 +1,44 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Div } from "../../../../../styled";
+import { Button, Modal, addToast } from "../../../../../common";
+import { useTranslation } from "react-i18next";
+import { TextInput } from "../../../../../common/inputs/TextInput";
+import { Checkbox } from "../../../../../common";
+import { useState } from "react";
+import { useDataSetManipulation } from "../../SpreadsheetContextProvider/useDataSetManipulation";
+import { useFilteredDataContext } from "../../FilteredDataContextProvider";
+export var FindAndReplaceModal = function (_a) {
+    var initialText = _a.initialText, onClose = _a.onClose;
+    var t = useTranslation("general").t;
+    var _b = useState(initialText), searchText = _b[0], setSearchText = _b[1];
+    var _c = useState(""), replaceText = _c[0], setReplaceText = _c[1];
+    var findAndReplaceInSpreadsheet = useDataSetManipulation().findAndReplaceInSpreadsheet;
+    var _d = useState(false), useRegex = _d[0], setUseRegex = _d[1];
+    var _e = useState(true), matchCase = _e[0], setMatchCase = _e[1];
+    var setFilteredInputValue = useFilteredDataContext().setFilteredInputValue;
+    var findAndReplace = function () {
+        var records = findAndReplaceInSpreadsheet(searchText, replaceText, matchCase, useRegex);
+        if (records.length > 0) {
+            addToast(t("find_and_replace_modal.records_replaced", {
+                length: records.length,
+            }), "success");
+            onClose();
+            setFilteredInputValue("");
+        }
+        else {
+            addToast(t("find_and_replace_modal.no_records_found"), "error");
+        }
+    };
+    return (_jsx(Modal, __assign({ isOpen: true, onClose: function () { return onClose(); } }, { children: _jsxs(Div, __assign({ p: "17px 20px", w: 500 }, { children: [_jsx(Div, __assign({ textAlignCenter: true, h5: true }, { children: t("find_and_replace_modal.title") })), _jsx(Div, __assign({ mt: 20, mb: 20, textAlignCenter: true, body1: true }, { children: t("find_and_replace_modal.description") })), _jsxs(Div, __assign({ mb: 20, w: 500, textAlignCenter: true, body1: true }, { children: [_jsx(TextInput, { "data-cy": "find-input", mb: 20, name: t("find_and_replace_modal.find"), label: t("find_and_replace_modal.find"), value: searchText, onChange: function (value) { return setSearchText(value); } }), _jsx(TextInput, { "data-cy": "replace-input", label: t("find_and_replace_modal.replace_with"), value: replaceText, onChange: function (value) { return setReplaceText(value); } })] })), _jsx(Div, __assign({ mb: 12 }, { children: _jsx(Checkbox, { "data-cy": "use-regex", label: t("find_and_replace_modal.use_regex"), isChecked: useRegex, onChange: function (v) { return setUseRegex(v); } }) })), _jsx(Div, __assign({ mb: 12 }, { children: _jsx(Checkbox, { "data-cy": "case-sensitive", label: t("find_and_replace_modal.use_case_sensitive"), isChecked: matchCase, onChange: function (v) { return setMatchCase(v); } }) })), _jsxs(Div, __assign({ dflex: true, centered: true, mt: 40 }, { children: [_jsx(Button, __assign({ variant: "secondary", onClick: function () { return onClose(); }, w: 160, mr: 16 }, { children: t("find_and_replace_modal.cancel") })), _jsx(Button, __assign({ "data-cy": "find-replace-submit", variant: "primary", onClick: function () { return findAndReplace(); } }, { children: t("find_and_replace_modal.submit") }))] }))] })) })));
+};

package/lib/esm/Importer/common/Spreadsheet/components/SpreadsheetRowCheckboxes.js

@@ -44,9 +44,9 @@ import { useImporterContext } from "../../../contexts/ImporterContextProvider";
 import { useReviewContext } from "../../../Review/ReviewContextProvider";
 import { spreadsheetRowHeightPx } from "../common";
 import { spreadsheetHeaderHeightPx } from "../common/index";
-import { useDataSetContext } from "../DataSetContextProvider";
 import { useSpreadsheetContext } from "../SpreadsheetContextProvider";
 import { rowIsEmpty } from "../SpreadsheetContextProvider/utils";
+import { useDataSetContext } from "../DataSetContextProvider";
 var StyledGrid = styled(Grid)(templateObject_1 || (templateObject_1 = __makeTemplateObject(["\n  background: ", ";\n  overflow-y: scroll;\n"], ["\n  background: ", ";\n  overflow-y: scroll;\n"])), function (_a) {
     var theme = _a.theme;
     return theme.colors.white50;

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

@@ -2,7 +2,6 @@ import { Field, Record, TransformedRecord } from "../../../../types";
 type TransformRecordArgs = {
     record: Record;
     fields: Field[];
-    possibleDateFormats?: string[];
 };
-export declare const transformRecord: ({ record, fields, possibleDateFormats, }: TransformRecordArgs) => TransformedRecord;
+export declare const transformRecord: ({ record, fields }: TransformRecordArgs) => TransformedRecord;
 export {};

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;
 };