fuse-importer 0.1.4-testing → 0.1.5-testing

package/lib/esm/Importer/hooks/useSubmitToServer.js

@@ -0,0 +1,192 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { useState } from "react";
+import { useImporterContext, } from "../contexts/ImporterContextProvider";
+import { isRecordEmpty } from "../../Importer/common/Spreadsheet/common";
+import { sendRecordsToIntegrations } from "../../Importer/common/utils";
+import { getTemplateFields, recordListToDataSet } from "../../Importer/data";
+var trackImportedRowsCount = function (fuseApi, templateSlug, rowCount) { return __awaiter(void 0, void 0, void 0, function () {
+    var error_1, errorMessage;
+    var _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _c.trys.push([0, 2, , 3]);
+                return [4 /*yield*/, fuseApi.post("/api/v1/importer/templates/".concat(templateSlug, "/imports"), {
+                        row_count: rowCount,
+                    })];
+            case 1:
+                _c.sent();
+                return [3 /*break*/, 3];
+            case 2:
+                error_1 = _c.sent();
+                errorMessage = ((_b = (_a = error_1 === null || error_1 === void 0 ? void 0 : error_1.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.error) ||
+                    "There was an error submitting your dataset";
+                throw new Error(errorMessage);
+            case 3: return [2 /*return*/];
+        }
+    });
+}); };
+var buildColumnMappingsFromHeaderMatchings = function (templateHeaders, templateHeaderMatchings) {
+    return templateHeaders.map(function (column) {
+        return {
+            matched_column_name: templateHeaderMatchings[column.label],
+            template_column_name: column.label,
+        };
+    });
+};
+var saveMappedColumns = function (columnMappings, fuseApi, templateSlug) { return __awaiter(void 0, void 0, void 0, function () {
+    var error_2;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                _a.trys.push([0, 2, , 3]);
+                return [4 /*yield*/, fuseApi.patch("/api/v1/importer/templates/".concat(templateSlug), {
+                        column_mappings_attributes: columnMappings,
+                    })];
+            case 1:
+                _a.sent();
+                return [3 /*break*/, 3];
+            case 2:
+                error_2 = _a.sent();
+                throw new Error("There was an error trying to save column mappings");
+            case 3: return [2 /*return*/];
+        }
+    });
+}); };
+var getImportWasSuccessful = function (response) {
+    return !response.errors || !Object.keys(response.errors).length;
+};
+var filterAndMapWithBackendErrors = function (dataSet, errors) {
+    return Object.keys(errors).map(function (rId) {
+        var record = dataSet[rId];
+        var meta = record === null || record === void 0 ? void 0 : record._meta;
+        return __assign(__assign({}, record), { _meta: __assign(__assign({}, meta), { isInvalid: true, backendErrors: errors[rId] }) });
+    }, []);
+};
+export var useSubmitToServer = function () {
+    var _a = useImporterContext(), templateHeaderMatchings = _a.templateHeaderMatchings, templateHeaders = _a.templateHeaders, integrations = _a.integrations, templateSlug = _a.templateSlug, fuseApi = _a.fuseApi, previewMode = _a.importerOptions.previewMode, onSubmit = _a.onSubmit;
+    var _b = useState(false), isSubmitting = _b[0], setIsSubmitting = _b[1];
+    var _c = useState(false), importWasSuccessful = _c[0], setImportWasSuccessful = _c[1];
+    var _d = useState(null), appResponse = _d[0], setAppResponse = _d[1];
+    var onSubmitToServer = function (dataSet, afterSubmitCallback) { return __awaiter(void 0, void 0, void 0, function () {
+        var dataSetValues, reviewFields_1, validDataSetValues, validDataSetLength, invalidRecords_1, applicationResponse, isAppResponseSuccessful, _a, errors, isDataValid, recordsToDisplayFiltered, invalidDataSet, columnMappings, error_3;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 6, 7, 8]);
+                    if (!dataSet)
+                        return [2 /*return*/];
+                    setIsSubmitting(true);
+                    dataSetValues = Object.values(dataSet);
+                    reviewFields_1 = getTemplateFields({ templateHeaders: templateHeaders });
+                    validDataSetValues = dataSetValues.filter(function (record) {
+                        return !record._meta.isInvalid && !isRecordEmpty(record, reviewFields_1);
+                    });
+                    validDataSetLength = validDataSetValues.length;
+                    invalidRecords_1 = dataSetValues.filter(function (v) { return v._meta.isInvalid; });
+                    return [4 /*yield*/, onSubmit(validDataSetValues)];
+                case 1:
+                    applicationResponse = _b.sent();
+                    isAppResponseSuccessful = getImportWasSuccessful(applicationResponse);
+                    if (!isAppResponseSuccessful) {
+                        _a = (applicationResponse !== null && applicationResponse !== void 0 ? applicationResponse : {}).errors, errors = _a === void 0 ? {} : _a;
+                        invalidRecords_1 = __spreadArray(__spreadArray([], filterAndMapWithBackendErrors(dataSet, errors), true), invalidRecords_1, true);
+                    }
+                    isDataValid = invalidRecords_1.length === 0;
+                    setImportWasSuccessful(isDataValid && isAppResponseSuccessful);
+                    setAppResponse(applicationResponse);
+                    if (applicationResponse.recordsToDisplay) {
+                        recordsToDisplayFiltered = applicationResponse.recordsToDisplay.filter(function (record) {
+                            var recordId = record._meta.id;
+                            return !invalidRecords_1.some(function (invalidRecord) { return invalidRecord._meta.id === recordId; });
+                        });
+                        invalidRecords_1 = __spreadArray(__spreadArray([], invalidRecords_1, true), (recordsToDisplayFiltered || []), true);
+                    }
+                    invalidDataSet = recordListToDataSet(invalidRecords_1, reviewFields_1);
+                    afterSubmitCallback(invalidDataSet);
+                    if (!!previewMode) return [3 /*break*/, 5];
+                    return [4 /*yield*/, trackImportedRowsCount(fuseApi, templateSlug, validDataSetLength)];
+                case 2:
+                    _b.sent();
+                    return [4 /*yield*/, sendRecordsToIntegrations(dataSetValues, integrations)];
+                case 3:
+                    _b.sent();
+                    columnMappings = buildColumnMappingsFromHeaderMatchings(templateHeaders, templateHeaderMatchings);
+                    return [4 /*yield*/, saveMappedColumns(columnMappings, fuseApi, templateSlug)];
+                case 4:
+                    _b.sent();
+                    _b.label = 5;
+                case 5: return [3 /*break*/, 8];
+                case 6:
+                    error_3 = _b.sent();
+                    console.error(error_3);
+                    return [3 /*break*/, 8];
+                case 7:
+                    setIsSubmitting(false);
+                    return [7 /*endfinally*/];
+                case 8: return [2 /*return*/];
+            }
+        });
+    }); };
+    return {
+        appResponse: appResponse,
+        isSubmitting: isSubmitting,
+        onSubmitToServer: onSubmitToServer,
+        importWasSuccessful: importWasSuccessful,
+    };
+};

