fuse-importer 0.1.7-testing → 0.2.0-testing

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

@@ -0,0 +1,207 @@
+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 { useEffect, useState } from "react";
+import { fuseImporterId } from "../../../../common";
+import { useDataSetContext } from "../DataSetContextProvider";
+import { useFilteredDataContext } from "../FilteredDataContextProvider";
+import { useValidationContext } from "../ValidationContextProvider";
+import { useImporterContext } from "../../../contexts/ImporterContextProvider";
+import { useDataSetManipulation } from "./useDataSetManipulation";
+import { parseValue } from "../common";
+import { useSpreadsheetContext } from ".";
+export var defaultSelectionRect = {
+    start: { rowIndex: 0, colIndex: 0 },
+    end: { rowIndex: 0, colIndex: 0 },
+    initialCell: { rowIndex: 0, colIndex: 0 },
+};
+var getIframeBody = function (layoutRef) {
+    var iframeElement = document.getElementById(fuseImporterId);
+    var isCypressTestingEnv = !iframeElement.contentDocument;
+    if (isCypressTestingEnv)
+        return layoutRef.current;
+    return iframeElement.contentDocument.body;
+};
+export var useCellSelection = function (fields) {
+    var getRecord = useDataSetContext().getRecord;
+    var _a = useFilteredDataContext(), filteredDataIds = _a.filteredDataIds, isSortingOrFiltering = _a.isSortingOrFiltering;
+    var updateRecordAndRevalidate = useValidationContext().updateRecordAndRevalidate;
+    var layoutRef = useImporterContext().layoutRef;
+    var _b = useState(defaultSelectionRect), selectedCellRect = _b[0], setSelectedCellRect = _b[1];
+    var enumFieldValueMatchings = useImporterContext().enumFieldValueMatchings;
+    var isReadOnly = useSpreadsheetContext().isReadOnly;
+    var _c = useDataSetManipulation(), insertRecordsIntoSpreadsheet = _c.insertRecordsIntoSpreadsheet, addNewRecord = _c.addNewRecord;
+    useEffect(function () {
+        var iframeBody = getIframeBody(layoutRef);
+        iframeBody.addEventListener("paste", onPaste, true);
+        return function () {
+            iframeBody.removeEventListener("paste", onPaste, true);
+        };
+    }, [
+        selectedCellRect,
+        filteredDataIds,
+        isSortingOrFiltering,
+        enumFieldValueMatchings,
+        insertRecordsIntoSpreadsheet,
+        updateRecordAndRevalidate,
+        fields,
+    ]);
+    useEffect(function () {
+        var handleCopy = function () { return handleCopyCutOperation(false); };
+        var handleCut = function () { return handleCopyCutOperation(true); };
+        var iframeBody = getIframeBody(layoutRef);
+        iframeBody.addEventListener("copy", handleCopy);
+        iframeBody.addEventListener("cut", handleCut);
+        return function () {
+            iframeBody.removeEventListener("copy", handleCopy);
+            iframeBody.removeEventListener("cut", handleCut);
+        };
+    }, [selectedCellRect]);
+    var onPaste = function (event) { return __awaiter(void 0, void 0, void 0, function () {
+        var text, rows, maxCells, structuredData, startRowIndex, startColIndex, pastedRecordIds, newRecordId, pastedRecordValues;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (isReadOnly)
+                        return [2 /*return*/];
+                    text = event.clipboardData.getData("text");
+                    if (!text.includes("\t") && !text.includes("\n")) {
+                        return [2 /*return*/];
+                    }
+                    rows = text.split(/\r\n|\n|\r/);
+                    maxCells = rows.reduce(function (max, row) { return Math.max(max, row.split("\t").length); }, 0);
+                    structuredData = rows.map(function (row) {
+                        var cells = row.split("\t");
+                        while (cells.length < maxCells) {
+                            cells.push("");
+                        }
+                        return cells;
+                    });
+                    startRowIndex = selectedCellRect.start.rowIndex;
+                    startColIndex = selectedCellRect.start.colIndex;
+                    pastedRecordIds = filteredDataIds.slice(startRowIndex, startRowIndex + structuredData.length);
+                    if (!isSortingOrFiltering) {
+                        while (pastedRecordIds.length < structuredData.length) {
+                            newRecordId = addNewRecord();
+                            pastedRecordIds.push(newRecordId);
+                        }
+                    }
+                    pastedRecordValues = pastedRecordIds.map(function (id) { return (__assign({}, getRecord(id))); });
+                    structuredData.forEach(function (row, startRowIndex) {
+                        row.forEach(function (value, colIndex) {
+                            var field = fields[startColIndex + colIndex];
+                            if (!field)
+                                return;
+                            var pastedRecordValue = pastedRecordValues[startRowIndex];
+                            if (pastedRecordValue) {
+                                var enumSet = Object.keys(enumFieldValueMatchings).length > 0
+                                    ? enumFieldValueMatchings[field.label]
+                                    : field.options.reduce(function (acc, option) {
+                                        acc[option] = option;
+                                        return acc;
+                                    }, {});
+                                pastedRecordValue[field.name] = parseValue(field.type, value, enumSet);
+                            }
+                        });
+                    });
+                    if (!!isSortingOrFiltering) return [3 /*break*/, 2];
+                    return [4 /*yield*/, insertRecordsIntoSpreadsheet(pastedRecordValues)];
+                case 1:
+                    _a.sent();
+                    return [3 /*break*/, 4];
+                case 2: return [4 /*yield*/, updateRecordAndRevalidate(pastedRecordValues)];
+                case 3:
+                    _a.sent();
+                    _a.label = 4;
+                case 4:
+                    setSelectedCellRect({
+                        start: { rowIndex: startRowIndex, colIndex: startColIndex },
+                        end: {
+                            rowIndex: startRowIndex + structuredData.length - 1,
+                            colIndex: startColIndex + maxCells - 1,
+                        },
+                        initialCell: { rowIndex: startRowIndex, colIndex: startColIndex },
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+    var handleCopyCutOperation = function (isCut) {
+        var start = selectedCellRect.start, end = selectedCellRect.end;
+        var selectedCellsCount = (end.rowIndex - start.rowIndex + 1) * (end.colIndex - start.colIndex + 1);
+        if (selectedCellsCount <= 1)
+            return;
+        var updatedRecords = [];
+        var data = [];
+        for (var i = start.rowIndex; i <= end.rowIndex; i++) {
+            var rowData = [];
+            for (var j = start.colIndex; j <= end.colIndex; j++) {
+                var recordId = filteredDataIds[i];
+                var record = getRecord(recordId);
+                var cellData = record[fields[j].name];
+                rowData.push(cellData);
+                if (isCut) {
+                    record[fields[j].name] = "";
+                    updatedRecords.push(record);
+                }
+            }
+            data.push(rowData);
+        }
+        if (isCut)
+            updateRecordAndRevalidate(updatedRecords);
+        var clipboardText = data.map(function (row) { return row.join("\t"); }).join("\n");
+        navigator.clipboard.writeText(clipboardText);
+        setSelectedCellRect(__assign(__assign({}, selectedCellRect), { isDashed: true }));
+    };
+    useEffect(function () {
+        setSelectedCellRect(defaultSelectionRect);
+    }, [filteredDataIds]);
+    return {
+        selectedCellRect: selectedCellRect,
+        setSelectedCellRect: setSelectedCellRect,
+    };
+};

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

@@ -1,4 +1,8 @@
+import { Record } from "../../../../types";
 export declare const useDataSetManipulation: () => {
+    addNewRecord: () => string;
+    insertRecordsIntoSpreadsheet: (records: Record[]) => Promise<void>;
     appendNewRecordToSpreadsheet: () => void;
     deleteRecordsFromSpreadsheet: (recordIds: string[]) => void;
+    findAndReplaceInSpreadsheet: (searchText: string, replaceText: string, matchCase: boolean, useRegex: boolean) => Promise<any[]>;
 };

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

@@ -1,46 +1,152 @@
-import { useFilteredDataContext } from "../FilteredDataContextProvider";
-import { useDataSetContext } from "../DataSetContextProvider";
-import { hasValueInAnyField } from "./utils";
+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 { 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 { 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) { 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];
+            }
+        });
+    }); };
     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

