fuse-importer 0.1.8-testing → 0.2.0-testing

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

@@ -2,6 +2,7 @@ import React, { MutableRefObject } from "react";
 import { SpreadsheetFilter } from "../SpreadsheetContextProvider/useSpreadsheetFilter";
 import { SortBy } from "../common/types";
 export type State = {
+    isSortingOrFiltering: boolean;
     filteredDataIds: string[];
     filteredInputValue: string;
     setFilteredInputValue: (value: string) => void;

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

@@ -43,7 +43,7 @@ export var FilteredDataContextProvider = function (_a) {
     var _h = useState(false), recalculateFilters = _h[0], setRecalculateFilters = _h[1];
     var lastFilteredRecordId = useRef(null);
     var _j = useEventManagerContext(), on = _j.on, off = _j.off, EVENTS = _j.EVENTS;
-    var _k = useDataSetContext(), getRecord = _k.getRecord, dataSet = _k.dataSet;
+    var _k = useDataSetContext(), getRecord = _k.getRecord, dataSet = _k.dataSet, dataSetLength = _k.dataSetLength;
     var duplicateRecordIds = useDuplicateDataContext().duplicateRecordIds;
     var _l = useValidationContext(), errors = _l.errors, warnings = _l.warnings;
     var reset = function () {
@@ -127,7 +127,12 @@ export var FilteredDataContextProvider = function (_a) {
         setSortByFieldErrors(null);
         setSortBy(null);
     }, [sortByFieldWarnings]);
+    var isSortingOrFiltering = filteredDataIds.length !== dataSetLength.current ||
+        !!sortByFieldErrors ||
+        !!sortByFieldWarnings ||
+        !!sortBy;
     var value = {
+        isSortingOrFiltering: isSortingOrFiltering,
         filteredDataIds: filteredDataIds,
         filteredInputValue: filteredInputValue,
         setFilteredInputValue: setFilteredInputValue,

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

@@ -0,0 +1,7 @@
+import React from "react";
+export type State = {};
+export declare const KeyboardEventContext: React.Context<State>;
+export declare const KeyboardEventContextProvider: ({ children }: {
+    children: any;
+}) => JSX.Element;
+export declare const useDataSetContext: () => State;

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

@@ -0,0 +1,73 @@
+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 { useImporterContext } from "../../../../Importer/contexts/ImporterContextProvider";
+import { fuseImporterId } from "../../../../common";
+import { createContext, useContext, useEffect, } from "react";
+import { useUndoRedoContext } from "../UndoRedoContextProvider";
+import { useSearchContext } from "../SearchContextProvider";
+export var KeyboardEventContext = createContext({});
+export var KeyboardEventContextProvider = function (_a) {
+    var children = _a.children;
+    var layoutRef = useImporterContext().layoutRef;
+    var _b = useUndoRedoContext(), undo = _b.undo, redo = _b.redo;
+    var setFindAndReplaceModalOpen = useSearchContext().setFindAndReplaceModalOpen;
+    var openSearchInput = useSearchContext().openSearchInput;
+    var onKeyDown = function (e) {
+        // cmd+y
+        if (e.keyCode === 89 && (e.ctrlKey || e.metaKey)) {
+            e.preventDefault();
+            redo();
+        }
+        // cmd+shift+z
+        if (e.keyCode === 90 && (e.ctrlKey || e.metaKey) && e.shiftKey) {
+            e.preventDefault();
+            redo();
+        }
+        // cmd+z
+        if (e.keyCode === 90 && (e.ctrlKey || e.metaKey) && !e.shiftKey) {
+            e.preventDefault();
+            undo();
+        }
+        // cmd+f
+        if ((e.ctrlKey || e.metaKey) && !e.shiftKey && e.keyCode === 70) {
+            e.preventDefault();
+            openSearchInput();
+        }
+        // cmd+shift+f
+        if ((e.ctrlKey || e.metaKey) && e.shiftKey && e.keyCode === 70) {
+            e.preventDefault();
+            setFindAndReplaceModalOpen(true);
+        }
+    };
+    useEffect(function () {
+        var iframeElement = document.getElementById(fuseImporterId);
+        if (iframeElement.contentDocument) {
+            iframeElement.contentDocument.body.addEventListener("keydown", onKeyDown);
+        }
+        else {
+            // this is used in testing
+            layoutRef.current.addEventListener("keydown", onKeyDown);
+        }
+        return function () {
+            if (iframeElement.contentDocument) {
+                iframeElement.contentDocument.body.removeEventListener("keydown", onKeyDown);
+            }
+            else {
+                layoutRef.current.removeEventListener("keydown", onKeyDown);
+            }
+        };
+    }, [layoutRef.current]);
+    var value = {};
+    return (_jsx(KeyboardEventContext.Provider, __assign({ value: value }, { children: children })));
+};
+export var useDataSetContext = function () { return useContext(KeyboardEventContext); };

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

@@ -0,0 +1,15 @@
+import React from "react";
+export type State = {
+    findAndReplaceModalOpen: boolean;
+    setFindAndReplaceModalOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    isOpen: boolean;
+    setIsOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    openSearchInput: () => void;
+    closeSearchInput: () => void;
+    searchInputRef: React.MutableRefObject<HTMLInputElement>;
+};
+export declare const SearchContext: React.Context<State>;
+export declare const SearchContextProvider: ({ children }: {
+    children: any;
+}) => JSX.Element;
+export declare const useSearchContext: () => State;

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

@@ -0,0 +1,43 @@
+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, useState } from "react";
+export var SearchContext = createContext({});
+export var SearchContextProvider = function (_a) {
+    var children = _a.children;
+    var _b = useState(false), findAndReplaceModalOpen = _b[0], setFindAndReplaceModalOpen = _b[1];
+    var _c = useState(false), isOpen = _c[0], setIsOpen = _c[1];
+    var searchInputRef = useRef(null);
+    var openSearchInput = function () {
+        var _a;
+        if (!isOpen) {
+            setIsOpen(true);
+            if (searchInputRef === null || searchInputRef === void 0 ? void 0 : searchInputRef.current) {
+                (_a = searchInputRef.current) === null || _a === void 0 ? void 0 : _a.focus();
+            }
+        }
+    };
+    var closeSearchInput = function () {
+        setIsOpen(false);
+    };
+    var value = {
+        findAndReplaceModalOpen: findAndReplaceModalOpen,
+        setFindAndReplaceModalOpen: setFindAndReplaceModalOpen,
+        isOpen: isOpen,
+        setIsOpen: setIsOpen,
+        openSearchInput: openSearchInput,
+        searchInputRef: searchInputRef,
+        closeSearchInput: closeSearchInput,
+    };
+    return (_jsx(SearchContext.Provider, __assign({ value: value }, { children: children })));
+};
+export var useSearchContext = function () { return useContext(SearchContext); };

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

@@ -1,6 +1,7 @@
+import { Field, RecordDataSet } from "../../../../types";
 export declare const RecordHashCalculator: () => {
-    computeHashesForRecords: (dataSet: any, fields: any, _onHashesComputed: any) => void;
+    computeHashesForRecords: (dataSet: RecordDataSet, fields: Field[], _onHashesComputed: (x: any) => void) => Promise<void>;
 };
 export declare const RecordValueHashCalculator: () => {
-    computeDuplicateValueHashes: (dataSet: any, _field: any, _onDuplicateHashesComputed: any) => Promise<void>;
+    computeDuplicateValueHashes: (dataSet: RecordDataSet, _field: Field, _onDuplicateHashesComputed: (x: any[]) => void) => Promise<void>;
 };

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

@@ -74,21 +74,30 @@ export var RecordHashCalculator = function () {
         return hashMap;
     };
     var calculatingHashes = false;
-    var computeHashesForRecords = function (dataSet, fields, _onHashesComputed) {
-        if (!dataSet || calculatingHashes) {
-            return;
-        }
-        var processInBatches = useBatchProcessing().processInBatches;
-        calculatingHashes = true;
-        var results = [];
-        processInBatches(dataSet, function (batch) {
-            results = results.concat(computeHashesForBatch(batch, fields));
+    var computeHashesForRecords = function (dataSet, fields, _onHashesComputed) { return __awaiter(void 0, void 0, void 0, function () {
+        var processInBatches, results, duplicateHashes;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!dataSet || calculatingHashes) {
+                        return [2 /*return*/];
+                    }
+                    processInBatches = useBatchProcessing().processInBatches;
+                    calculatingHashes = true;
+                    results = [];
+                    return [4 /*yield*/, processInBatches(dataSet, function (batch) {
+                            results = results.concat(computeHashesForBatch(batch, fields));
+                        })];
+                case 1:
+                    _a.sent();
+                    results.sort(compareHashes);
+                    duplicateHashes = findDuplicateHashes(results);
+                    _onHashesComputed(duplicateHashes);
+                    calculatingHashes = false;
+                    return [2 /*return*/];
+            }
         });
-        results.sort(compareHashes);
-        var duplicateHashes = findDuplicateHashes(results);
-        _onHashesComputed(duplicateHashes);
-        calculatingHashes = false;
-    };
+    }); };
     return {
         computeHashesForRecords: computeHashesForRecords,
     };
