fuse-importer 0.27.0 → 0.30.0

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

@@ -0,0 +1,179 @@
+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 { parseDateFromUserInput, parseDateTimeFromUserInput, parseTimeFromDateTimeorTimeInput, } from "./dateTimeAutoformatUtils";
+export var isTransformationNeeded = function (fieldValue, transformedValue) { return ({
+    transformationWasNeeded: !!transformedValue
+        ? fieldValue !== transformedValue
+        : false,
+    original: fieldValue,
+    transformed: fieldValue === transformedValue || transformedValue === undefined
+        ? null
+        : transformedValue,
+}); };
+var isNotANumber = function (fieldValue) {
+    return fieldValue === null || fieldValue === undefined || isNaN(fieldValue);
+};
+var isNotAString = function (fieldValue) {
+    return !fieldValue || typeof fieldValue !== "string" || fieldValue.trim() === "";
+};
+var stringFieldTransformations = {
+    sentence_case: function (fieldValue) {
+        var _a, _b;
+        if (isNotAString(fieldValue))
+            return {
+                transformationWasNeeded: false,
+                original: fieldValue,
+                transformed: null,
+            };
+        var transformedValue = ((_b = (_a = fieldValue === null || fieldValue === void 0 ? void 0 : fieldValue.toLowerCase()) === null || _a === void 0 ? void 0 : _a.charAt(0)) === null || _b === void 0 ? void 0 : _b.toUpperCase()) +
+            (fieldValue === null || fieldValue === void 0 ? void 0 : fieldValue.slice(1).toLowerCase());
+        return isTransformationNeeded(fieldValue, transformedValue);
+    },
+    capitalize: function (fieldValue) {
+        if (isNotAString(fieldValue)) {
+            return {
+                transformationWasNeeded: false,
+                original: fieldValue,
+                transformed: null,
+            };
+        }
+        var transformedValue = fieldValue
+            .split(" ")
+            .map(function (word) { return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase(); })
+            .join(" ");
+        return isTransformationNeeded(fieldValue, transformedValue);
+    },
+    uppercase: function (fieldValue) {
+        if (isNotAString(fieldValue))
+            return {
+                transformationWasNeeded: false,
+                original: fieldValue,
+                transformed: null,
+            };
+        var transformedValue = fieldValue === null || fieldValue === void 0 ? void 0 : fieldValue.toUpperCase();
+        return isTransformationNeeded(fieldValue, transformedValue);
+    },
+    lowercase: function (fieldValue) {
+        if (isNotAString(fieldValue))
+            return {
+                transformationWasNeeded: false,
+                original: fieldValue,
+                transformed: null,
+            };
+        var transformedValue = fieldValue === null || fieldValue === void 0 ? void 0 : fieldValue.toLowerCase();
+        return isTransformationNeeded(fieldValue, transformedValue);
+    },
+    trim_whitespace: function (fieldValue) {
+        if (typeof fieldValue !== "string")
+            return {
+                transformationWasNeeded: false,
+                original: fieldValue,
+                transformed: null,
+            };
+        var transformedValue = fieldValue === null || fieldValue === void 0 ? void 0 : fieldValue.trim();
+        return isTransformationNeeded(fieldValue, transformedValue);
+    },
+};
+export var datesDateTimesAndTimesTransformations = {
+    autoformat: function (fieldValue, _, fieldOptions) {
+        if (fieldValue === null || fieldValue === undefined)
+            return {
+                transformationWasNeeded: false,
+                original: fieldValue,
+                transformed: null,
+            };
+        var type = fieldOptions.type, pattern = fieldOptions.pattern;
+        var parseFunctions = {
+            date: parseDateFromUserInput,
+            datetime: parseDateTimeFromUserInput,
+            time: parseTimeFromDateTimeorTimeInput,
+        };
+        var parseFn = parseFunctions[type];
+        var dateValue = parseFn(fieldValue);
+        var transformedValue = dateValue === null || dateValue === void 0 ? void 0 : dateValue.toFormat(pattern);
+        return isTransformationNeeded(fieldValue, transformedValue);
+    },
+};
+var urlTransformations = {
+    prefix: function (fieldValue, transformation) {
+        var _a;
+        var prefixValue = (_a = transformation === null || transformation === void 0 ? void 0 : transformation.options) === null || _a === void 0 ? void 0 : _a.prefix;
+        var fieldValueHasPrefix = fieldValue === null || fieldValue === void 0 ? void 0 : fieldValue.startsWith(prefixValue);
+        if (isNotAString(prefixValue) ||
+            isNotAString(fieldValue) ||
+            fieldValueHasPrefix)
+            return {
+                transformationWasNeeded: false,
+                original: fieldValue,
+                transformed: null,
+            };
+        var transformedValue = "".concat(prefixValue).concat(fieldValue);
+        return isTransformationNeeded(fieldValue, transformedValue);
+    },
+};
+var floatTransformations = {
+    number_of_decimals: function (fieldValue, transformation) {
+        var _a;
+        var numberOfDecimalsValue = Number((_a = transformation === null || transformation === void 0 ? void 0 : transformation.options) === null || _a === void 0 ? void 0 : _a.number_of_decimals);
+        if (isNotANumber(numberOfDecimalsValue) || isNotANumber(fieldValue)) {
+            return {
+                transformationWasNeeded: false,
+                original: fieldValue,
+                transformed: null,
+            };
+        }
+        var transformedValue = parseFloat(Number(fieldValue).toFixed(numberOfDecimalsValue));
+        return isTransformationNeeded(fieldValue, transformedValue);
+    },
+};
+var integerTransformations = {
+    round: function (fieldValue) {
+        if (fieldValue === "" || isNotANumber(fieldValue)) {
+            return {
+                transformationWasNeeded: false,
+                original: fieldValue,
+                transformed: null,
+            };
+        }
+        var typeofFieldValue = typeof fieldValue;
+        var roundedValue = Math.round(fieldValue);
+        var valueWithCorrectType = typeofFieldValue === "string" ? "".concat(roundedValue) : roundedValue;
+        return isTransformationNeeded(fieldValue, valueWithCorrectType);
+    },
+    floor: function (fieldValue) {
+        if (fieldValue === "" || isNotANumber(fieldValue)) {
+            return {
+                transformationWasNeeded: false,
+                original: fieldValue,
+                transformed: null,
+            };
+        }
+        var typeofFieldValue = typeof fieldValue;
+        var flooredValue = Math.floor(fieldValue);
+        var valueWithCorrectType = typeofFieldValue === "string" ? "".concat(flooredValue) : flooredValue;
+        return isTransformationNeeded(fieldValue, valueWithCorrectType);
+    },
+    ceiling: function (fieldValue) {
+        if (fieldValue === "" || isNotANumber(fieldValue)) {
+            return {
+                transformationWasNeeded: false,
+                original: fieldValue,
+                transformed: null,
+            };
+        }
+        var typeofFieldValue = typeof fieldValue;
+        var ceilingValue = Math.ceil(fieldValue);
+        var valueWithCorrectType = typeofFieldValue === "string" ? "".concat(ceilingValue) : ceilingValue;
+        return isTransformationNeeded(fieldValue, valueWithCorrectType);
+    },
+};
+export var fieldTransformations = __assign(__assign(__assign(__assign(__assign({}, stringFieldTransformations), datesDateTimesAndTimesTransformations), urlTransformations), floatTransformations), integerTransformations);

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

