fuse-importer 0.1.8-testing → 0.2.0-testing

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

@@ -9,65 +9,142 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-import { useFilteredDataContext } from "../FilteredDataContextProvider";
-import { useDataSetContext } from "../DataSetContextProvider";
-import { hasValueInAnyField } from "./utils";
+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 { useImporterContext } from "../../../../Importer/contexts/ImporterContextProvider";
 import { addMeta } from "../../../../Importer/data";
 import { useEventManagerContext } from "../../../../common/EventManagerContextProvider";
-import { useValidationContext } from "../ValidationContextProvider";
+import useFindAndReplace from "../../../../common/Table/TableActions/useFindAndReplace";
+import { useDataSetContext } from "../DataSetContextProvider";
 import { useDuplicateDataContext } from "../DuplicateDataContextProvider";
+import { useFilteredDataContext } from "../FilteredDataContextProvider";
+import { useUndoRedoContext } from "../UndoRedoContextProvider";
+import { useValidationContext } from "../ValidationContextProvider";
 import { useBatchProcessing } from "./useBatchProcessing";
-import useFindAndReplace from "../../../../common/Table/TableActions/useFindAndReplace";
+import { hasValueInAnyField } from "./utils";
 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;
+    var _b = useDataSetContext(), getRecord = _b.getRecord, setRecord = _b.setRecord, dataSet = _b.dataSet, deleteRecord = _b.deleteRecord, emptyRecordIds = _b.emptyRecordIds, dataSetLength = _b.dataSetLength;
     var _c = useEventManagerContext(), emit = _c.emit, EVENTS = _c.EVENTS;
     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 trackRecordDeletion = useUndoRedoContext().trackRecordDeletion;
+    var layoutRef = useImporterContext().layoutRef;
+    var addNewRecord = function () {
+        var newRow = addMeta({}, dataSetLength.current);
+        setRecord(newRow._meta.id, newRow);
+        return newRow._meta.id;
+    };
     var appendNewRecordToSpreadsheet = function () {
-        var _a, _b;
         var _record = getRecord(lastFilteredRecordId.current);
         if (!hasValueInAnyField(_record)) {
             return;
         }
-        var highestRowIndex = -1;
-        for (var recordId in dataSet.current)
-            if (((_b = (_a = getRecord(recordId)) === null || _a === void 0 ? void 0 : _a._meta) === null || _b === void 0 ? void 0 : _b.rowIndex) > highestRowIndex)
-                highestRowIndex = getRecord(recordId)._meta.rowIndex;
-        var newRow = addMeta({}, highestRowIndex + 1);
-        setRecord(newRow._meta.id, newRow);
+        addNewRecord();
         emit(EVENTS.ON_LAST_ROW_CHANGED);
     };
+    var insertRecordsIntoSpreadsheet = function (records) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    records.forEach(function (record) {
+                        setRecord(record._meta.id, { _meta: record._meta });
+                    });
+                    return [4 /*yield*/, updateRecordAndRevalidate(records)];
+                case 1:
+                    _a.sent();
+                    setRecalculateFilters(function (prev) { return !prev; });
+                    emit(EVENTS.UPDATE_COLUMN_ERROR_COUNT);
+                    emit(EVENTS.UPDATE_TOTAL_ERROR_COUNT);
+                    emit(EVENTS.UPDATE_TOTAL_ROW_COUNT);
+                    layoutRef.current.querySelector(".input-content").focus();
+                    return [2 /*return*/];
+            }
+        });
+    }); };
     var deleteRecordsFromSpreadsheet = function (recordIds) {
+        trackRecordDeletion(recordIds, insertRecordsIntoSpreadsheet, function (records) {
+            var ids = records.map(function (r) { return r._meta.id; });
+            deleteRecordsFromSpreadsheet(ids);
+        });
+        var records = [];
         recordIds.forEach(function (recordId) {
+            records.push(getRecord(recordId));
             updateDuplicateValues(getRecord(recordId), {}, false, updateRecordAndRevalidate);
             deleteRecord(recordId);
             calculateColumnErrorCounts(errors.current[recordId], {});
             calculateColumnWarningCounts(warnings.current[recordId], {});
+            delete errors.current[recordId];
+            delete warnings.current[recordId];
             emptyRecordIds.current.delete(recordId);
         });
         setRecalculateFilters(function (prev) { return !prev; });
         emit(EVENTS.UPDATE_COLUMN_ERROR_COUNT);
         emit(EVENTS.UPDATE_TOTAL_ERROR_COUNT);
         emit(EVENTS.UPDATE_TOTAL_ROW_COUNT);
+        layoutRef.current.querySelector(".input-content input").focus();
     };
