fuse-importer 0.23.8 → 0.24.0

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

@@ -9,303 +9,68 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) 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];
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
         }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
+    return t;
 };
 import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext, useEffect, useState, useMemo, useCallback, useRef, } from "react";
-import { formatBatchErrors } from "../../..";
-import { getRecordErrors, getRenderedRecordWithErrors, recordIsEmpty, } from "./common";
-import { sleep } from "../../../utils";
-import { useImporterContext } from "../../ImporterContextProvider";
-var MINIMUM_ROW_COUNT = 20;
-var getRowId = function (id) { return "r".concat(id); };
-export var getBatchErrors = function (records, onValidateRecord) { return __awaiter(void 0, void 0, void 0, function () {
-    var batchErrors;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0: return [4 /*yield*/, Promise.all(records.map(function (record) { return __awaiter(void 0, void 0, void 0, function () {
-                    var _a;
-                    return __generator(this, function (_b) {
-                        switch (_b.label) {
-                            case 0:
-                                _a = {
-                                    rowId: record._meta.id
-                                };
-                                return [4 /*yield*/, onValidateRecord(record)];
-                            case 1: return [2 /*return*/, (_a.errors = _b.sent(),
-                                    _a)];
-                        }
-                    });
-                }); }))];
-            case 1:
-                batchErrors = _a.sent();
-                return [2 /*return*/, formatBatchErrors(batchErrors)];
-        }
-    });
-}); };
+import { get } from "lodash";
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, } from "react";
+import { useValidationState } from "./hooks";
 var SpreadsheetContext = createContext({});
