@shopify/react-form-state/build/cjs/validators.js

"use strict";

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

var _predicates = require("@shopify/predicates");

var _utilities = require("./utilities");

function validateNested(validatorDictionary) {
  return function (input, fields) {
    var errors = (0, _utilities.mapObject)(input, function (value, field) {
      var validate = validatorDictionary[field];

      if (validate == null) {
        return null;
      }

      if (typeof validate === 'function') {
        return validate(value, fields);
      }

      if (!Array.isArray(validate)) {
        return;
      }

      var errors = validate.map(function (validator) {
        return validator(value, fields);
      }).filter(function (input) {
        return input != null;
      });

      if (errors.length === 0) {
        return;
      }

      return errors;
    });
    var anyErrors = Object.keys(errors).map(function (key) {
      return errors[key];
    }).some(function (value) {
      return value != null;
    });

    if (anyErrors) {
      return errors;
    }
  };
}

function validateList(validatorDictionary) {
  var validateItem = validateNested(validatorDictionary);
  return function (input, fields) {
    var errors = input.map(function (item) {
      return validateItem(item, fields);
    });

    if (errors.some(function (error) {
      return error != null;
    })) {
      return errors;
    }
  };
}

function validateWithFields(matcher, errorContent) {
  return validate(matcher, errorContent);
}

function validate(matcher, errorContent) {
  return function (input, fields) {
    var matches = matcher(input, fields);
    /*
      always mark empty fields valid to match Polaris guidelines
      https://polaris.shopify.com/patterns/error-messages#section-form-validation
    */

    if ((0, _predicates.isEmpty)(input)) {
      return;
    }

    if (matches) {
      return;
    }

    if (typeof errorContent === 'function') {
      return errorContent(toString(input));
    }

    return errorContent;
  };
}

function validateRequired(matcher, errorContent) {
  return function (input, fields) {
    var matches = matcher(input, fields);

    if (matches) {
      return;
    }

    if (typeof errorContent === 'function') {
      return errorContent(toString(input));
    }

    return errorContent;
  };
}

var validators = {
  lengthMoreThan: function lengthMoreThan(length, errorContent) {
    return validate((0, _predicates.lengthMoreThan)(length), errorContent);
  },
  lengthLessThan: function lengthLessThan(length, errorContent) {
    return validate((0, _predicates.lengthLessThan)(length), errorContent);
  },
  numericString: function numericString(errorContent) {
    return validate(_predicates.isNumericString, errorContent);
  },
  positiveNumericString: function positiveNumericString(errorContent) {
    return validate(_predicates.isPositiveNumericString, errorContent);
  },
  nonNumericString: function nonNumericString(errorContent) {
    return validate(_predicates.notNumericString, errorContent);
  },
  requiredString: function requiredString(errorContent) {
    return validateRequired(_predicates.notEmptyString, errorContent);
  },
  required: function required(errorContent) {
    return validateRequired(_predicates.notEmpty, errorContent);
  }
};

function toString(obj) {
  if (obj == null) {
    return '';
  }

  return obj.toString();
}

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