-    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);
-                }
+    var findAndReplaceInSpreadsheet = function (searchText, replaceText, matchCase, useRegex) { return __awaiter(void 0, void 0, void 0, function () {
+        var cellsWithText;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    cellsWithText = [];
+                    return [4 /*yield*/, processInBatches(dataSet.current, function (batch) {
+                            for (var recordKey in batch) {
+                                var record = __assign({}, batch[recordKey]);
+                                if (replaceInRecord(record, searchText, replaceText, matchCase, useRegex)) {
+                                    cellsWithText.push(record);
+                                }
+                            }
+                        })];
+                case 1:
+                    _a.sent();
+                    updateRecordAndRevalidate(cellsWithText);
+                    return [2 /*return*/, cellsWithText];
             }
         });
-        updateRecordAndRevalidate(cellsWithText);
-        return cellsWithText;
-    };
+    }); };
     return {
+        addNewRecord: addNewRecord,
+        insertRecordsIntoSpreadsheet: insertRecordsIntoSpreadsheet,
         appendNewRecordToSpreadsheet: appendNewRecordToSpreadsheet,
         deleteRecordsFromSpreadsheet: deleteRecordsFromSpreadsheet,
         findAndReplaceInSpreadsheet: findAndReplaceInSpreadsheet,

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

@@ -0,0 +1,16 @@
+import { MutableRefObject } from "react";
+import { Record } from "../../../../types";
+type ContextArgs = {
+    children: any;
+};
+type State = {
+    trackRecordChanges: (records: Record[], undo: any, redo: any) => void;
+    trackRecordDeletion: (recordIds: string[], undo: any, redo: any) => void;
+    undoTrackingEnabled: MutableRefObject<boolean>;
+    undo: () => void;
+    redo: () => void;
+};
+export declare const UndoRedoContext: import("react").Context<State>;
+export declare const UndoRedoContextProvider: ({ children }: ContextArgs) => JSX.Element;
+export declare const useUndoRedoContext: () => State;
+export {};

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

@@ -0,0 +1,104 @@
+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 } from "react/jsx-runtime";
+import { createContext, useContext, useRef, } from "react";
+import { useDataSetContext } from "../DataSetContextProvider";
+import { useImporterContext } from "../../../../Importer/contexts/ImporterContextProvider";
+export var UndoRedoContext = createContext({});
+export var UndoRedoContextProvider = function (_a) {
+    var children = _a.children;
+    var changeStack = useRef([]);
+    var getRecord = useDataSetContext().getRecord;
+    var stackPointer = useRef(0);
+    var undoTrackingEnabled = useRef(false);
+    var layoutRef = useImporterContext().layoutRef;
+    var changeStackSizeLimit = 15;
+    var undo = function () {
+        var topItem = changeStack.current[stackPointer.current];
+        if (!topItem)
+            return;
+        var records = [];
+        for (var key in topItem.changes) {
+            var change = topItem.changes[key];
+            records.push(change.oldRecord);
+        }
+        undoTrackingEnabled.current = false;
+        topItem.undo(records);
+        undoTrackingEnabled.current = true;
+        stackPointer.current -= 1;
+    };
+    var redo = function () {
+        if (stackPointer.current >= changeStack.current.length - 1) {
+            return;
+        }
+        stackPointer.current += 1;
+        var topItem = changeStack.current[stackPointer.current];
+        var records = [];
+        for (var key in topItem.changes) {
+            var change = topItem.changes[key];
+            records.push(change.newRecord);
+        }
+        undoTrackingEnabled.current = false;
+        topItem.redo(records);
+        undoTrackingEnabled.current = true;
+    };
+    var trackRecordChanges = function (records, undo, redo) {
+        if (!undoTrackingEnabled.current)
+            return;
+        var recordChanges = [];
+        for (var key in records) {
+            recordChanges.push({
+                oldRecord: __assign({}, getRecord(records[key]._meta.id)),
+                newRecord: __assign({}, records[key]),
+            });
+        }
+        var change = {
+            type: "records_changed",
+            changes: recordChanges,
+            undo: undo,
+            redo: redo,
+        };
+        trackChange(change);
+        stackPointer.current = changeStack.current.length - 1;
+    };
+    var trackRecordDeletion = function (recordIds, undo, redo) {
+        var recordChanges = [];
+        recordIds.forEach(function (recordId) {
+            recordChanges.push({
+                oldRecord: __assign({}, getRecord(recordId)),
+                newRecord: __assign({}, getRecord(recordId)),
+            });
+        });
+        var change = {
+            type: "records_deleted",
+            changes: recordChanges,
+            undo: undo,
+            redo: redo,
+        };
+        trackChange(change);
+        stackPointer.current = changeStack.current.length - 1;
+    };
+    var trackChange = function (change) {
+        changeStack.current.push(change);
+        // limit the number of items we keep in memory
+        changeStack.current = changeStack.current.slice(Math.max(changeStack.current.length - changeStackSizeLimit, 0));
+    };
+    var value = {
+        trackRecordChanges: trackRecordChanges,
+        trackRecordDeletion: trackRecordDeletion,
+        undoTrackingEnabled: undoTrackingEnabled,
+        undo: undo,
+        redo: redo,
+    };
+    return (_jsx(UndoRedoContext.Provider, __assign({ value: value }, { children: children })));
+};
+export var useUndoRedoContext = function () { return useContext(UndoRedoContext); };

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

