fuse-importer 0.27.1 → 0.30.0

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

@@ -0,0 +1,324 @@
+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);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+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";
+import { selectValidatorsFor, validateRecord } from "../validation";
+// this is the fastest check for empty object as per
+// https://stackoverflow.com/questions/679915/how-do-i-test-for-an-empty-javascript-object/785768#785768
+var isObjectEmpty = function (obj) {
+    for (var i in obj) {
+        return false;
+    }
+    return true;
+};
+var checkIfHasErrors = function (_errors) {
+    return _errors && !isObjectEmpty(_errors);
+};
+var calculateFieldCountChangeInRecord = function (prevCountsInRecord, currCountsInRecord, globalFieldCounts, totalGlobalFieldCount) {
+    if (prevCountsInRecord === void 0) { prevCountsInRecord = {}; }
+    if (currCountsInRecord === void 0) { currCountsInRecord = {}; }
+    if (totalGlobalFieldCount === void 0) { totalGlobalFieldCount = null; }
+    var allFieldsInRecord = new Set(__spreadArray(__spreadArray([], Object.keys(prevCountsInRecord), true), Object.keys(currCountsInRecord), true));
+    allFieldsInRecord.forEach(function (fieldName) {
+        var _a;
+        var countChangeInRecord = (currCountsInRecord[fieldName] ? 1 : 0) -
+            (prevCountsInRecord[fieldName] ? 1 : 0);
+        if (!countChangeInRecord)
+            return;
+        globalFieldCounts.current = __assign(__assign({}, globalFieldCounts.current), (_a = {}, _a[fieldName] = (globalFieldCounts.current[fieldName] || 0) + countChangeInRecord, _a));
+        if (totalGlobalFieldCount)
+            totalGlobalFieldCount.current += countChangeInRecord;
+    });
+};
+export var ValidationContext = createContext({});
+export var ValidationContextProvider = function (_a) {
+    var fields = _a.fields, isReadOnly = _a.isReadOnly, onValidateRecord = _a.onValidateRecord, children = _a.children;
+    var errors = useRef({});
+    var warnings = useRef({});
+    var _b = useState(0), validationPercentage = _b[0], setValidationPercentage = _b[1];
+    var validatorsCache = useMemo(function () { return selectValidatorsFor(fields); }, [fields]);
+    var setIsLoadingApp = useAppLoadingContext().setIsLoadingApp;
+    var columnsWithErrorCounts = useRef({});
+    var columnsWithWarningCounts = useRef({});
+    var totalErrorCount = useRef(0);
+    var invalidRowsCountRef = useRef(0);
+    var _c = useEventManagerContext(), emit = _c.emit, EVENTS = _c.EVENTS;
+    var _d = useDataSetContext(), getRecord = _d.getRecord, setRecord = _d.setRecord, dataSet = _d.dataSet, dataSetLength = _d.dataSetLength;
+    var _e = useDuplicateDataContext(), duplicateValues = _e.duplicateValues, updateDuplicateValues = _e.updateDuplicateValues, resetDuplicateProvider = _e.resetDuplicateProvider;
+    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 = {}; }
+        if (newErrors === void 0) { newErrors = {}; }
+        if (Object.keys(oldErrors).length === 0 &&
+            Object.keys(newErrors).length > 0)
+            invalidRowsCountRef.current += 1;
+        if (Object.keys(oldErrors).length > 0 &&
+            Object.keys(newErrors).length === 0)
+            invalidRowsCountRef.current -= 1;
+        calculateFieldCountChangeInRecord(oldErrors, newErrors, columnsWithErrorCounts, totalErrorCount);
+    };
+    var calculateColumnWarningCounts = function (oldWarnings, newWarnings) {
+        if (oldWarnings === void 0) { oldWarnings = {}; }
+        if (newWarnings === void 0) { newWarnings = {}; }
+        calculateFieldCountChangeInRecord(oldWarnings, newWarnings, columnsWithWarningCounts);
+    };
+    var batchValidationDelayMs = 100;
+    var sleep = function (n) { return new Promise(function (resolve) { return setTimeout(resolve, n); }); };
+    var getBackendErrors = function (record) {
+        var _a;
+        var recordBackendErrors = (_a = record === null || record === void 0 ? void 0 : record._meta) === null || _a === void 0 ? void 0 : _a.backendErrors;
+        return recordBackendErrors || null;
+    };
+    var _validateRecord = function (record, initialValidation) {
+        if (initialValidation === void 0) { initialValidation = false; }
+        return __awaiter(void 0, void 0, void 0, function () {
+            var recordId, oldRecord, newRecord, backendErrors, _a, recordErrors, recordWarnings, hasError, hasWarning;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!record)
+                            return [2 /*return*/];
+                        recordId = record._meta.id;
+                        oldRecord = getRecord(recordId);
+                        updateDuplicateValues(oldRecord, record, initialValidation, updateRecordAndRevalidate);
+                        newRecord = setRecord(recordId, __assign({}, record));
+                        backendErrors = getBackendErrors(record);
+                        return [4 /*yield*/, validateRecord({
+                                validatorsCache: validatorsCache,
+                                onValidateRecord: onValidateRecord,
+                                fields: fields,
+                                record: newRecord,
+                                duplicateValues: duplicateValues,
+                                backendErrors: backendErrors,
+                            })];
+                    case 1:
+                        _a = _b.sent(), recordErrors = _a.errors, recordWarnings = _a.warnings;
+                        calculateColumnErrorCounts(errors.current[recordId], recordErrors);
+                        calculateColumnWarningCounts(warnings.current[recordId], recordWarnings);
+                        hasError = checkIfHasErrors(recordErrors);
+                        hasWarning = checkIfHasErrors(recordWarnings);
+                        newRecord._meta.isInvalid = hasError;
+                        newRecord._meta.hasWarning = hasWarning;
+                        if (hasError) {
+                            errors.current[recordId] = recordErrors;
+                        }
+                        else {
+                            delete errors.current[recordId];
+                        }
+                        if (hasWarning) {
+                            warnings.current[recordId] = recordWarnings;
+                        }
+                        else {
+                            delete warnings.current[recordId];
+                        }
+                        if (backendErrors && spreadsheetInitialized) {
+                            record._meta.backendErrors = {};
+                        }
+                        emit(recordId, newRecord);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    var updateValidationPercentage = function (recordsValidated, totalRecords) {
+        var validationPercentage = (Math.min(recordsValidated, totalRecords) / totalRecords) * 100;
+        setValidationPercentage(Math.round((validationPercentage + Number.EPSILON) * 10) / 10);
+    };
+    // Validate record and update dataSet
+    var updateRecordAndRevalidate = function (records, initialValidation, loadingIndicator) {
+        if (initialValidation === void 0) { initialValidation = false; }
+        if (loadingIndicator === void 0) { loadingIndicator = true; }
+        return __awaiter(void 0, void 0, void 0, function () {
+            var recordsArray, length, recordsProcessed;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        recordsArray = Array.isArray(records) ? records : [records];
+                        length = recordsArray.length;
+                        if (!(loadingIndicator && length > 10000)) return [3 /*break*/, 2];
+                        setIsLoadingApp(true);
+                        // wait for the first render to complete
+                        // before blocking main thread with review step logic
+                        return [4 /*yield*/, sleep(200)];
+                    case 1:
+                        // wait for the first render to complete
+                        // before blocking main thread with review step logic
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        recordsProcessed = 0;
+                        return [4 /*yield*/, processRecordsInBatches(recordsArray, function (batch) { return __awaiter(void 0, void 0, void 0, function () {
+                                var i, record;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            i = 0;
+                                            _a.label = 1;
+                                        case 1:
+                                            if (!(i < batch.length)) return [3 /*break*/, 4];
+                                            record = batch[i];
+                                            return [4 /*yield*/, _validateRecord(record, initialValidation)];
+                                        case 2:
+                                            _a.sent();
+                                            recordsProcessed += 1;
+                                            _a.label = 3;
+                                        case 3:
+                                            i++;
+                                            return [3 /*break*/, 1];
+                                        case 4:
+                                            updateValidationPercentage(recordsProcessed, length);
+                                            emit(EVENTS.UPDATE_COLUMN_ERROR_COUNT);
+                                            emit(EVENTS.UPDATE_TOTAL_ERROR_COUNT);
+                                            emit(EVENTS.UPDATE_TOTAL_ROW_COUNT);
+                                            return [4 /*yield*/, sleep(batchValidationDelayMs)];
+                                        case 5:
+                                            _a.sent();
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); })];
+                    case 3:
+                        _a.sent();
+                        if (loadingIndicator) {
+                            setIsLoadingApp(false);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // Initial data validation and update dataSet
+    useEffect(function () {
+        if (dataSet.current && !isReadOnly) {
+            resetDuplicateProvider();
+        }
+        reset();
+    }, [dataSet.current]);
+    useEffect(function () {
+        var isDataSetInvalid = !dataSet.current || dataSetLength.current === 0;
+        if (isDataSetInvalid ||
+            isReadOnly ||
+            currentStepIndex !== 2 ||
+            (fields === null || fields === void 0 ? void 0 : fields.length) === 0)
+            return;
+        var initialValidation = function () { return __awaiter(void 0, void 0, void 0, function () {
+            var initialData;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        initialData = Object.values(dataSet.current);
+                        if (!(initialData.length > 0)) return [3 /*break*/, 2];
+                        setIsLoadingApp(true);
+                        return [4 /*yield*/, updateRecordAndRevalidate(initialData, true)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        }); };
+        (function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, initialValidation()];
+                    case 1:
+                        _a.sent();
+                        setSpreadsheetInitialized(true);
+                        return [2 /*return*/];
+                }
+            });
+        }); })();
+    }, [currentStepIndex, dataSetChanged]);
+    var isValidationCompleted = validationPercentage === 100;
+    var isValid = isValidationCompleted && totalErrorCount.current === 0;
+    var value = {
+        errors: errors,
+        warnings: warnings,
+        totalErrorCount: totalErrorCount,
+        invalidRowsCountRef: invalidRowsCountRef,
+        columnsWithErrorCounts: columnsWithErrorCounts,
+        columnsWithWarningCounts: columnsWithWarningCounts,
+        calculateColumnErrorCounts: calculateColumnErrorCounts,
+        calculateColumnWarningCounts: calculateColumnWarningCounts,
+        validationPercentage: validationPercentage,
+        isValidationCompleted: isValidationCompleted,
+        isValid: isValid,
+        updateRecordAndRevalidate: updateRecordAndRevalidate,
+        spreadsheetInitialized: spreadsheetInitialized,
+    };
+    return (_jsx(ValidationContext.Provider, __assign({ value: value }, { children: children })));
+};
+export var useValidationContext = function () { return useContext(ValidationContext); };

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