package/lib/esm/common/EventManagerContextProvider/index.d.ts

@@ -0,0 +1,22 @@
+import { EventEmitter } from "eventemitter3";
+import React from "react";
+declare const EVENTS: {
+    ON_LAST_ROW_CHANGED: string;
+    UPDATE_COLUMN_ERROR_COUNT: string;
+    UPDATE_TOTAL_ERROR_COUNT: string;
+    UPDATE_TOTAL_ROW_COUNT: string;
+};
+type CallbackType = EventEmitter.EventListener<EventEmitter.ValidEventTypes, any>;
+export type State = {
+    on: (event: string, callback: CallbackType) => void;
+    off: (event: string, callback: CallbackType) => void;
+    emit: (event: string, value?: any) => void;
+    emitter: React.MutableRefObject<EventEmitter>;
+    EVENTS: typeof EVENTS;
+};
+export declare const EventManagerContext: React.Context<State>;
+export declare const EventManagerContextProvider: ({ children }: {
+    children: any;
+}) => JSX.Element;
+export declare const useEventManagerContext: () => State;
+export {};

package/lib/esm/common/EventManagerContextProvider/index.js

@@ -0,0 +1,38 @@
+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 { EventEmitter } from "eventemitter3";
+import { createContext, useContext, useRef } from "react";
+var EVENTS = {
+    ON_LAST_ROW_CHANGED: "ON_LAST_ROW_CHANGED",
+    UPDATE_COLUMN_ERROR_COUNT: "UPDATE_COLUMN_ERROR_COUNT",
+    UPDATE_TOTAL_ERROR_COUNT: "UPDATE_TOTAL_ERROR_COUNT",
+    UPDATE_TOTAL_ROW_COUNT: "UPDATE_TOTAL_ROW_COUNT",
+};
+export var EventManagerContext = createContext({});
+export var EventManagerContextProvider = function (_a) {
+    var children = _a.children;
+    var emitter = useRef(new EventEmitter());
+    var on = function (event, callback) {
+        return emitter.current.on(event, callback);
+    };
+    var off = function (event, callback) {
+        return emitter.current.off(event, callback);
+    };
+    var emit = function (event, value) {
+        if (value === void 0) { value = null; }
+        return emitter.current.emit(event, value);
+    };
+    var value = { on: on, off: off, emit: emit, emitter: emitter, EVENTS: EVENTS };
+    return (_jsx(EventManagerContext.Provider, __assign({ value: value }, { children: children })));
+};
+export var useEventManagerContext = function () { return useContext(EventManagerContext); };