@@ -22,7 +22,7 @@ export type ValidationState = {
     calculateColumnWarningCounts?: CalculateColumnCount;
 };
 type UseValidationStateReturnValue = ValidationState & {
-    updateRecordAndRevalidate: (record: Record | Record[], initialValidation?: boolean) => Promise<void>;
+    updateRecordAndRevalidate: (record: Record | Record[], initialValidation?: boolean, loadingIndicator?: boolean) => Promise<void>;
     spreadsheetInitialized: boolean;
 };
 export declare const ValidationContext: import("react").Context<UseValidationStateReturnValue>;

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

@@ -63,6 +63,7 @@ import { useDataSetContext } from "../DataSetContextProvider";
 import { useDuplicateDataContext } from "../DuplicateDataContextProvider";
 import { useBatchProcessing } from "../SpreadsheetContextProvider/useBatchProcessing";
 import { selectValidatorsFor, validateRecord } from "../validation";
+import { useUndoRedoContext } from "../UndoRedoContextProvider";
 // 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) {
@@ -103,12 +104,13 @@ export var ValidationContextProvider = function (_a) {
     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;
-    var _e = useDuplicateDataContext(), duplicateValues = _e.duplicateValues, updateDuplicateValues = _e.updateDuplicateValues;
+    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 _g = useImporterContext(), currentStepIndex = _g.currentStepIndex, templateSlug = _g.templateSlug;
+    var _h = useState(false), dataSetChanged = _h[0], setDataSetChanged = _h[1];
+    var _j = useUndoRedoContext(), trackRecordChanges = _j.trackRecordChanges, undoTrackingEnabled = _j.undoTrackingEnabled;
     var reset = function () {
         columnsWithErrorCounts.current = {};
         columnsWithWarningCounts.current = {};
@@ -198,16 +200,18 @@ export var ValidationContextProvider = function (_a) {
         setValidationPercentage(Math.round((validationPercentage + Number.EPSILON) * 10) / 10);
     };
     // Validate record and update dataSet
-    var updateRecordAndRevalidate = function (records, initialValidation) {
+    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];
+                        trackRecordChanges(recordsArray, updateRecordAndRevalidate, updateRecordAndRevalidate);
                         length = recordsArray.length;
-                        if (!(length > 10000)) return [3 /*break*/, 2];
+                        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
@@ -251,7 +255,9 @@ export var ValidationContextProvider = function (_a) {
                             }); })];
                     case 3:
                         _a.sent();
-                        setIsLoadingApp(false);
+                        if (loadingIndicator) {
+                            setIsLoadingApp(false);
+                        }
                         return [2 /*return*/];
                 }
             });
