fuse-importer 0.24.4 → 0.25.0

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

@@ -60,17 +60,29 @@ var datePatternTypes = ["date", "datetime", "time"];
 function safeCallOnValidateRecord(_a) {
     var onValidateRecord = _a.onValidateRecord, record = _a.record;
     return __awaiter(this, void 0, void 0, function () {
-        var error_1;
+        var result, isNewVersion, mappedResult, errors, warnings, error_1;
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
                     _b.trys.push([0, 2, , 3]);
                     return [4 /*yield*/, onValidateRecord(record)];
-                case 1: return [2 /*return*/, _b.sent()];
+                case 1:
+                    result = _b.sent();
+                    isNewVersion = "errors" in result || "warnings" in result;
+                    mappedResult = isNewVersion
+                        ? result
+                        : result;
+                    errors = isNewVersion
+                        ? mappedResult.errors
+                        : mappedResult;
+                    warnings = isNewVersion
+                        ? mappedResult.warnings
+                        : mappedResult;
+                    return [2 /*return*/, { errors: errors || {}, warnings: warnings || {} }];
                 case 2:
                     error_1 = _b.sent();
                     console.warn("onValidateRecord hook failed with error: ".concat(error_1));
-                    return [2 /*return*/, {}];
+                    return [2 /*return*/, { errors: {}, warnings: {} }];
                 case 3: return [2 /*return*/];
             }
         });
@@ -105,7 +117,7 @@ function runValidatorsFor(_a) {
                 break;
             }
         }
-        return __assign(__assign({}, currentErrors), errors);
+        return __assign(__assign({}, currentErrors), { errors: __assign(__assign({}, (currentErrors.errors || {})), errors), warnings: __assign({}, (currentErrors.warnings || {})) });
     }, {});
 }
 export function selectValidatorsFor(fields) {
@@ -144,28 +156,40 @@ export function validateRecord(_a) {
     var _b, _c;
     var record = _a.record, fields = _a.fields, data = _a.data, onValidateRecord = _a.onValidateRecord, validatorsCache = _a.validatorsCache;
     return __awaiter(this, void 0, void 0, function () {
-        var isTouched, backendErrors, hasBackendErrors, validators, validatorErrors, errors, hasError;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
+        var isTouched, backendErrors, hasBackendErrors, validators, _d, validatorErrors, validatorWarnings, errors, warnings, _e, onValidateRecordErrors, onValidateRecordWarnings;
+        return __generator(this, function (_f) {
+            switch (_f.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*/, {}];
+                        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) {
-                        return [2 /*return*/, backendErrors];
+                        return [2 /*return*/, { errors: backendErrors, warnings: {} }];
                     }
                     validators = validatorsCache !== null && validatorsCache !== void 0 ? validatorsCache : selectValidatorsFor(fields);
-                    validatorErrors = runValidatorsFor({ record: record, data: data, validators: validators });
+                    _d = runValidatorsFor({
+                        record: record,
+                        data: data,
+                        validators: validators,
+                    }), validatorErrors = _d.errors, validatorWarnings = _d.warnings;
                     errors = ignoreNullOrUndefinedKeyValues(validatorErrors);
-                    hasError = Object.keys(errors).length > 0;
-                    if (!(!hasError && !isNullOrUndefined(onValidateRecord))) return [3 /*break*/, 2];
-                    return [4 /*yield*/, safeCallOnValidateRecord({ onValidateRecord: onValidateRecord, record: record })];
-                case 1: return [2 /*return*/, _d.sent()];
-                case 2: return [2 /*return*/, errors];
+                    warnings = ignoreNullOrUndefinedKeyValues(validatorWarnings);
+                    if (!!isNullOrUndefined(onValidateRecord)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, safeCallOnValidateRecord({
+                            onValidateRecord: onValidateRecord,
+                            record: record,
+                        })];
+                case 1:
+                    _e = _f.sent(), onValidateRecordErrors = _e.errors, onValidateRecordWarnings = _e.warnings;
+                    return [2 /*return*/, {
+                            errors: __assign(__assign({}, errors), onValidateRecordErrors),
+                            warnings: __assign(__assign({}, warnings), onValidateRecordWarnings),
+                        }];
+                case 2: return [2 /*return*/, { errors: errors, warnings: warnings }];
             }
         });
     });

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

@@ -92,6 +92,8 @@ declare const getCustomTheme: (importerStylePreferences: ImporterStylePreference
             orange800: string;
             orange900: string;
             orange1000: string;
+            orange1100: string;
+            orange1200: string;
         };
         readonly textStyles: {
             h1: import("styled-components").FlattenSimpleInterpolation;

package/lib/esm/Importer/data/index.js

@@ -116,7 +116,6 @@ export var getReviewDataSet = function (_a) {
         name: templateHeader.internal_key,
         type: FieldTypes[templateHeader.column_type] || FieldTypes.string,
         isRequired: templateHeader.required,
-        isUnique: templateHeader.unique,
         options: templateHeader.values,
         pattern: templateHeader.pattern,
         validations: templateHeader.validations,

package/lib/esm/styled/theme/colorPalette.d.ts

@@ -63,6 +63,8 @@ export declare const colorPalette: {
     orange800: string;
     orange900: string;
     orange1000: string;
+    orange1100: string;
+    orange1200: string;
 };
 export declare const colorLabels: {
     readonly backgroundInterface: string;
@@ -164,4 +166,6 @@ export declare const colors: {
     orange800: string;
     orange900: string;
     orange1000: string;
+    orange1100: string;
+    orange1200: string;
 };

package/lib/esm/styled/theme/colorPalette.js

@@ -79,6 +79,8 @@ var orange = {
     orange800: "#885A05",
     orange900: "#654304",
     orange1000: "#432D03",
+    orange1100: "#FEEBD9",
+    orange1200: "#78430D",
 };
 var white = {
     white: "white",

package/lib/esm/styled/theme/index.d.ts

@@ -196,6 +196,8 @@ export declare const theme: {
         orange800: string;
         orange900: string;
         orange1000: string;
+        orange1100: string;
+        orange1200: string;
     };
     readonly textStyles: {
         h1: import("styled-components").FlattenSimpleInterpolation;

package/lib/esm/types.d.ts

@@ -34,6 +34,7 @@ export type Meta = {
     id: string;
     rowIndex: number;
     isInvalid?: boolean;
+    hasWarning?: boolean;
     touched?: boolean;
     backendErrors?: ValidationErrors;
 };
@@ -44,10 +45,14 @@ export type Record = {
 export type RecordDataSet = {
     [key: string]: Record;
 };
+export type ValidationResult = {
+    errors: ValidationErrors;
+    warnings: ValidationErrors;
+};
 export type ValidationErrors = {
     [k: string]: string;
 };
-export type OnValidateRecord = (record: Record) => Promise<ValidationErrors>;
+export type OnValidateRecord = (record: Record) => Promise<ValidationResult | ValidationErrors>;
 export type FormatRecord = (record: Record) => Record;
 export type RowValidationError = {
     rowId: string;
@@ -112,7 +117,6 @@ export type Field = {
     label: string;
     type: FieldTypes;
     isRequired?: boolean;
-    isUnique?: boolean;
     options?: any;
     pattern?: string;
     validations?: FieldValidation[];