package/lib/esm/common/FileUploadDropzone/ImporterDropzone.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+export interface DropzoneProps {
+    onComplete: (results: any) => void;
+    saveFileName: (fileName: string) => void;
+    setIsLoading?: React.Dispatch<boolean>;
+}
+interface UseDragAndDropProps extends DropzoneProps {
+    validHeadersCount?: (headersLength: number) => boolean;
+}
+export declare const useDragAndDrop: ({ onComplete, saveFileName, setIsLoading, validHeadersCount, }: UseDragAndDropProps) => {
+    getRootProps: <T extends import("react-dropzone").DropzoneRootProps>(props?: T) => T;
+    getInputProps: <T_1 extends import("react-dropzone").DropzoneInputProps>(props?: T_1) => T_1;
+    open: () => void;
+    isDragActive: boolean;
+};
+export {};

package/lib/esm/common/FileUploadDropzone/ImporterDropzone.js

@@ -0,0 +1,108 @@
+import { useDropzone } from "react-dropzone";
+import { addToast } from "../Toast";
+import Papa from "papaparse";
+import * as XLSX from "xlsx";
+export var useDragAndDrop = function (_a) {
+    var onComplete = _a.onComplete, saveFileName = _a.saveFileName, setIsLoading = _a.setIsLoading, validHeadersCount = _a.validHeadersCount;
+    var onDrop = function (acceptedFiles) {
+        acceptedFiles.forEach(function (file) {
+            setIsLoading && setIsLoading(true);
+            saveFileName(file.name);
+            var reader = new FileReader();
+            var isCsvFile = file.type === "text/csv";
+            reader.onabort = function () { return console.log("file reading was aborted"); };
+            reader.onerror = function () { return console.log("file reading has failed"); };
+            reader.onload = function (event) {
+                var _a;
+                var results = event.target.result;
+                if (isCsvFile) {
+                    Papa.parse(results, {
+                        worker: true,
+                        complete: function (parserResults) {
+                            onComplete(parserResults.data);
+                            setIsLoading && setIsLoading(false);
+                        },
+                    });
+                    return;
+                }
+                var getDataFromFile = function (fileResults) {
+                    // rounded value to 20MB
+                    var isLargeFile = file.size > 20000000;
+                    var workBook = XLSX.read(fileResults, {
+                        type: "array",
+                        codepage: 65001,
+                        raw: true,
+                        dense: isLargeFile,
+                    });
+                    var workBookName = workBook.SheetNames[0];
+                    var sheet = workBook.Sheets[workBookName];
+                    return XLSX.utils.sheet_to_json(sheet, { header: 1, raw: false });
+                };
+                var fileData = getDataFromFile(results);
+                var headersCount = (_a = fileData[0]) === null || _a === void 0 ? void 0 : _a.length;
+                if (validHeadersCount) {
+                    validHeadersCount(headersCount) && onComplete(fileData);
+                }
+                else {
+                    onComplete(fileData);
+                }
+                setIsLoading && setIsLoading(false);
+            };
+            if (isCsvFile) {
+                reader.readAsText(file);
+            }
+            else {
+                reader.readAsArrayBuffer(file);
+            }
+        });
+    };
+    var onDropRejected = function (rejectedFiles) {
+        var errorMessages = rejectedFiles.map(function (file) {
+            if (file.errors[0].code === "file-too-large") {
+                return "Please upload a CSV file less than 100mb or an XLSX file less than 50mb.";
+            }
+            else {
+                return file.errors[0].message;
+            }
+        });
+        var uniqueMessages = Array.from(new Set(errorMessages));
+        uniqueMessages.forEach(function (message) {
+            addToast(message, "error");
+        });
+    };
+    var validator = function (file) {
+        var isCsvFile = file.type === "text/csv";
+        var isExcelFile = [
+            "application/vnd.ms-excel",
+            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        ].includes(file.type);
+        if (isCsvFile && file.size > 100000000) {
+            return {
+                code: "file-too-large",
+                message: "Maximum file size is 100MB",
+            };
+        }
+        else if (isExcelFile && file.size > 50000000) {
+            return {
+                code: "file-too-large",
+                message: "Maximum file size is 50MB",
+            };
+        }
+        return null;
+    };
+    var _b = useDropzone({
+        onDrop: onDrop,
+        onDropRejected: onDropRejected,
+        noClick: true,
+        noKeyboard: true,
+        accept: ".csv, .xls, .xlsx",
+        maxFiles: 1,
+        validator: validator,
+    }), getRootProps = _b.getRootProps, getInputProps = _b.getInputProps, open = _b.open, isDragActive = _b.isDragActive;
+    return {
+        getRootProps: getRootProps,
+        getInputProps: getInputProps,
+        open: open,
+        isDragActive: isDragActive,
+    };
+};

