@data-driven-forms/react-form-renderer/validation/validation.js

React Form Renderer. Data Driven Forms converts JSON form definitions into fully functional React forms.

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));

var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var _get = _interopRequireDefault(require("lodash/get"));

var _composeValidators = _interopRequireDefault(require("../compose-validators"));

var _defaultSchemaValidator = _interopRequireDefault(require("../default-schema-validator"));

var _getValidates = _interopRequireDefault(require("../get-validates"));

var _getVisibleFields = _interopRequireDefault(require("../get-visible-fields"));

var _validatorMapper = _interopRequireDefault(require("../validator-mapper"));

var _validatorHelpers = require("../use-field-api/validator-helpers");

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }

var DEFAULT_COMPONENT = 'default-component';

var noop = function noop() {};

var changeToDefaultComponent = function changeToDefaultComponent(schema) {
  if (Array.isArray(schema)) {
    return schema.map(changeToDefaultComponent);
  }

  return _objectSpread(_objectSpread(_objectSpread({}, schema), schema.component && {
    component: DEFAULT_COMPONENT
  }), schema.fields && {
    fields: changeToDefaultComponent(schema.fields)
  });
};

var validation = /*#__PURE__*/function () {
  var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(schema, options) {
    var values, componentMapper, validatorMapper, actionMapper, schemaValidatorMapper, omitWarnings, conditionMapper, validatorMapperMerged, validatorTypes, actionTypes, finalComponentMapper, finalSchema, validates;
    return _regenerator["default"].wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            if (schema) {
              _context2.next = 2;
              break;
            }

            throw new Error('validation requires a schema as the first argument.');

          case 2:
            if (!((0, _typeof2["default"])(options) !== 'object')) {
              _context2.next = 4;
              break;
            }

            throw new Error("options argument has to be type of object, provided: ".concat((0, _typeof2["default"])(options)));

          case 4:
            values = options.values, componentMapper = options.componentMapper, validatorMapper = options.validatorMapper, actionMapper = options.actionMapper, schemaValidatorMapper = options.schemaValidatorMapper, omitWarnings = options.omitWarnings, conditionMapper = options.conditionMapper;
            validatorMapperMerged = _objectSpread(_objectSpread({}, _validatorMapper["default"]), validatorMapper);
            validatorTypes = Object.keys(validatorMapperMerged);
            actionTypes = Object.keys(actionMapper || {});
            finalComponentMapper = componentMapper;
            finalSchema = schema;

            if (!finalComponentMapper) {
              finalComponentMapper = (0, _defineProperty2["default"])({}, DEFAULT_COMPONENT, noop);
              finalSchema = changeToDefaultComponent(schema);
            }

            (0, _defaultSchemaValidator["default"])(finalSchema, finalComponentMapper, validatorTypes, actionTypes, schemaValidatorMapper);
            finalSchema = (0, _getVisibleFields["default"])(finalSchema, values, undefined, conditionMapper);
            validates = (0, _getValidates["default"])(finalSchema, {
              componentMapper: finalComponentMapper,
              actionMapper: actionMapper,
              values: values
            });
            _context2.next = 16;
            return Object.keys(validates).reduce( /*#__PURE__*/function () {
              var _ref2 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(accP, name) {
                var acc, error, index, validateFn, fieldError;
                return _regenerator["default"].wrap(function _callee$(_context) {
                  while (1) {
                    switch (_context.prev = _context.next) {
                      case 0:
                        _context.next = 2;
                        return accP;

                      case 2:
                        acc = _context.sent;
                        index = 0;

                      case 4:
                        if (!(!error && index + 1 <= validates[name].length)) {
                          _context.next = 13;
                          break;
                        }

                        validateFn = (0, _composeValidators["default"])((0, _validatorHelpers.getValidate)(validates[name][index], undefined, validatorMapperMerged));
                        _context.next = 8;
                        return validateFn((0, _get["default"])(values, name), values, {});

                      case 8:
                        fieldError = _context.sent;

                        if ((fieldError === null || fieldError === void 0 ? void 0 : fieldError.type) !== 'warning' || (fieldError === null || fieldError === void 0 ? void 0 : fieldError.type) === 'warning' && !omitWarnings) {
                          error = fieldError;
                        }

                        index = index + 1;
                        _context.next = 4;
                        break;

                      case 13:
                        if (!error) {
                          _context.next = 15;
                          break;
                        }

                        return _context.abrupt("return", _objectSpread(_objectSpread({}, acc), {}, (0, _defineProperty2["default"])({}, name, error)));

                      case 15:
                        return _context.abrupt("return", acc);

                      case 16:
                      case "end":
                        return _context.stop();
                    }
                  }
                }, _callee);
              }));

              return function (_x3, _x4) {
                return _ref2.apply(this, arguments);
              };
            }(), {});

          case 16:
            return _context2.abrupt("return", _context2.sent);

          case 17:
          case "end":
            return _context2.stop();
        }
      }
    }, _callee2);
  }));

  return function validation(_x, _x2) {
    return _ref.apply(this, arguments);
  };
}();

var _default = validation;
exports["default"] = _default;