-var addMeta = function (d, i) { return (__assign(__assign({}, d), { _meta: { id: getRowId(i), rowIndex: i } })); };
 export var SpreadsheetContextProvider = function (_a) {
-    var initialData = _a.initialData, _b = _a.rowWidth, rowWidth = _b === void 0 ? 1 : _b, _c = _a.onValidateRecord, onValidateRecord = _c === void 0 ? null : _c, _d = _a.onValidateBatch, onValidateBatch = _d === void 0 ? null : _d, appResponse = _a.appResponse, fields = _a.fields, options = _a.options, isReadOnly = _a.isReadOnly, highlightFirstRow = _a.highlightFirstRow, submittedData = _a.submittedData, setReviewedData = _a.setReviewedData, children = _a.children;
-    var mappedInitialData = useMemo(function () { return initialData.map(addMeta); }, [
-        initialData,
-    ]);
-    var _e = useState(mappedInitialData), data = _e[0], setData = _e[1];
-    var dataRef = useRef(mappedInitialData);
-    var _f = useState(false), isLoading = _f[0], setIsLoading = _f[1];
-    var _g = useState(null), sortByFieldErrors = _g[0], setSortByFieldErrors = _g[1];
-    var _h = useState(true), isScrollingEnabled = _h[0], setIsScrollingEnabled = _h[1];
-    var _j = useState(null), batchValidationErrors = _j[0], setBatchValidationErrors = _j[1];
-    var _k = useState(0), batchValidationPercentage = _k[0], setBatchValidationPercentage = _k[1];
-    var _l = useValidationState({
-        data: data,
+    var initialDataSet = _a.initialDataSet, _b = _a.rowWidth, rowWidth = _b === void 0 ? 1 : _b, fields = _a.fields, options = _a.options, isReadOnly = _a.isReadOnly, highlightFirstRow = _a.highlightFirstRow, children = _a.children, onValidateRecord = _a.onValidateRecord, onDataSetChanged = _a.onDataSetChanged, onValidationStateChanged = _a.onValidationStateChanged;
+    var _c = useState(initialDataSet), dataSet = _c[0], setDataSet = _c[1];
+    var _d = useState(false), isLoading = _d[0], setIsLoading = _d[1];
+    var _e = useState(null), sortByFieldErrors = _e[0], setSortByFieldErrors = _e[1];
+    var sortByCurrentErrorsRef = useRef({});
+    var _f = useValidationState({
+        dataSet: dataSet,
+        initialDataSet: initialDataSet,
         fields: fields,
-        batchValidationErrors: batchValidationErrors,
-        submittedData: submittedData,
-    }), columnErrorCounts = _l.columnErrorCounts, totalErrors = _l.totalErrors, isValidationComplete = _l.isValidationComplete;
-    var updateData = useCallback(function (data) {
-        dataRef.current = data;
-        setData(data);
-    }, []);
-    useEffect(function () {
-        var batchValidationDelayMs = options.batchValidationDelayMs, _a = options.batchValidationSize, batchValidationSize = _a === void 0 ? 1000 : _a;
-        var batchSize = Math.min(Math.floor(batchValidationSize), data.length) || data.length;
-        var batchCount = Math.ceil(data.length / batchSize);
-        var isCancelled = false;
-        var addEmptyRows = function () {
-            var newData = __spreadArray([], data, true);
-            var emptyRecord = fields.reduce(function (obj, f) {
-                var _a;
-                return (__assign(__assign({}, obj), (_a = {}, _a[f.name] = null, _a)));
-            }, {});
-            for (var i = newData.length; i < MINIMUM_ROW_COUNT; i++) {
-                newData.push(__assign(__assign({}, emptyRecord), { _meta: {
-                        id: getRowId(i),
-                        rowIndex: i,
-                    } }));
-            }
-            updateData(newData);
-        };
-        var validateInBatches = function () { return __awaiter(void 0, void 0, void 0, function () {
-            var validationErrors, batchIdx, idx, batch, errors, validationPercentage;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        validationErrors = {};
-                        batchIdx = 0;
-                        _a.label = 1;
-                    case 1:
-                        if (!(batchIdx < batchCount)) return [3 /*break*/, 5];
-                        if (isCancelled)
-                            return [3 /*break*/, 5];
-                        idx = batchIdx * batchSize;
-                        batch = data.slice(idx, idx + batchSize);
-                        return [4 /*yield*/, (onValidateBatch
-                                ? onValidateBatch(batch)
-                                : getBatchErrors(batch, onValidateRecord))];
-                    case 2:
-                        errors = _a.sent();
-                        validationErrors = __assign(__assign({}, validationErrors), errors);
-                        // unblocks main thread for rendering ui
-                        return [4 /*yield*/, sleep(batchValidationDelayMs)];
-                    case 3:
-                        // unblocks main thread for rendering ui
-                        _a.sent();
-                        validationPercentage = (Math.min(idx + batchSize, data.length) / data.length) * 100;
-                        setBatchValidationPercentage(Math.floor(validationPercentage));
-                        _a.label = 4;
-                    case 4:
-                        batchIdx++;
-                        return [3 /*break*/, 1];
-                    case 5:
-                        if (!isCancelled)
-                            setBatchValidationErrors(validationErrors);
-                        return [2 /*return*/];
-                }
-            });
-        }); };
-        var init = function () { return __awaiter(void 0, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                if (data.length < MINIMUM_ROW_COUNT)
-                    addEmptyRows();
-                validateInBatches();
-                return [2 /*return*/];
-            });
-        }); };
-        if (!isReadOnly)
-            init();
-        return function () {
-            isCancelled = true;
-        };
-    }, []);
-    useEffect(function () {
-        var appValidationErrors = appResponse === null || appResponse === void 0 ? void 0 : appResponse.errors;
-        if (appValidationErrors) {
-            updateData(__spreadArray([], data, true).map(function (record) { return (__assign(__assign({}, record), { _meta: __assign(__assign({}, record._meta), { appValidationErrors: appValidationErrors[record._meta.id] }) })); }));
-        }
-    }, [appResponse]);
-    useEffect(function () {
-        if (!setReviewedData)
-            return;
-        if (isValidationComplete)
-            setReviewedData(data.filter(function (r) { return !recordIsEmpty(r, fields); }));
-        else
-            setReviewedData(null);
-    }, [isValidationComplete, data]);
-    useEffect(function () {
+        options: options,
+        isReadOnly: isReadOnly,
+        setDataSet: setDataSet,
+        setIsLoading: setIsLoading,
+        onValidateRecord: onValidateRecord,
+    }), errorsRef = _f.errorsRef, updateRecordAndRevalidate = _f.updateRecordAndRevalidate, validationState = __rest(_f, ["errorsRef", "updateRecordAndRevalidate"]);
+    // sort data based on errors (errors group on top and not errors group at bottom)
+    var data = useMemo(function () {
+        var errors = sortByCurrentErrorsRef.current; //Sort errors snapshot
+        var dataSetValues = Object.values(dataSet);
         if (!sortByFieldErrors)
-            return;
-        var sortedByFieldErrors = __spreadArray([], data, true).sort(function (a, b) {
-            var recordHasErrors = function (record) {
-                return !!getRecordErrors({
-                    record: record,
-                    fields: fields,
-                    batchValidationErrors: batchValidationErrors,
-                    submittedData: submittedData,
-                    data: data,
-                })[sortByFieldErrors];
-            };
-            var aHasErrors = recordHasErrors(a);
-            var bHasErrors = recordHasErrors(b);
-            if (aHasErrors === bHasErrors)
+            return dataSetValues;
+        return dataSetValues.sort(function (a, b) {
+            var aHasErrors = !!get(errors, "".concat(get(a, "_meta.id"), ".").concat(sortByFieldErrors), false);
+            var bHasErrors = !!get(errors, "".concat(get(b, "_meta.id"), ".").concat(sortByFieldErrors), false);
+            if (aHasErrors === bHasErrors) {
                 return a._meta.rowIndex > b._meta.rowIndex ? 1 : -1;
+            }
             return bHasErrors ? 1 : -1;
         });
-        updateData(sortedByFieldErrors);
-    }, [sortByFieldErrors]);
-    var validateRenderedRecords = useCallback(function (renderedData) { return __awaiter(void 0, void 0, void 0, function () {
-        var newData;
-        return __generator(this, function (_a) {
-            if (isReadOnly)
-                return [2 /*return*/];
-            setIsLoading(true);
-            newData = __spreadArray([], data, true);
-            renderedData.forEach(function (record) { return __awaiter(void 0, void 0, void 0, function () {
-                var renderedRecordWithErrors, _a, rowIndex;
-                var _b;
-                return __generator(this, function (_c) {
-                    switch (_c.label) {
-                        case 0:
-                            _a = getRenderedRecordWithErrors;
-                            _b = {
-                                record: record
-                            };
-                            return [4 /*yield*/, onValidateRecord(record)];
-                        case 1:
-                            renderedRecordWithErrors = _a.apply(void 0, [(_b.validationErrors = _c.sent(),
-                                    _b)]);
-                            rowIndex = newData.findIndex(function (r) { return r._meta.id === record._meta.id; });
-                            newData[rowIndex] = renderedRecordWithErrors;
-                            return [2 /*return*/];
-                    }
-                });
-            }); });
-            setIsLoading(false);
-            updateData(newData);
-            return [2 /*return*/];
-        });
-    }); }, [data]);
-    var value = {
-        data: data,
-        dataRef: dataRef,
-        fields: fields,
-        isLoading: isLoading,
-        setIsLoading: setIsLoading,
-        isScrollingEnabled: isScrollingEnabled,
-        isValidationComplete: isValidationComplete,
-        batchValidationErrors: batchValidationErrors,
-        batchValidationPercentage: batchValidationPercentage,
-        totalErrors: totalErrors,
-        columnErrorCounts: columnErrorCounts,
-        isReadOnly: isReadOnly,
-        rowWidth: rowWidth,
-        sortByFieldErrors: sortByFieldErrors,
-        submittedData: submittedData,
-        setSortByFieldErrors: setSortByFieldErrors,
-        setData: updateData,
-        onValidateRecord: onValidateRecord,
-        validateRenderedRecords: validateRenderedRecords,
-        setIsScrollingEnabled: setIsScrollingEnabled,
-        highlightFirstRow: highlightFirstRow,
-    };
-    return (_jsx(SpreadsheetContext.Provider, __assign({ value: value }, { children: children })));
-};
-var useValidationState = function (_a) {
-    var data = _a.data, fields = _a.fields, batchValidationErrors = _a.batchValidationErrors, submittedData = _a.submittedData;
-    var _b = useState({}), columnErrorCounts = _b[0], setColumnErrorCounts = _b[1];
-    var setIsSpreadsheetValid = useImporterContext().setIsSpreadsheetValid;
+    }, [dataSet, sortByFieldErrors]);
     useEffect(function () {
-        var updateErrorCounts = function () {
-            var newColumnErrorCounts = {};
-            data.forEach(function (record) {
-                var updateFieldErrorCount = function (recordErrors) {
-                    var fieldsWithErrors = Object.keys(recordErrors).filter(function (f) { return recordErrors[f]; });
-                    fieldsWithErrors.forEach(function (field) {
-                        var currentCount = newColumnErrorCounts[field] || 0;
-                        newColumnErrorCounts[field] = currentCount + 1;
-                    });
-                };
-                var recordErrors = getRecordErrors({
-                    record: record,
-                    fields: fields,
-                    batchValidationErrors: batchValidationErrors,
-                    submittedData: submittedData,
-                    data: data,
-                });
-                updateFieldErrorCount(recordErrors);
-            });
-            setIsSpreadsheetValid(Object.keys(newColumnErrorCounts).length === 0);
-            setColumnErrorCounts(newColumnErrorCounts);
-        };
-        updateErrorCounts();
-    }, [data, batchValidationErrors]);
-    var totalErrors = useMemo(function () {
-        return Object.keys(columnErrorCounts).reduce(function (total, key) { return total + (columnErrorCounts[key] || 0); }, 0);
+        onDataSetChanged && onDataSetChanged(dataSet);
+    }, [dataSet]);
+    useEffect(function () {
+        setDataSet(initialDataSet);
+    }, [initialDataSet]);
+    useEffect(function () {
+        onValidationStateChanged && onValidationStateChanged(validationState);
+    }, [validationState, onValidationStateChanged]);
+    var handleSortByFieldErrors = useCallback(function (value) {
+        //current errors snapshot for use on sort to keep data sorted without changing with each edit or revalidation.
+        sortByCurrentErrorsRef.current = __assign({}, errorsRef.current);
+        setSortByFieldErrors(value);
     }, []);