@@ -117,19 +126,24 @@ export var RecordValueHashCalculator = function () {
     var computeDuplicateValueHashes = function (dataSet, _field, _onDuplicateHashesComputed) { return __awaiter(void 0, void 0, void 0, function () {
         var processInBatches, results;
         return __generator(this, function (_a) {
-            if (!dataSet || columnsBeingCalculated[_field.name]) {
-                return [2 /*return*/];
+            switch (_a.label) {
+                case 0:
+                    if (!dataSet || columnsBeingCalculated[_field.name]) {
+                        return [2 /*return*/];
+                    }
+                    columnsBeingCalculated[_field.name] = true;
+                    processInBatches = useBatchProcessing().processInBatches;
+                    results = [];
+                    return [4 /*yield*/, processInBatches(dataSet, function (batch) {
+                            results = results.concat(computeHashesForBatch(batch, _field));
+                        })];
+                case 1:
+                    _a.sent();
+                    results.sort(compareHashes);
+                    _onDuplicateHashesComputed(results);
+                    columnsBeingCalculated[_field.name] = false;
+                    return [2 /*return*/];
             }
-            columnsBeingCalculated[_field.name] = true;
-            processInBatches = useBatchProcessing().processInBatches;
-            results = [];
-            processInBatches(dataSet, function (batch) {
-                results = results.concat(computeHashesForBatch(batch, _field));
-            });
-            results.sort(compareHashes);
-            _onDuplicateHashesComputed(results);
-            columnsBeingCalculated[_field.name] = false;
-            return [2 /*return*/];
         });
     }); };
     return {

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

@@ -2,6 +2,7 @@ import React from "react";
 import { SpreadsheetOptions } from "../../../..";
 import { Field, RecordDataSet } from "../../../../types";
 import { SpreadsheetProps } from "../common/types";
+import { CellSelectionState } from "./useCellSelection";
 export type OnDataSetChanged = (dataSet: RecordDataSet) => void;
 type State = {
     filteredDataIds: string[];
@@ -14,7 +15,7 @@ type State = {
     checkboxColumnWidth: number;
     inefficientRerender: boolean;
     setInefficientRerender: React.Dispatch<React.SetStateAction<boolean>>;
-};
+} & CellSelectionState;
 type Props = SpreadsheetProps & {
     children: JSX.Element;
 };

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

@@ -24,6 +24,7 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { createContext, useContext, useMemo, useRef, useState, } from "react";
 import { useFilteredDataContext } from "../FilteredDataContextProvider";
 import { useValidationContext } from "../ValidationContextProvider";
+import { useCellSelection } from "./useCellSelection";
 var SpreadsheetContext = createContext({});
 export var SpreadsheetContextProvider = function (_a) {
     var fields = _a.fields, options = _a.options, isReadOnly = _a.isReadOnly, children = _a.children, onValidateRecord = _a.onValidateRecord, selectedRows = _a.selectedRows, setSelectedRows = _a.setSelectedRows;
@@ -38,7 +39,7 @@ export var SpreadsheetContextProvider = function (_a) {
         var baseCheckboxColumnWidth = lastRowIndexLength * singleLetterWidth + horizontalSpacing;
         return baseCheckboxColumnWidth < 40 ? 40 : baseCheckboxColumnWidth;
     }, [filteredDataIds.length]);
-    var value = __assign(__assign({ filteredDataIds: filteredDataIds, fields: fields }, validationState), { isReadOnly: isReadOnly, options: options, onValidateRecord: onValidateRecord, selectedRows: selectedRows, setSelectedRows: setSelectedRows, lastClickedIndexRef: lastClickedIndexRef, checkboxColumnWidth: checkboxColumnWidth, inefficientRerender: inefficientRerender, setInefficientRerender: setInefficientRerender });
+    var value = __assign(__assign(__assign({ filteredDataIds: filteredDataIds, fields: fields }, validationState), { isReadOnly: isReadOnly, options: options, onValidateRecord: onValidateRecord, selectedRows: selectedRows, setSelectedRows: setSelectedRows, lastClickedIndexRef: lastClickedIndexRef, checkboxColumnWidth: checkboxColumnWidth, inefficientRerender: inefficientRerender, setInefficientRerender: setInefficientRerender }), useCellSelection(fields));
     return (_jsx(SpreadsheetContext.Provider, __assign({ value: value }, { children: children })));
 };
 export var useSpreadsheetContext = function () { return useContext(SpreadsheetContext); };

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

@@ -1,5 +1,5 @@
 import { Record, RecordDataSet } from "../../../../types";
 export declare const useBatchProcessing: (batchPageSize?: number) => {
-    processRecordsInBatches: (records: Record[], handleBatch: any) => Promise<void>;
-    processInBatches: (dataSet: RecordDataSet, handleBatch: any) => void;
+    processRecordsInBatches: (records: Record[], handleBatch: (x: any) => void) => Promise<void>;
+    processInBatches: (dataSet: RecordDataSet, handleBatch: (x: any) => void) => Promise<void>;
 };

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

@@ -61,10 +61,19 @@ export var useBatchProcessing = function (batchPageSize) {
             }
         });
     }); };