package/lib/esm/common/FileUploadDropzone/index.d.ts

@@ -0,0 +1 @@
+export * from "./ImporterDropzone";

package/lib/esm/common/FileUploadDropzone/index.js

@@ -0,0 +1 @@
+export * from "./ImporterDropzone";

package/lib/esm/common/Table/TableActions/CustomActions/CustomActions.js

@@ -59,64 +59,78 @@ import { MenuItem, addToast } from "../../../index";
 import { useSpreadsheetContext } from "../../../../index";
 import { useImporterContext } from "../../../../Importer/contexts/ImporterContextProvider";
 import { useTranslation } from "react-i18next";
+import { useBatchProcessing } from "../../../../Importer/common/Spreadsheet/SpreadsheetContextProvider/useBatchProcessing";
+import { useDataSetContext } from "../../../../Importer/common/Spreadsheet/DataSetContextProvider";
+import { useValidationContext } from "../../../../Importer/common/Spreadsheet/ValidationContextProvider";
 var Container = styled(Div)(templateObject_1 || (templateObject_1 = __makeTemplateObject(["\n  cursor: pointer;\n"], ["\n  cursor: pointer;\n"])));
 var StyledSelectMenu = styled(SelectMenu)(templateObject_2 || (templateObject_2 = __makeTemplateObject(["\n  .selectMenu[data-popper-placement^=\"bottom\"] {\n    width: 320px !important;\n    transform: translate(-199px, 21px);\n  }\n"], ["\n  .selectMenu[data-popper-placement^=\"bottom\"] {\n    width: 320px !important;\n    transform: translate(-199px, 21px);\n  }\n"])));
 export var CustomActions = function () {
     var customActions = useImporterContext().customActions;
-    var _a = useSpreadsheetContext(), selectedRows = _a.selectedRows, data = _a.data, updateRecord = _a.updateRecord;
-    var _b = useState(null), referenceElement = _b[0], setReferenceElement = _b[1];
-    var _c = useState(false), isMenuOpen = _c[0], setIsMenuOpen = _c[1];
+    var selectedRows = useSpreadsheetContext().selectedRows;
+    var getRecord = useDataSetContext().getRecord;
+    var updateRecordAndRevalidate = useValidationContext().updateRecordAndRevalidate;
+    var _a = useState(null), referenceElement = _a[0], setReferenceElement = _a[1];
+    var _b = useState(false), isMenuOpen = _b[0], setIsMenuOpen = _b[1];
     var t = useTranslation("review").t;
     var filteredOptions = useMemo(function () {
         return customActions.map(function (action) { return action.name; });
     }, [customActions]);
-    var handleCustomAction = function (actionKey) { return __awaiter(void 0, void 0, void 0, function () {
-        var recordsToRunAction, recordsAfterActions, action, i, currentRecord, newRecord, error_1;
+    var processBatch = function (batch, action) { return __awaiter(void 0, void 0, void 0, function () {
+        var results, i, currentRecord;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    recordsToRunAction = data.filter(function (row) { var _a; return selectedRows.includes((_a = row === null || row === void 0 ? void 0 : row._meta) === null || _a === void 0 ? void 0 : _a.id); });
-                    recordsAfterActions = [];
-                    action = customActions.find(function (action) { return action.name === actionKey; });
-                    if (!action || Object.keys(action).length === 0) {
-                        addToast(t("table_actions.custom_actions.general_error_toast"), "error");
-                        return [2 /*return*/];
+                    results = [];
+                    for (i = 0; i < batch.length; i++) {
+                        currentRecord = batch[i];
+                        try {
+                            if (action.actionType === "record") {
+                                results.push(action.handler(currentRecord));
+                            }
+                        }
+                        catch (error) {
+                            addToast(t("table_actions.custom_actions.error_toast", {
+                                actionName: action.name,
+                            }), "error");
+                            break;
+                        }
                     }
-                    i = 0;
-                    _a.label = 1;
+                    return [4 /*yield*/, updateRecordAndRevalidate(results)];
                 case 1:
-                    if (!(i < recordsToRunAction.length)) return [3 /*break*/, 7];
-                    currentRecord = recordsToRunAction[i];
-                    _a.label = 2;
-                case 2:
-                    _a.trys.push([2, 5, , 6]);
-                    if (!(action.actionType === "record")) return [3 /*break*/, 4];
-                    return [4 /*yield*/, action.handler(currentRecord)];
-                case 3:
-                    newRecord = _a.sent();
-                    recordsAfterActions.push(newRecord);
-                    return [3 /*break*/, 6];
-                case 4: return [3 /*break*/, 6];
-                case 5:
-                    error_1 = _a.sent();
-                    addToast(t("table_actions.custom_actions.error_toast", {
-                        actionName: action.name,
-                    }), "error");
-                    return [3 /*break*/, 7];
-                case 6:
-                    i++;
-                    return [3 /*break*/, 1];
-                case 7:
-                    if (recordsAfterActions.length) {
-                        addToast(t("table_actions.custom_actions.success_toast", {
-                            actionName: action.name,
-                        }), "success");
-                    }
-                    updateRecord(recordsAfterActions);
+                    _a.sent();
                     return [2 /*return*/];
             }
         });
     }); };
+    var handleCustomAction = function (actionKey) { return __awaiter(void 0, void 0, void 0, function () {
+        var recordsToRunAction, action, processRecordsInBatches, toastMessage;
+        return __generator(this, function (_a) {
+            recordsToRunAction = selectedRows.map(function (recordId) {
+                return getRecord(recordId);
+            });
+            action = customActions.find(function (action) { return action.name === actionKey; });
+            if (!action || Object.keys(action).length === 0) {
+                addToast(t("table_actions.custom_actions.general_error_toast"), "error");
+                return [2 /*return*/];
+            }
+            processRecordsInBatches = useBatchProcessing().processRecordsInBatches;
+            processRecordsInBatches(recordsToRunAction, function (batch) { return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, processBatch(batch, action)];
+                        case 1:
+                            _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            toastMessage = t("table_actions.custom_actions.success_toast", {
+                actionName: action.name,
+            });
+            addToast(toastMessage, "success");
+            return [2 /*return*/];
+        });
+    }); };
     var onSelect = function (value) {
         setIsMenuOpen(false);
         handleCustomAction(value);

package/lib/esm/common/Table/TableActions/DeleteSelectedRows.js

@@ -16,40 +16,49 @@ var __assign = (this && this.__assign) || function () {
 import { jsxs as _jsxs, Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 import { useState } from "react";
 import styled from "styled-components";
-import { TooltipProvider } from "../../../common/TooltipProvider";
-import { ConfirmationModal } from "../../../common/ConfirmationModal";
+import { useTranslation } from "react-i18next";
 import { useSpreadsheetContext } from "../../../Importer";
-import { DeleteIcon, ConfirmationDeleteIcon } from "./icons";
+import { useDataSetContext } from "../../../Importer/common/Spreadsheet/DataSetContextProvider";
+import { useFilteredDataContext } from "../../../Importer/common/Spreadsheet/FilteredDataContextProvider";
+import { useValidationContext } from "../../../Importer/common/Spreadsheet/ValidationContextProvider";
+import { ConfirmationModal } from "../../../common/ConfirmationModal";
+import { useEventManagerContext } from "../../../common/EventManagerContextProvider";
+import { TooltipProvider } from "../../../common/TooltipProvider";
 import { Div } from "../../../styled/utils";
+import { addToast } from "../../Toast";
 import { ActionButton } from "./TableActions.styles";
-import { useTranslation } from "react-i18next";
-import { addToast } from "../../../common/Toast";
+import { ConfirmationDeleteIcon, DeleteIcon } from "./icons";
+import { useDataSetManipulation } from "../../../Importer/common/Spreadsheet/SpreadsheetContextProvider/useDataSetManipulation";
 var StyledTooltipProvider = styled(TooltipProvider)(templateObject_1 || (templateObject_1 = __makeTemplateObject(["\n  width: fit-content;\n"], ["\n  width: fit-content;\n"])));
 export var DeleteSelectedRows = function (_a) {
     var _b = _a.testId, testId = _b === void 0 ? "ta-delete-rows" : _b;
     var _c = useState(false), isConfirmationModalOpen = _c[0], setIsConfirmationModalOpen = _c[1];
-    var _d = useSpreadsheetContext(), deleteRecords = _d.deleteRecords, selectedRows = _d.selectedRows, setSelectedRows = _d.setSelectedRows, setFilteredInputValue = _d.setFilteredInputValue, spreadsheetFilter = _d.spreadsheetFilter, duplicateRecords = _d.duplicateRecords, resetSpreadsheetFilter = _d.resetSpreadsheetFilter;
+    var _d = useFilteredDataContext(), setFilteredInputValue = _d.setFilteredInputValue, setRecalculateFilters = _d.setRecalculateFilters;
+    var _e = useSpreadsheetContext(), selectedRows = _e.selectedRows, setSelectedRows = _e.setSelectedRows;
+    var _f = useValidationContext(), errors = _f.errors, warnings = _f.warnings, calculateColumnErrorCounts = _f.calculateColumnErrorCounts, calculateColumnWarningCounts = _f.calculateColumnWarningCounts;
+    var _g = useDataSetContext(), deleteRecord = _g.deleteRecord, emptyRecordIds = _g.emptyRecordIds;
     var t = useTranslation("review").t;
+    var _h = useEventManagerContext(), emit = _h.emit, EVENTS = _h.EVENTS;
+    var deleteRecordsFromSpreadsheet = useDataSetManipulation().deleteRecordsFromSpreadsheet;
     var toggleModalVisibility = function () {
         setIsConfirmationModalOpen(function (oldValue) { return !oldValue; });
     };
-    var handleDeleteRecord = function () {
+    var deleteRecords = function () {
         setSelectedRows([]);
         toggleModalVisibility();
         setFilteredInputValue("");
-        deleteRecords(selectedRows);
-        if (spreadsheetFilter.byRow === "duplicates") {
-            var selectedDuplicatesCount = Object.keys(duplicateRecords.records).filter(function (key) { return selectedRows.includes(key); }).length;
-            addToast(t("table_actions.filters_by_rows.duplicates_deleted", {
-                count: selectedDuplicatesCount,
-            }), "success");
-            resetSpreadsheetFilter();
-        }
+        deleteRecordsFromSpreadsheet(selectedRows);
+        addToast(t("table_actions.delete_rows.deleted_message", {
+            length: selectedRows.length,
+        }), "success");
+        emit(EVENTS.UPDATE_COLUMN_ERROR_COUNT);
+        emit(EVENTS.UPDATE_TOTAL_ERROR_COUNT);
+        emit(EVENTS.UPDATE_TOTAL_ROW_COUNT);
     };
     var DescriptionUI = function () { return (_jsx(_Fragment, { children: _jsxs(Div, { children: [t("table_actions.delete_rows.confirmation_modal", {
                     length: selectedRows.length,
                 }), selectedRows.length > 1 ? "s" : "", "?"] }) })); };
-    var confirmationModalUI = (_jsx(ConfirmationModal, { isOpen: isConfirmationModalOpen, handleClose: toggleModalVisibility, title: "".concat(t("table_actions.delete_rows.modal_title")).concat(selectedRows.length > 1 ? "s" : ""), description: _jsx(DescriptionUI, {}), onSubmit: handleDeleteRecord, buttonText: t("table_actions.delete_rows.yes_delete"), icon: ConfirmationDeleteIcon }));
+    var confirmationModalUI = (_jsx(ConfirmationModal, { isOpen: isConfirmationModalOpen, handleClose: toggleModalVisibility, title: "".concat(t("table_actions.delete_rows.modal_title")).concat(selectedRows.length > 1 ? "s" : ""), description: _jsx(DescriptionUI, {}), onSubmit: deleteRecords, buttonText: t("table_actions.delete_rows.yes_delete"), icon: ConfirmationDeleteIcon }));
     var isDeleteButtonDisabled = selectedRows.length <= 0;
     return (_jsxs(_Fragment, { children: [confirmationModalUI, _jsx(StyledTooltipProvider, __assign({ tooltip: isDeleteButtonDisabled
                     ? t("table_actions.delete_rows.select_rows")

package/lib/esm/common/Table/TableActions/ExportData.js

@@ -11,13 +11,15 @@ var __assign = (this && this.__assign) || function () {
 };
 import { jsx as _jsx } from "react/jsx-runtime";
 import { DownloadIcon } from "./icons";
-import { useReviewContext } from "../../../Importer";
 import { TooltipProvider } from "../../../common/TooltipProvider";
 import { ActionButton } from "./TableActions.styles";
 import { useTranslation } from "react-i18next";
+import { useExportDataToFile } from "../../../Importer/hooks/useExportDataToFile";
+import { useDataSetContext } from "../../../Importer/common/Spreadsheet/DataSetContextProvider";
 export var ExportData = function (_a) {
     var _b = _a.testId, testId = _b === void 0 ? "ta-export-data" : _b;
-    var onExport = useReviewContext().onExport;
+    var onExport = useExportDataToFile().onExport;
+    var dataSet = useDataSetContext().dataSet;
     var t = useTranslation("review").t;
-    return (_jsx(TooltipProvider, __assign({ tooltip: t("table_actions.export_your_data.tooltip"), placement: "right", flip: false, centered: true, "data-testid": testId }, { children: _jsx(ActionButton, __assign({ onClick: function () { return onExport("csv"); } }, { children: _jsx(DownloadIcon, {}) })) })));
+    return (_jsx(TooltipProvider, __assign({ tooltip: t("table_actions.export_your_data.tooltip"), placement: "right", flip: false, centered: true, "data-testid": testId }, { children: _jsx(ActionButton, __assign({ onClick: function () { return onExport(dataSet === null || dataSet === void 0 ? void 0 : dataSet.current, "csv"); } }, { children: _jsx(DownloadIcon, {}) })) })));
 };