-    var isValidationComplete = batchValidationErrors && totalErrors === 0;
-    return { columnErrorCounts: columnErrorCounts, totalErrors: totalErrors, isValidationComplete: isValidationComplete };
+    var value = __assign(__assign({ data: data, fields: fields, isLoading: isLoading }, validationState), { isReadOnly: isReadOnly, rowWidth: rowWidth, sortByFieldErrors: sortByFieldErrors, highlightFirstRow: highlightFirstRow, setIsLoading: setIsLoading, setSortByFieldErrors: handleSortByFieldErrors, onValidateRecord: onValidateRecord, updateRecord: updateRecordAndRevalidate });
+    return (_jsx(SpreadsheetContext.Provider, __assign({ value: value }, { children: children })));
 };
 export var useSpreadsheetContext = function () { return useContext(SpreadsheetContext); };

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

@@ -1,23 +1,16 @@
-import { Field, Record, BatchValidationErrors } from "../../../../types";
+import { Record, Field, FieldTypes } from "../../../../types";
 export declare const spreadsheetRowHeightPx = 40;
 export declare const spreadsheetHeaderHeightPx = 40;
+export declare const isNullOrUndefined: (value: any) => boolean;
 export declare const isEmpty: (value: any) => boolean;
 export declare const isEmail: (value: any) => boolean;
 export declare const isUrl: (value: any) => boolean;
 export declare const isTrue: (value: string) => boolean;