@@ -259,22 +265,33 @@ export var ValidationContextProvider = function (_a) {
     };
     // Initial data validation and update dataSet
     useEffect(function () {
+        if (dataSet.current && !isReadOnly) {
+            resetDuplicateProvider();
+        }
         reset();
     }, [dataSet.current]);
     useEffect(function () {
-        if (!dataSet.current || isReadOnly || currentStepIndex !== 2)
+        var isDataSetInvalid = !dataSet.current || dataSetLength.current === 0;
+        if (isDataSetInvalid ||
+            isReadOnly ||
+            currentStepIndex !== 2 ||
+            (fields === null || fields === void 0 ? void 0 : fields.length) === 0)
             return;
-        setIsLoadingApp(true);
         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);
+                        undoTrackingEnabled.current = false;
                         return [4 /*yield*/, updateRecordAndRevalidate(initialData, true)];
                     case 1:
                         _a.sent();
-                        return [2 /*return*/];
+                        undoTrackingEnabled.current = true;
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
                 }
             });
         }); };
@@ -284,13 +301,12 @@ export var ValidationContextProvider = function (_a) {
                     case 0: return [4 /*yield*/, initialValidation()];
                     case 1:
                         _a.sent();
-                        setIsLoadingApp(false);
                         setSpreadsheetInitialized(true);
                         return [2 /*return*/];
                 }
             });
         }); })();
-    }, [spreadsheetInitialized, currentStepIndex, dataSetChanged]);
+    }, [currentStepIndex, dataSetChanged]);
     var isValidationCompleted = validationPercentage === 100;
     var isValid = isValidationCompleted && totalErrorCount.current === 0;
     var value = {

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

@@ -1,4 +1,4 @@
-import { Record, Field, FieldTypes } from "../../../../types";
+import { Field, FieldTypes, Record } from "../../../../types";
 export declare const spreadsheetRowHeightPx = 40;
 export declare const spreadsheetHeaderHeightPx = 40;
 export declare const isNullOrUndefined: (value: any) => boolean;

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

@@ -11,7 +11,7 @@ export var isEmpty = function (value) {
             (value.length === 0 || value.trim().length === 0)));
 };
 export var isEmail = function (value) {
-    var emailRegex = /^[\w+.-]+@([\w-]+\.)+[\w-]{2,4}$/;
+    var emailRegex = /^[\w+.-]+@([\w-]+\.)+[\w-]+$/;
     return emailRegex.test(value);
 };
 export var isUrl = function (value) {
@@ -52,10 +52,18 @@ export var isRecordEmpty = function (record, fields) {
 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/components/FindAndReplace/index.js

@@ -9,13 +9,49 @@ var __assign = (this && this.__assign) || function () {
     };
     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 { useEffect, useRef, useState } from "react";
 import { useDataSetManipulation } from "../../SpreadsheetContextProvider/useDataSetManipulation";
 import { useFilteredDataContext } from "../../FilteredDataContextProvider";
 export var FindAndReplaceModal = function (_a) {
@@ -27,18 +63,32 @@ export var FindAndReplaceModal = function (_a) {
     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") }))] }))] })) })));
+    var findRef = useRef();
+    useEffect(function () {
+        if (!findRef.current)
+            return;
+        findRef.current.focus();
+    }, [findRef.current]);
+    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, { setInputRef: findRef, "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/SpreadsheetData/CellContextProvider.d.ts

@@ -0,0 +1,23 @@
+import React from "react";
+import { css } from "styled-components";
+type SelectionProps = {
+    onClick: (e: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
+    onDragStart: (e: React.DragEvent<HTMLDivElement>) => void;
+    onDragEnd: () => void;
+    onDragOver: () => void;
+    onBlur: () => void;
+    draggable: boolean;
+};
+type State = {
+    isSelected: boolean;
+    selectedCellStyles: ReturnType<typeof css>;
+    selectionProps: SelectionProps | {};
+};
+type Props = {
+    children: JSX.Element;
+    rowIndex: number;
+    colIndex: number;
+};
+export declare const CellContextProvider: ({ children, rowIndex, colIndex, }: Props) => JSX.Element;
+export declare const useCellContext: () => State;
+export {};