@@ -0,0 +1,5 @@
+import { SortBy } from "../../../common";
+import { Record } from "../../../types";
+export declare const useFieldSorting: () => {
+    getDefaultSortCompareFn: (sortBy: SortBy) => (a: Record, b: Record) => number;
+};

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

@@ -0,0 +1,81 @@
+import { get } from "lodash";
+import { DateTime } from "luxon";
+import { useImporterContext } from "../../contexts/ImporterContextProvider";
+export var useFieldSorting = function () {
+    var templateHeaders = useImporterContext().templateHeaders;
+    var getDefaultSortCompareFn = function (sortBy) {
+        return function (a, b) {
+            var aField = get(a, sortBy.field);
+            var bField = get(b, sortBy.field);
+            var fieldTypes = templateHeaders.reduce(function (acc, header) {
+                var type = header.column_type;
+                var pattern = header.pattern || null;
+                acc[header.internal_key] = { type: type, pattern: pattern };
+                return acc;
+            }, {});
+            var fieldType = fieldTypes[sortBy.field];
+            var isAEmpty = aField === undefined || aField === null || aField === "";
+            var isBEmpty = bField === undefined || bField === null || bField === "";
+            // sort empty values to the end
+            if (isAEmpty && isBEmpty) {
+                if (a._meta.rowIndex === b._meta.rowIndex)
+                    return 0;
+                return a._meta.rowIndex < b._meta.rowIndex ? -1 : 1;
+            }
+            if (isAEmpty)
+                return 1;
+            if (isBEmpty)
+                return -1;
+            if (fieldType && fieldType.type === "boolean") {
+                var aString = aField ? "true" : "false";
+                var bString = bField ? "true" : "false";
+                if (aString === bString) {
+                    if (a._meta.rowIndex === b._meta.rowIndex)
+                        return 0;
+                    return a._meta.rowIndex < b._meta.rowIndex ? -1 : 1;
+                }
+                if (aString === "true")
+                    return sortBy.direction === "asc" ? -1 : 1;
+                if (bString === "true")
+                    return sortBy.direction === "asc" ? 1 : -1;
+            }
+            else if (fieldType &&
+                (fieldType.type === "date" ||
+                    fieldType.type === "datetime" ||
+                    fieldType.type === "time")) {
+                var aDateTime = aField
+                    ? DateTime.fromFormat(aField, fieldType.pattern)
+                    : null;
+                var bDateTime = bField
+                    ? DateTime.fromFormat(bField, fieldType.pattern)
+                    : null;
+                // sort invalid date values to the end before empty values
+                if (aDateTime && !aDateTime.isValid)
+                    return 1;
+                if (bDateTime && !bDateTime.isValid)
+                    return -1;
+                if (aDateTime && bDateTime && aDateTime.equals(bDateTime)) {
+                    if (a._meta.rowIndex === b._meta.rowIndex)
+                        return 0;
+                    return a._meta.rowIndex < b._meta.rowIndex ? -1 : 1;
+                }
+                if (sortBy.direction === "asc") {
+                    return (aDateTime === null || aDateTime === void 0 ? void 0 : aDateTime.valueOf()) - (bDateTime === null || bDateTime === void 0 ? void 0 : bDateTime.valueOf());
+                }
+                return (bDateTime === null || bDateTime === void 0 ? void 0 : bDateTime.valueOf()) - (aDateTime === null || aDateTime === void 0 ? void 0 : aDateTime.valueOf());
+            }
+            else {
+                if (aField === bField) {
+                    if (a._meta.rowIndex === b._meta.rowIndex)
+                        return 0;
+                    return a._meta.rowIndex < b._meta.rowIndex ? -1 : 1;
+                }
+                if (sortBy.direction === "asc") {
+                    return aField > bField ? 1 : -1;
+                }
+                return aField < bField ? 1 : -1;
+            }
+        };
+    };
+    return { getDefaultSortCompareFn: getDefaultSortCompareFn };
+};

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