+export declare const isFalse: (value: string) => boolean;
+export declare const isBoolean: (value: string) => boolean;
 export declare const isInteger: (value: string) => boolean;
 export declare const isFloat: (value: string) => boolean;
-export declare const recordIsEmpty: (record: any, fields: any) => any;
-export declare const getRenderedRecordWithErrors: ({ record, validationErrors, }: {
-    record: any;
-    validationErrors: any;
-}) => Record;
-declare type GetRecordErrorsArgs = {
-    record: Record;
-    fields: Field[];
-    batchValidationErrors: BatchValidationErrors;
-    submittedData: Record[];
-    data: Record[];
-};
-export declare const getRecordErrors: ({ record, fields, batchValidationErrors, submittedData, data, }: GetRecordErrorsArgs) => {};
-export {};
+export declare const isEven: (value: number) => boolean;
+export declare const ignoreNullOrUndefinedKeyValues: (obj: any) => {};
+export declare const isRecordEmpty: (record: Record, fields: Field[]) => boolean;
+export declare const parseValue: (fieldType: FieldTypes, value: any, enumSet?: any) => any;

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

@@ -1,19 +1,9 @@
-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 _a;
-import { FieldTypes, } from "../../../../types";
-import { DateTime } from "luxon";
+import { FieldTypes } from "../../../../types";
 export var spreadsheetRowHeightPx = 40;
 export var spreadsheetHeaderHeightPx = 40;