@@ -5,17 +5,17 @@ export var isNullOrUndefined = function (value) {
     return value === null || value === undefined;
 };
 export var isEmpty = function (value) {
-    return (value === undefined ||
-        value === null ||
+    return (isNullOrUndefined(value) ||
         (typeof value === "object" && Object.keys(value).length === 0) ||
-        (typeof value === "string" && value.trim().length === 0));
+        (typeof value === "string" &&
+            (value.length === 0 || value.trim().length === 0)));
 };
 export var isEmail = function (value) {
     var emailRegex = /^[\w+.-]+@([\w-]+\.)+[\w-]{2,4}$/;
     return emailRegex.test(value);
 };
 export var isUrl = function (value) {
-    var urlRegex = /^(http:\/\/www\.|https:\/\/www\.|http:\/\/|https:\/\/)?[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$/g;
+    var urlRegex = /^(?:(?:https?|ftp|file|tcp|mailto|tel|data|ssh|irc|gopher|ws|wss):\/\/|www\.)[A-Za-z0-9]+([\-\.]{1}[A-Za-z0-9]+)*\.[A-Za-z]{2,16}(:[0-9]{1,5})?(\/.*)?$/g;
     return urlRegex.test(value);
 };
 export var isTrue = function (value) {
@@ -46,15 +46,24 @@ export var ignoreNullOrUndefinedKeyValues = function (obj) {
     return result;
 };
 export var isRecordEmpty = function (record, fields) {
-    return fields.reduce(function (isEmptyRecord, f) { return isEmptyRecord && isEmpty(record[f.name]); }, true);
+    var hasValue = fields.some(function (f) { return !isEmpty(record[f.name]); });
+    return !hasValue;
 };
 export var parseValue = function (fieldType, value, enumSet) {
     if (isEmpty(value))
         return value;
-    if (fieldType === FieldTypes.float)
-        return isFloat(value) ? parseFloat(value) : value;
-    if (fieldType === FieldTypes.integer)
-        return isInteger(value) ? parseInt(value) : value;
+    var cleanNumber = function (val) {
+        // Remove all non-numeric characters except the decimal point.
+        return typeof val === "string" ? val.replace(/[^\d.]/g, "") : val;
+    };
+    if (fieldType === FieldTypes.float) {
+        var cleanedValue = cleanNumber(value);
+        return isFloat(cleanedValue) ? parseFloat(cleanedValue) : value;
+    }
+    if (fieldType === FieldTypes.integer) {
+        var cleanedValue = cleanNumber(value);
+        return isInteger(cleanedValue) ? parseInt(cleanedValue, 10) : value;
+    }
     if (fieldType === FieldTypes.boolean)
         return isTrue(value) ? true : false;
     if (fieldType === FieldTypes.enum && enumSet)

package/lib/esm/Importer/common/Spreadsheet/common/types.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="react" />
 import { DivCSSProps } from "../../../../styled";
-import { RecordDataSet, Field, SpreadsheetOptions, OnValidateRecord, Record } from "../../../../types";
-import { OnDataSetChanged, OnValidationStateChanged } from "../SpreadsheetContextProvider";
+import { Field, OnValidateRecord, Record, RecordDataSet, SpreadsheetOptions } from "../../../../types";
+import { OnDataSetChanged } from "../SpreadsheetContextProvider";
 export declare enum SortOrder {
     ASC = "asc",
     DESC = "desc"
@@ -18,7 +18,6 @@ export type SpreadsheetProps = {
     options?: SpreadsheetOptions;
     onValidateRecord?: OnValidateRecord;
     onDataSetChanged?: OnDataSetChanged;
-    onValidationStateChanged?: OnValidationStateChanged;
     selectedRows?: string[];
     setSelectedRows?: React.Dispatch<React.SetStateAction<string[]>>;
     getSortCompareFn?: (sortBy: SortBy) => (a: Record, b: Record) => number;

package/lib/esm/Importer/common/Spreadsheet/components/FieldHeader.d.ts

@@ -7,8 +7,6 @@ type SortIndicatorProps = {
 export declare const SortIndicator: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, import("../../../../styled/utils").CSSProps & SortIndicatorProps, never>;
 export type FieldHeaderProps = {
     field: Field;
-    sortByFieldErrors: (name: string) => void;
-    sortByFieldWarnings: (name: string) => void;
 };
 export declare const FieldHeader: React.FC<FieldHeaderProps>;
 export declare const chevronDown: JSX.Element;

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

@@ -14,11 +14,14 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import { colors } from "../../../../styled/theme/colorPalette";
+import { useEffect, useState } from "react";
 import styled, { css } from "styled-components";
 import { TooltipProvider } from "../../../../common";
+import { useEventManagerContext } from "../../../../common/EventManagerContextProvider";
+import { colors } from "../../../../styled/theme/colorPalette";
 import { Div } from "../../../../styled/utils";
-import { useSpreadsheetContext } from "../SpreadsheetContextProvider";
+import { useFilteredDataContext } from "../FilteredDataContextProvider";
+import { useValidationContext } from "../ValidationContextProvider";
 import { SortOrder } from "../common/types";
 var ErrorCount = styled(Div)(function (_a) {
     var _b = _a.theme, colors = _b.colors, c = _b.css;
@@ -28,11 +31,23 @@ export var SortIndicator = styled(Div)(templateObject_3 || (templateObject_3 = _
     return p.direction === SortOrder.ASC && css(templateObject_2 || (templateObject_2 = __makeTemplateObject(["\n      transform: rotate(180deg);\n    "], ["\n      transform: rotate(180deg);\n    "])));
 }, function (p) { return p.theme.colors.gray300; });
 export var FieldHeader = function (_a) {
-    var field = _a.field, sortByFieldErrors = _a.sortByFieldErrors, sortByFieldWarnings = _a.sortByFieldWarnings;
-    var _b = useSpreadsheetContext(), columnErrorCounts = _b.columnErrorCounts, columnWarningCounts = _b.columnWarningCounts, sortBy = _b.sortBy, spreadsheetFilter = _b.spreadsheetFilter, filteredInputValue = _b.filteredInputValue, setSortBy = _b.setSortBy;
-    var fieldErrorCount = columnErrorCounts[field.name];
-    var fieldWarningCount = columnWarningCounts[field.name];
-    var shouldRenderErrorCount = fieldErrorCount &&
+    var field = _a.field;
+    var _b = useValidationContext(), columnsWithErrorCounts = _b.columnsWithErrorCounts, columnsWithWarningCounts = _b.columnsWithWarningCounts;
+    var _c = useFilteredDataContext(), handleSortByFieldErrors = _c.handleSortByFieldErrors, handleSortByFieldWarnings = _c.handleSortByFieldWarnings, sortBy = _c.sortBy, setSortBy = _c.setSortBy, spreadsheetFilter = _c.spreadsheetFilter, filteredInputValue = _c.filteredInputValue;
+    var _d = useEventManagerContext(), on = _d.on, off = _d.off, EVENTS = _d.EVENTS;
+    var _e = useState(columnsWithErrorCounts.current[field.name] || null), fieldErrorCount = _e[0], setFieldErrorCount = _e[1];
+    var _f = useState(columnsWithWarningCounts.current[field.name] || null), fieldWarningCount = _f[0], setFieldWarningCount = _f[1];
+    useEffect(function () {
+        var listener = function () {
+            setFieldErrorCount(columnsWithErrorCounts.current[field.name] || null);
+        };
+        on(EVENTS.UPDATE_COLUMN_ERROR_COUNT, listener);
+        return function () {
+            off(EVENTS.UPDATE_COLUMN_ERROR_COUNT, listener);
+        };
+    }, []);
+    var shouldRenderErrorCount = fieldErrorCount !== null &&
+        fieldErrorCount > 0 &&
         filteredInputValue === "" &&
         spreadsheetFilter.type === "rowBased" &&
         spreadsheetFilter.byRow === "all";
@@ -50,16 +65,16 @@ export var FieldHeader = function (_a) {
             });
         }
     };
-    return (_jsxs(Div, __assign({ "data-test-id": "column-header-".concat(field.name), p: "0 16px", spaceBetween: true, w100: true, alignCenter: true, onClick: onHeaderClick }, { children: [_jsxs(Div, __assign({ dflex: true }, { children: [_jsxs(Div, __assign({ truncateText: true, selectNone: true }, { children: [field.label, field.isRequired && "*"] })), _jsx(Div, __assign({ ml: 8, centered: true }, { children: (sortBy === null || sortBy === void 0 ? void 0 : sortBy.field) === field.name && (_jsx(SortIndicator, __assign({ direction: sortBy === null || sortBy === void 0 ? void 0 : sortBy.direction }, { children: chevronDown }))) }))] })), shouldRenderErrorCount && (_jsx(TooltipProvider, __assign({ mr: 3, w: 35, tooltip: "Sort by ".concat(field.label, " errors") }, { children: _jsx(ErrorCount, __assign({ "data-test-id": "column-errors-count-".concat(field.name), onClick: function (ev) {
+    return (_jsxs(Div, __assign({ "data-cy": "column-header", "data-test-id": "column-header-".concat(field.name), p: "0 16px", spaceBetween: true, w100: true, alignCenter: true, onClick: onHeaderClick }, { children: [_jsxs(Div, __assign({ dflex: true }, { children: [_jsxs(Div, __assign({ truncateText: true, selectNone: true }, { children: [field.label, field.isRequired && "*"] })), _jsx(Div, __assign({ ml: 8, centered: true }, { children: (sortBy === null || sortBy === void 0 ? void 0 : sortBy.field) === field.name && (_jsx(SortIndicator, __assign({ direction: sortBy === null || sortBy === void 0 ? void 0 : sortBy.direction }, { children: chevronDown }))) }))] })), shouldRenderErrorCount && (_jsx(TooltipProvider, __assign({ mr: 3, w: 35, "data-cy": "tool-tip-message", tooltip: "Sort by ".concat(field.label, " errors") }, { children: _jsx(ErrorCount, __assign({ "data-cy": "column-error", "data-test-id": "column-errors-count-".concat(field.name), onClick: function (ev) {
                         ev.stopPropagation();
-                        sortByFieldErrors(field.name);
-                    } }, { children: _jsx(Div, __assign({ centered: true }, { children: _jsx(Div, __assign({ w: 35, textAlignCenter: true, label3: true, truncateText: true }, { children: fieldErrorCount })) })) })) }))), !fieldErrorCount && fieldWarningCount && (_jsx(TooltipProvider, __assign({ mr: 3, w: 35, tooltip: "Sort by ".concat(field.label, " errors") }, { children: _jsx(ErrorCount, __assign({ style: {
+                        handleSortByFieldErrors(field.name);
+                    } }, { children: _jsx(Div, __assign({ centered: true }, { children: _jsx(Div, __assign({ w: 35, textAlignCenter: true, label3: true, truncateText: true }, { children: fieldErrorCount })) })) })) }))), !fieldErrorCount && fieldWarningCount !== null && fieldWarningCount > 0 && (_jsx(TooltipProvider, __assign({ mr: 3, w: 35, tooltip: "Sort by ".concat(field.label, " errors") }, { children: _jsx(ErrorCount, __assign({ style: {
                         color: colors.orange1200,
                         background: colors.orange1100,
                         boxShadow: "0px 0px 0px 1px ".concat(colors.orange500, " inset"),
                     }, "data-test-id": "column-errors-count-".concat(field.name), onClick: function (ev) {
                         ev.stopPropagation();
-                        sortByFieldWarnings(field.name);
+                        handleSortByFieldWarnings(field.name);
                     } }, { children: _jsx(Div, __assign({ centered: true }, { children: _jsx(Div, __assign({ w: 35, textAlignCenter: true, label3: true, truncateText: true }, { children: fieldWarningCount })) })) })) })))] })));
 };
 export var chevronDown = (_jsx("svg", __assign({ width: "9", height: "5", viewBox: "0 0 9 5", fill: "none", xmlns: "http://www.w3.org/2000/svg" }, { children: _jsx("path", { d: "M4.31848 4.93945L0.421366 0.439453L8.2156 0.439454L4.31848 4.93945Z", fill: "#102622" }) })));

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,88 @@
+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);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+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 () { return __awaiter(void 0, void 0, void 0, function () {
+        var records;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, findAndReplaceInSpreadsheet(searchText, replaceText, matchCase, useRegex)];
+                case 1:
+                    records = _a.sent();
+                    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 [2 /*return*/];
+            }
+        });
+    }); };
+    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") }))] }))] })) })));
+};