@shopify/react-form-state/build/esm/validators.mjs

Manage React forms tersely and type-safely with no magic

import { isEmpty, lengthMoreThan, lengthLessThan, isNumericString, isPositiveNumericString, notNumericString, notEmptyString, notEmpty } from '@shopify/predicates';
import { mapObject } from './utilities.mjs';

function validateNested(validatorDictionary) {
  return (input, fields) => {
    const errors = mapObject(input, (value, field) => {
      const validate = validatorDictionary[field];

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

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

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

      const errors = validate.map(validator => validator(value, fields)).filter(input => input != null);

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

      return errors;
    });
    const anyErrors = Object.keys(errors).map(key => errors[key]).some(value => value != null);

    if (anyErrors) {
      return errors;
    }
  };
}
function validateList(validatorDictionary) {
  const validateItem = validateNested(validatorDictionary);
  return (input, fields) => {
    const errors = input.map(item => validateItem(item, fields));

    if (errors.some(error => error != null)) {
      return errors;
    }
  };
}
function validateWithFields(matcher, errorContent) {
  return validate(matcher, errorContent);
}
function validate(matcher, errorContent) {
  return (input, fields) => {
    const matches = matcher(input, fields);
    /*
      always mark empty fields valid to match Polaris guidelines
      https://polaris.shopify.com/patterns/error-messages#section-form-validation
    */

    if (isEmpty(input)) {
      return;
    }

    if (matches) {
      return;
    }

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

    return errorContent;
  };
}
function validateRequired(matcher, errorContent) {
  return (input, fields) => {
    const matches = matcher(input, fields);

    if (matches) {
      return;
    }

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

    return errorContent;
  };
}
const validators = {
  lengthMoreThan(length, errorContent) {
    return validate(lengthMoreThan(length), errorContent);
  },

  lengthLessThan(length, errorContent) {
    return validate(lengthLessThan(length), errorContent);
  },

  numericString(errorContent) {
    return validate(isNumericString, errorContent);
  },

  positiveNumericString(errorContent) {
    return validate(isPositiveNumericString, errorContent);
  },

  nonNumericString(errorContent) {
    return validate(notNumericString, errorContent);
  },

  requiredString(errorContent) {
    return validateRequired(notEmptyString, errorContent);
  },

  required(errorContent) {
    return validateRequired(notEmpty, errorContent);
  }

};

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

  return obj.toString();
}

export default validators;
export { validate, validateList, validateNested, validateRequired, validateWithFields };