@@ -1,4 +1,5 @@
-import { Field, FieldValidation, OnValidateRecord, Record, ValidationErrors } from "../../../../types";
+import { MutableRefObject } from "react";
+import { DuplicateValuesCollection, Field, FieldValidation, OnValidateRecord, Record, ValidationErrors } from "../../../../types";
 import { FieldValidator } from "./validators";
 type SelectedValidator = {
     validator: FieldValidation;
@@ -13,10 +14,11 @@ type ValidateRecordArgs = {
     validatorsCache?: SelectedFieldValidators[];
     record: Record;
     fields: Field[];
-    data: Record[];
+    duplicateValues: MutableRefObject<DuplicateValuesCollection>;
+    backendErrors?: ValidationErrors;
 };
 export declare function selectValidatorsFor(fields: Field[]): SelectedFieldValidators[];
-export declare function validateRecord({ record, fields, data, onValidateRecord, validatorsCache, }: ValidateRecordArgs): Promise<{
+export declare function validateRecord({ record, fields, onValidateRecord, validatorsCache, duplicateValues, backendErrors, }: ValidateRecordArgs): Promise<{
     errors?: ValidationErrors;
     warnings?: ValidationErrors;
 }>;

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

@@ -89,9 +89,9 @@ function safeCallOnValidateRecord(_a) {
     });
 }
 function safeCallValidator(_a) {
-    var field = _a.field, record = _a.record, validator = _a.validator, validatorFunction = _a.validatorFunction, data = _a.data;
+    var field = _a.field, record = _a.record, validator = _a.validator, validatorFunction = _a.validatorFunction, duplicateValues = _a.duplicateValues;
     try {
-        return validatorFunction(field, record[field.name], validator, data);
+        return validatorFunction(field, record[field.name], validator, duplicateValues);
     }
     catch (e) {
         console.error("Validator ".concat(validator === null || validator === void 0 ? void 0 : validator.validation_type, " for field ").concat(JSON.stringify(field), " and value ").concat(record[field.name], " failed."), e);
@@ -102,7 +102,7 @@ function mergeErrorsAndWarnings(currentErrors, errors) {
     return __assign(__assign({}, currentErrors), { errors: __assign(__assign({}, (currentErrors.errors || {})), errors), warnings: __assign({}, (currentErrors.warnings || {})) });
 }
 function runValidatorsFor(_a) {
-    var record = _a.record, data = _a.data, validators = _a.validators;
+    var record = _a.record, validators = _a.validators, duplicateValues = _a.duplicateValues;
     return validators.reduce(function (currentErrors, _a) {
         var field = _a.field, validators = _a.validators;
         var errors = {};
@@ -115,8 +115,8 @@ function runValidatorsFor(_a) {
                 field: field,
                 record: record,
                 validator: validator,
-                data: data,
                 validatorFunction: validatorFunction,
+                duplicateValues: duplicateValues,
             });
             if (error) {
                 errors[field.name] = error;
@@ -159,29 +159,25 @@ export function selectValidatorsFor(fields) {
     });
 }
 export function validateRecord(_a) {
-    var _b, _c;
-    var record = _a.record, fields = _a.fields, data = _a.data, onValidateRecord = _a.onValidateRecord, validatorsCache = _a.validatorsCache;
+    var record = _a.record, fields = _a.fields, onValidateRecord = _a.onValidateRecord, validatorsCache = _a.validatorsCache, duplicateValues = _a.duplicateValues, backendErrors = _a.backendErrors;
     return __awaiter(this, void 0, void 0, function () {
-        var isTouched, backendErrors, hasBackendErrors, validators, _d, validatorErrors, validatorWarnings, errors, warnings, _e, onValidateRecordErrors, onValidateRecordWarnings;
-        return __generator(this, function (_f) {
-            switch (_f.label) {
+        var validators, _b, validatorErrors, validatorWarnings, errors, warnings, _c, onValidateRecordErrors, onValidateRecordWarnings;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
                 case 0:
                     if (isRecordEmpty(record, fields)) {
                         //TODO: Check this logic because this can skip the validation of touched rows because all fields are empty
                         return [2 /*return*/, { errors: {}, warnings: {} }];
                     }
-                    isTouched = (_b = record._meta) === null || _b === void 0 ? void 0 : _b.touched;
-                    backendErrors = ((_c = record._meta) === null || _c === void 0 ? void 0 : _c.backendErrors) || {};
-                    hasBackendErrors = Object.keys(backendErrors).length > 0;
-                    if (!isTouched && hasBackendErrors) {
+                    if (backendErrors) {
                         return [2 /*return*/, { errors: backendErrors, warnings: {} }];
                     }
                     validators = validatorsCache !== null && validatorsCache !== void 0 ? validatorsCache : selectValidatorsFor(fields);
-                    _d = runValidatorsFor({
+                    _b = runValidatorsFor({
                         record: record,
-                        data: data,
                         validators: validators,
-                    }), validatorErrors = _d.errors, validatorWarnings = _d.warnings;
+                        duplicateValues: duplicateValues,
+                    }), validatorErrors = _b.errors, validatorWarnings = _b.warnings;
                     errors = ignoreNullOrUndefinedKeyValues(validatorErrors);
                     warnings = ignoreNullOrUndefinedKeyValues(validatorWarnings);
                     if (!!isNullOrUndefined(onValidateRecord)) return [3 /*break*/, 2];
@@ -190,7 +186,7 @@ export function validateRecord(_a) {
                             record: record,
                         })];
                 case 1:
-                    _e = _f.sent(), onValidateRecordErrors = _e.errors, onValidateRecordWarnings = _e.warnings;
+                    _c = _d.sent(), onValidateRecordErrors = _c.errors, onValidateRecordWarnings = _c.warnings;
                     return [2 /*return*/, {
                             errors: __assign(__assign({}, errors), onValidateRecordErrors),
                             warnings: __assign(__assign({}, warnings), onValidateRecordWarnings),

package/lib/esm/Importer/common/Spreadsheet/validation/validators.d.ts

@@ -1,5 +1,6 @@
-import { Field, FieldValidation, Record } from "../../../../types";
-export type FieldValidator = (field: Field, fieldValue: any, validation?: FieldValidation, data?: Record[]) => null | string;
+import { MutableRefObject } from "react";
+import { DuplicateValuesCollection, Field, FieldValidation } from "../../../../types";
+export type FieldValidator = (field: Field, fieldValue: any, validation?: FieldValidation, duplicateValues?: MutableRefObject<DuplicateValuesCollection>, customErrorMessage?: string) => null | string;
 export type FieldValidations = Partial<{
     [key: string]: FieldValidator;
 }>;

package/lib/esm/Importer/common/Spreadsheet/validation/validators.js

@@ -85,21 +85,37 @@ export var fieldValidations = {
         if (!isNullOrUndefined(field.pattern) &&
             !isNullOrUndefined(fieldValue) &&
             !DateTime.fromFormat(fieldValue, field.pattern).isValid) {
-            return "".concat(field.label, " must match the pattern ").concat(field.pattern);
+            var randomDate = DateTime.fromISO("1990-01-15T14:35:55.150", {
+                zone: "utc",
+            });
+            var transformedValue = randomDate === null || randomDate === void 0 ? void 0 : randomDate.toFormat(field.pattern);
+            var defaultMessage = "".concat(field.label, " must match the pattern ").concat(field.pattern);
+            return transformedValue
+                ? "Must be formatted as \"".concat(field.pattern, "\" (e.g. ").concat(transformedValue, ")")
+                : defaultMessage;
         }
     },
-    unique_case_sensitive: function (field, fieldValue, validator, data) {
+    unique_case_sensitive: function (field, fieldValue, validator, duplicateValues) {
         var _a;
-        if (!isNullOrUndefined(fieldValue) && !isNullOrUndefined(data)) {
-            var isDuplicated = data.filter(function (d) { return d[field.name] === fieldValue; }).length > 1;
+        if (!isNullOrUndefined(fieldValue) &&
+            !isNullOrUndefined(duplicateValues.current)) {
+            fieldValue = String(fieldValue);
+            var isDuplicated = duplicateValues.current[field.name] &&
+                duplicateValues.current[field.name][fieldValue] &&
+                duplicateValues.current[field.name][fieldValue].length > 1;
             var message = (_a = validator.message) !== null && _a !== void 0 ? _a : "".concat(field.label, " must be unique case sensitive");
             return isDuplicated ? message : undefined;
         }
     },
-    unique_case_insensitive: function (field, fieldValue, validator, data) {
+    unique_case_insensitive: function (field, fieldValue, validator, duplicateValues) {
         var _a;
-        if (!isNullOrUndefined(fieldValue) && !isNullOrUndefined(data)) {
-            var isDuplicated = data.filter(function (d) { var _a; return ((_a = d[field.name]) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === fieldValue.toLowerCase(); }).length > 1;
+        if (!isNullOrUndefined(fieldValue) &&
+            !isNullOrUndefined(duplicateValues.current)) {
+            fieldValue = String(fieldValue);
+            var isDuplicated = duplicateValues.current[field.name] &&
+                duplicateValues.current[field.name][fieldValue.toLowerCase()] &&
+                duplicateValues.current[field.name][fieldValue.toLowerCase()].length >
+                    1;
             var message = (_a = validator.message) !== null && _a !== void 0 ? _a : "".concat(field.label, " must be unique case insensitive");
             return isDuplicated ? message : undefined;
         }

package/lib/esm/Importer/common/theme.d.ts

@@ -42,6 +42,7 @@ declare const getCustomTheme: (importerStylePreferences: ImporterStylePreference
             red50: string;
             red100: string;
             red200: string;
+            red250: string;
             red300: string;
             red400: string;
             red500: string;

package/lib/esm/Importer/contexts/ImporterContextProvider.d.ts

@@ -1,8 +1,6 @@
-import Fuse from "fuse.js";
 import React from "react";
-import { FormatRecord, ImporterOptions, Integration, OnSubmit, OnValidateRecord, Record, TemplateHeader } from "../../types";
+import { CustomAction, FormatRecord, ImporterOptions, Integration, OnSubmit, OnValidateRecord, Record, TemplateHeader } from "../../types";
 import { FuseApi } from "../common/FuseApi";
-export declare const fusejsOptions: Fuse.IFuseOptions<string>;
 export type HeaderMatchings = {
     [templateHeaderLabel: string]: string;
 };
@@ -25,6 +23,7 @@ export type State = {
     initialRecords: Record[];
     enumFieldValueMatchings: EnumFieldValueMatchings;
     templateHeaders: TemplateHeader[];
+    userDynamicColumns: string[];
     templateHeaderMatchings: HeaderMatchings;
     uploadedDataHeaders: string[];
     matcherSubstep: number;
@@ -46,6 +45,7 @@ export type State = {
     setCurrentStepIndex: React.Dispatch<number>;
     setEnumFieldValueMatchings: React.Dispatch<React.SetStateAction<EnumFieldValueMatchings>>;
     setUploadedData: React.Dispatch<any[]>;
+    setHeadersMappings: React.Dispatch<any[]>;
     setTemplateHeaderMatchings: React.Dispatch<React.SetStateAction<HeaderMatchings>>;
     setPreviewFirstTime: React.Dispatch<boolean>;
     formatRecord: FormatRecord;
@@ -56,6 +56,10 @@ export type State = {
     isUsingManualImport: React.MutableRefObject<boolean>;
     resetImporterWhenUsingManualImport: () => void;
     manualDataImportSelected: () => void;
+    customActions: CustomAction[];
+    headerMappingsLoaded: boolean;
+    valueMappingsLoaded: boolean;
+    headersMappings: HeaderMappings[];
 };
 export type Props = {
     templateSlug: string;
@@ -68,6 +72,11 @@ export type Props = {
     formatRecord: FormatRecord;
     onValidateRecord?: OnValidateRecord;
     dynamicColumns: TemplateHeader[] | null;
+    customActions: CustomAction[];
 };
-export declare const ImporterContextProvider: ({ templateSlug, initialRecords, apiToken, children, options, onSubmit, onClose, formatRecord, onValidateRecord, dynamicColumns, }: Props) => JSX.Element;
+type HeaderMappings = {
+    [key: string]: string;
+};
+export declare const ImporterContextProvider: ({ templateSlug, initialRecords, apiToken, children, options, onSubmit, onClose, formatRecord, onValidateRecord, dynamicColumns, customActions, }: Props) => JSX.Element;
 export declare const useImporterContext: () => State;
+export {};