-    var processInBatches = function (dataSet, handleBatch) {
-        var records = Object.values(dataSet);
-        processRecordsInBatches(records, handleBatch);
-    };
+    var processInBatches = function (dataSet, handleBatch) { return __awaiter(void 0, void 0, void 0, function () {
+        var records;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    records = Object.values(dataSet);
+                    return [4 /*yield*/, processRecordsInBatches(records, handleBatch)];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); };
     return {
         processRecordsInBatches: processRecordsInBatches,
         processInBatches: processInBatches,

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

@@ -0,0 +1,24 @@
+/// <reference types="react" />
+import { Field } from "../../../../types";
+export type SelectedCellRect = {
+    start: {
+        rowIndex: number;
+        colIndex: number;
+    };
+    end: {
+        rowIndex: number;
+        colIndex: number;
+    };
+    initialCell: {
+        rowIndex: number;
+        colIndex: number;
+    };
+    isDashed?: boolean;
+    editMode?: boolean;
+};
+export declare const defaultSelectionRect: SelectedCellRect;
+export type CellSelectionState = {
+    selectedCellRect: SelectedCellRect;
+    setSelectedCellRect: React.Dispatch<React.SetStateAction<SelectedCellRect>>;
+};
+export declare const useCellSelection: (fields?: Field[]) => CellSelectionState;

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,5 +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) => any[];
+    findAndReplaceInSpreadsheet: (searchText: string, replaceText: string, matchCase: boolean, useRegex: boolean) => Promise<any[]>;
 };