@@ -58,10 +58,12 @@ 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";
+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) {
@@ -101,16 +103,23 @@ 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, 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 _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 = {};
         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 +186,7 @@ export var ValidationContextProvider = function (_a) {
                         else {
                             delete warnings.current[recordId];
                         }
-                        if (backendErrors) {
+                        if (backendErrors && spreadsheetInitialized) {
                             record._meta.backendErrors = {};
                         }
                         emit(recordId, newRecord);
@@ -191,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
@@ -244,7 +255,9 @@ export var ValidationContextProvider = function (_a) {
                             }); })];
                     case 3:
                         _a.sent();
-                        setIsLoadingApp(false);
+                        if (loadingIndicator) {
+                            setIsLoadingApp(false);
+                        }
                         return [2 /*return*/];
                 }
             });
@@ -252,21 +265,33 @@ export var ValidationContextProvider = function (_a) {
     };
     // Initial data validation and update dataSet
     useEffect(function () {
+        if (dataSet.current && !isReadOnly) {
+            resetDuplicateProvider();
+        }
         reset();
-        if (!dataSet.current || isReadOnly)
+    }, [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;
-        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();
-                        setSpreadsheetInitialized(true);
-                        return [2 /*return*/];
+                        undoTrackingEnabled.current = true;
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
                 }
             });
         }); };
@@ -276,12 +301,12 @@ export var ValidationContextProvider = function (_a) {
                     case 0: return [4 /*yield*/, initialValidation()];
                     case 1:
                         _a.sent();
-                        setIsLoadingApp(false);
+                        setSpreadsheetInitialized(true);
                         return [2 /*return*/];
                 }
             });
         }); })();
-    }, [dataSet.current]);
+    }, [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;