re-use-form/dist/config.js

Easy-to-use React form hooks with built-in validation support

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.resolveConfig = resolveConfig;
exports.mergeConfigs = mergeConfigs;
exports.DEFAULT_CONFIG = void 0;

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }

function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

var DEFAULT_CONFIG = {
  initial: {}
};
exports.DEFAULT_CONFIG = DEFAULT_CONFIG;

function isResolved(config) {
  return 'validationDeps' in config;
}

function resolveConfig(config) {
  if (!config) return {};
  if (isResolved(config)) return config;
  var validationOptions = {};
  var validationsConfig = config.validations ? _objectSpread({}, config.validations) : {};
  var validationStrategy = 'onAnyError';
  var asyncValidationsConfig = {};

  if ('defaultOptions' in validationsConfig) {
    validationOptions = validationsConfig.defaultOptions;
    delete validationsConfig.defaultOptions;
  }

  if ('onChangeStrategy' in validationsConfig) {
    validationStrategy = validationsConfig.onChangeStrategy;
    delete validationsConfig.onChangeStrategy;
  }

  if ('async' in validationsConfig) {
    asyncValidationsConfig = validationsConfig.async;
    delete validationsConfig.async;
  }

  if ('rules' in validationsConfig) {
    validationsConfig = validationsConfig.rules;
  }

  var _extractValidationDep = extractValidationDeps(validationsConfig),
      _extractValidationDep2 = _slicedToArray(_extractValidationDep, 2),
      validationDeps = _extractValidationDep2[0],
      validations = _extractValidationDep2[1];

  var _extractAsyncValidati = extractAsyncValidations(asyncValidationsConfig),
      _extractAsyncValidati2 = _slicedToArray(_extractAsyncValidati, 2),
      asyncValidations = _extractAsyncValidati2[0],
      asyncErrorsStrategy = _extractAsyncValidati2[1];

  return {
    attrs: config.initial,
    pureHandlers: config.pureHandlers !== false && typeof WeakMap !== 'undefined',
    validationOptions: validationOptions,
    validations: validations,
    validationDeps: validationDeps,
    validationStrategy: validationStrategy,
    asyncValidations: asyncValidations,
    asyncErrorsStrategy: asyncErrorsStrategy,
    helpers: Array.isArray(config.helpers) ? config.helpers : config.helpers ? [config.helpers] : []
  };
}

function extractValidationDeps(validationsConfig) {
  var validations = _objectSpread({}, validationsConfig);

  var inputDeps = {};

  var _loop = function _loop(key) {
    if (_typeof(validations[key]) === 'object' && 'rules' in validations[key] && 'deps' in validations[key]) {
      validations[key].deps.forEach(function (dep) {
        if (!(dep in inputDeps)) {
          inputDeps[dep] = [];
        }

        inputDeps[dep].push(key);
      });
      validations[key] = validations[key].rules;
    }
  };

  for (var key in validations) {
    _loop(key);
  }

  return [inputDeps, validations];
}

function extractAsyncValidations(validationsConfig) {
  var validations = _objectSpread({}, validationsConfig);

  var errorsStrategy = 'takeFirst';

  if ('errorsStrategy' in validations) {
    errorsStrategy = validations.errorsStrategy;
    delete validations.errorsStrategy;
  }

  if ('rules' in validations) {
    validations = validations.rules;
  }

  return [validations, errorsStrategy];
}

function mergeValidations(validations1, validations2) {
  return mergeObj(validations1, validations2, function (val1, val2) {
    if (!Array.isArray(val1)) val1 = [val1];
    if (!Array.isArray(val2)) val2 = [val2];
    return [].concat(_toConsumableArray(val1), _toConsumableArray(val2));
  });
}

function mergeValidationOptions(opts1, opts2) {
  return mergeObj(opts1, opts2, function (_opt1, opt2) {
    return opt2;
  });
}

function mergeValidationDeps(deps1, deps2) {
  return mergeObj(deps1, deps2, function (deps1, deps2) {
    return [].concat(_toConsumableArray(deps1), _toConsumableArray(deps2));
  });
}

function mergeConfigs(config1, config2) {
  if (!config1) return config2;
  if (!config2) return config1;
  var resConfig1 = resolveConfig(config1);
  var resConfig2 = resolveConfig(config2);
  return {
    pureHandlers: resConfig1.pureHandlers,
    validationOptions: mergeValidationOptions(resConfig1.validationOptions, resConfig2.validationOptions),
    validations: mergeValidations(resConfig1.validations, resConfig2.validations),
    validationDeps: mergeValidationDeps(resConfig1.validationDeps, resConfig2.validationDeps),
    validationStrategy: config2.validationStrategy || config1.validationStrategy,
    asyncValidations: mergeValidations(resConfig1.asyncValidations, resConfig2.asyncValidations),
    asyncErrorsStrategy: config2.asyncErrorsStrategy || config1.asyncErrorsStrategy,
    helpers: [].concat(_toConsumableArray(resConfig1.helpers), _toConsumableArray(resConfig2.helpers))
  };
}

function mergeObj(obj1, obj2, resolver) {
  var merged = _objectSpread({}, obj1);

  for (var key in obj2) {
    if (key in obj1) {
      merged[key] = resolver(obj1[key], obj2[key]);
    } else {
      merged[key] = obj2[key];
    }
  }

  return merged;
}