+export var isNullOrUndefined = function (value) {
+    return value === null || value === undefined;
+};
 export var isEmpty = function (value) {
     return (value === undefined ||
         value === null ||
@@ -29,56 +19,24 @@ export var isUrl = function (value) {
     return urlRegex.test(value);
 };
 export var isTrue = function (value) {
-    var _value = (value || "").toString().toLowerCase();
+    var _a;
+    var _value = (_a = value === null || value === void 0 ? void 0 : value.toString()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
     return ["true", "yes", "1", "y", "on", "t"].includes(_value);
 };
+export var isFalse = function (value) {
+    var _a;
+    var _value = (_a = value === null || value === void 0 ? void 0 : value.toString()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    return ["false", "no", "0", "n", "off", "f"].includes(_value);
+};
+export var isBoolean = function (value) {
+    return isTrue(value) || isFalse(value);
+};
 export var isInteger = function (value) { return /^-?[0-9]+$/.test(value + ""); };
 export var isFloat = function (value) {
     return /^-?[0-9]+(?:\.[0-9]+)?$/.test(value + "");
 };
-export var recordIsEmpty = function (record, fields) {
-    return fields.reduce(function (isEmptyRecord, f) { return isEmptyRecord && isEmpty(record[f.name]); }, true);
-};
-export var getRenderedRecordWithErrors = function (_a) {
-    var record = _a.record, validationErrors = _a.validationErrors;
-    return (__assign(__assign({}, record), { _meta: __assign(__assign({}, (record._meta || {})), { localValidationErrors: validationErrors, wasSeen: true }) }));
-};
-var validateDatePattern = function (field, fieldValue) {
-    var date = DateTime.fromFormat(fieldValue, field.pattern);
-    if (!date.isValid) {
-        return "".concat(field.label, " must match the pattern ").concat(field.pattern);
-    }
-};
-var validateUnique = function (fieldValue, key, records) {
-    var existingRecords = records.filter(function (r) { return r[key] === fieldValue; });
-    return existingRecords.length < 2;
-};
-var validations = (_a = {},
-    _a[FieldTypes.email] = function (field, fieldValue) {
-        if (!isEmail(fieldValue)) {
-            return "".concat(field.label, " is not a valid email");
-        }
-    },
-    _a[FieldTypes.url] = function (field, fieldValue) {
-        if (!isUrl(fieldValue)) {
-            return "".concat(field.label, " is not a valid url");
-        }
-    },
-    _a[FieldTypes.integer] = function (field, fieldValue) {
-        if (!isInteger(fieldValue)) {
-            return "".concat(field.label, " is not a valid integer");
-        }
-    },
-    _a[FieldTypes.float] = function (field, fieldValue) {
-        if (!isFloat(fieldValue)) {
-            return "".concat(field.label, " is not a valid float");
-        }
-    },
-    _a[FieldTypes.date] = validateDatePattern,
-    _a[FieldTypes.time] = validateDatePattern,
-    _a[FieldTypes.datetime] = validateDatePattern,
-    _a);
-var ignoreNullOrUndefinedKeyValues = function (obj) {
+export var isEven = function (value) { return value % 2 === 0; };
+export var ignoreNullOrUndefinedKeyValues = function (obj) {
     var result = {};
     Object.keys(obj || {})
         .filter(function (key) { return obj[key] !== null && obj[key] !== undefined; })
@@ -87,47 +45,19 @@ var ignoreNullOrUndefinedKeyValues = function (obj) {
     });
     return result;
 };
-export var getRecordErrors = function (_a) {
-    var record = _a.record, fields = _a.fields, batchValidationErrors = _a.batchValidationErrors, submittedData = _a.submittedData, data = _a.data;
-    var submittedRecord = submittedData === null || submittedData === void 0 ? void 0 : submittedData.find(function (r) { return r._meta.id === record._meta.id; });
-    var recordHasData = !recordIsEmpty(record, fields);
-    if (recordHasData) {
-        var recordTemplateValidationErrors = fields.reduce(function (errors, field) {
-            var newErrors = __assign({}, errors);
-            var fieldValue = record[field.name];
-            if (isEmpty(fieldValue) && field.isRequired) {
-                newErrors[field.name] = "".concat(field.label, " is required");
-            }
-            else if (!isEmpty(fieldValue) && validations[field.type]) {
-                newErrors[field.name] = validations[field.type](field, fieldValue);
-                if (field.isUnique && !newErrors[field.name]) {
-                    var isFieldUnique = validateUnique(fieldValue, field.name, data);
-                    if (!isFieldUnique) {
-                        newErrors[field.name] = "".concat(field.label, " must be unique");
-                    }
-                }
-            }
-            return newErrors;
-        }, {});
-        var recordValidationErrors = (function () {
-            var _a;
-            if ((_a = record === null || record === void 0 ? void 0 : record._meta) === null || _a === void 0 ? void 0 : _a.wasSeen)
-                return record._meta.localValidationErrors;
-            return batchValidationErrors
-                ? batchValidationErrors[record._meta.id]
-                : {};
-        })();
-        var appValidationErrors = {};
-        if (record._meta.appValidationErrors) {
-            var appValidationErrorFields = Object.keys(record._meta.appValidationErrors);
-            appValidationErrors = appValidationErrorFields.reduce(function (errors, field) {
-                var newErrors = __assign({}, errors);
-                if (record[field] === submittedRecord[field])
-                    newErrors[field] = record._meta.appValidationErrors[field];
-                return newErrors;
-            }, {});
-        }
-        return __assign(__assign(__assign({}, ignoreNullOrUndefinedKeyValues(recordValidationErrors)), ignoreNullOrUndefinedKeyValues(recordTemplateValidationErrors)), ignoreNullOrUndefinedKeyValues(appValidationErrors));
-    }
-    return {};
+export var isRecordEmpty = function (record, fields) {
+    return fields.reduce(function (isEmptyRecord, f) { return isEmptyRecord && isEmpty(record[f.name]); }, true);
+};
+export var parseValue = function (fieldType, value, enumSet) {
+    if (isEmpty(value))
+        return value;
+    if (fieldType === FieldTypes.float)
+        return isFloat(value) ? parseFloat(value) : value;
+    if (fieldType === FieldTypes.integer)
+        return isInteger(value) ? parseInt(value) : value;
+    if (fieldType === FieldTypes.boolean)
+        return isTrue(value) ? true : false;
+    if (fieldType === FieldTypes.enum && enumSet)
+        return enumSet[value];
+    return value;
 };

package/lib/esm/Importer/common/Spreadsheet/{common → components}/FieldHeader.js

@@ -14,10 +14,10 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import styled, { css } from "styled-components";
 import { TooltipProvider } from "../../../../common";
 import { Div } from "../../../../styled/utils";
 import { useSpreadsheetContext } from "../SpreadsheetContextProvider";
-import styled, { css } from "styled-components";
 var ErrorCount = styled(Div)(function (_a) {
     var _b = _a.theme, colors = _b.colors, c = _b.css;
     return css(templateObject_1 || (templateObject_1 = __makeTemplateObject(["\n    color: ", ";\n    background: ", ";\n    border: solid 1px ", ";\n    padding: 4px 7px;\n    border-radius: 56px;\n    min-width: 24px;\n    ", ";\n  "], ["\n    color: ", ";\n    background: ", ";\n    border: solid 1px ", ";\n    padding: 4px 7px;\n    border-radius: 56px;\n    min-width: 24px;\n    ", ";\n  "])), colors.error, colors.red100, colors.error, c.centered);

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

@@ -0,0 +1,3 @@
+import React from "react";
+declare const _default: React.MemoExoticComponent<() => JSX.Element>;
+export default _default;

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

@@ -0,0 +1,74 @@
+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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React, { useCallback, useMemo, useRef } from "react";
+import { areEqual } from "react-window";
+import { Div } from "../../../../styled/utils";
+import { getTableHeight } from "../../../common";
+import { spreadsheetHeaderHeightPx, spreadsheetRowHeightPx } from "../common";
+import { useSpreadsheetContext } from "../SpreadsheetContextProvider";
+import * as S from "../styles";
+import { FieldHeader } from "./FieldHeader";
+import GlobalStyle from "./GlobalStyle";
+import { inputTypes } from "./inputs";
+import { SpreadsheetRowNumbers } from "./SpreadsheetRowNumbers";
+import ValidationProgress from "./ValidationProgress";
+var getItemKey = function (record) { return record._meta.id; };
+var SpreadsheetData = function () {
+    var _a = useSpreadsheetContext(), fields = _a.fields, data = _a.data, isLoading = _a.isLoading, isReadOnly = _a.isReadOnly, rowWidth = _a.rowWidth, totalErrors = _a.totalErrors, validationPercentage = _a.validationPercentage, setSortByFieldErrors = _a.setSortByFieldErrors;
+    var rowNumbersGridRef = useRef();
+    var sortByErrors = useCallback(function (field) {
+        return setSortByFieldErrors(function (sortByFieldErrors) {
+            return sortByFieldErrors === field ? null : field;
+        });
+    }, []);
+    var columns = useMemo(function () {
+        return fields.map(function (field) { return ({
+            Header: function () { return (_jsx(FieldHeader, { field: field, sortByFieldErrors: sortByErrors })); },
+            Content: function (record) {
+                var Input = inputTypes[field.type];
+                var rowIndex = record.rowIndex, recordProp = __rest(record, ["rowIndex"]);
+                return (_jsx(Input, { id: "".concat(field.name, "-").concat(rowIndex), fieldType: field.type, name: field.name, options: field.options, record: recordProp }));
+            },
+        }); });
+    }, [fields, sortByErrors]);
+    var onTableScroll = useCallback(function (scrollTop) {
+        if (rowNumbersGridRef.current) {
+            var grid = rowNumbersGridRef.current;
+            grid.scrollTo({ scrollTop: scrollTop });
+        }
+    }, []);
+    var dataLength = data === null || data === void 0 ? void 0 : data.length;
+    var spreadsheetHeight = useMemo(function () {
+        return getTableHeight({
+            headerHeight: spreadsheetHeaderHeightPx,
+            rowHeight: spreadsheetRowHeightPx,
+            dataCount: dataLength,
+            minimumTableHeight: 450,
+            maxVisibleRows: 12,
+        });
+    }, [dataLength]);
+    var showValidationProgress = !isReadOnly && validationPercentage < 100;
+    return (_jsxs(Div, { children: [_jsx(GlobalStyle, {}), _jsx(Div, __assign({ h: 32 }, { children: showValidationProgress && (_jsx(ValidationProgress, { totalErrors: totalErrors, validationPercentage: validationPercentage })) })), _jsxs(S.SpreadSheetWrapper, __assign({ h: spreadsheetHeight, dflex: true, w: 1400 }, { children: [_jsx(SpreadsheetRowNumbers, { gridRef: rowNumbersGridRef, spreadsheetHasXScroll: rowWidth > 1, height: spreadsheetHeight }), _jsx(S.TableView, { tableHeadersHeight: spreadsheetHeaderHeightPx, highlightFirstRow: isReadOnly, rowHeight: spreadsheetRowHeightPx, h: spreadsheetHeight, rowWidth: rowWidth, data: data, columns: columns, isLoading: isLoading, onTableScroll: onTableScroll, getItemKey: getItemKey })] }))] }));
+};
+export default React.memo(SpreadsheetData, areEqual);