Updates deps and README.md, adds methods to lib and new demo

Author: gorlandor

README.md

@@ -15,13 +15,22 @@ Valido — A helper library for form validation built on top of .@chriso's valid
 
 ```javascript
 
-const Valido = require('../lib/Valido.util');
-const idNumber = '$not_alpha_numeric_only#(u)123';
-
-if (Valido.IsAlphaNumericOnly(idNumber) === true) {
-    alert('Valid id');
-} else {
-    alert('Not Valido');
-}
+const Valido = require("../lib/Valido.util");
+const expect = require('expect');
+
+test('String does not meet specified length', () => {
+
+  const username = "bass";
+
+  const { valid, errors } = Valido.validateProperLength({
+    value: username,
+    minLength: 8,
+    maxLength: 15
+  });
+
+  expect(errors.length).toBeGreaterThan(0);
+  expect(valid).toEqual(false);
+
+});
 
 ```

lib/Valido.util.js

@@ -1,5 +1,22 @@
 const validator = require("validator");
 
+/**   
+ * @typedef {Object} TextInputProps
+ * @property {string} value - The input value
+ * @property {string} fieldName - The input label or labeled-by, used for validation message
+ * @property {string[]} errors - A collection of the validation errors
+ * @property {string} [required] - Indicates whether the input is required
+ * @property {string} [minLength] - Specifies the minimum character length of an input, if present
+ * @property {string} [maxLength] - Specifies the maximum character length of an input, if present   
+ * @property {boolean} dirty - Indicates whether the input has been edited by the user
+ */
+
+/**   
+ * @typedef {Object} InputValidationResult
+ * @property {boolean} valid - Indicates whether the input meets the validation tests 
+ * @property {string[]} errors - A collection of the validation errors  
+ */
+
 /**
  * Validation library for handling checks for
  * valid Email, Password, Phone, SSN, TIN, Date (MM/dd/yyyy) and Alphanumeric formats,
@@ -125,7 +142,7 @@ class Valido {
     if (typeof value !== "string") return false;
 
     const regex = new RegExp(/^po|^po box|^p.o.|^p.o. box|^post office box|^pmb|^private mailbox|^hc|^rr|hc [0-9]+ box [0-9]+|po box [0-9]+|rr [0-9]+ box [0-9]+/gim);
-    return regex.test(value) == false;
+    return regex.test(value) === false;
   }
 
   /**
@@ -152,6 +169,142 @@ class Valido {
     return regex.test(value);
   }
 
+
+  /**
+   * Validates the email address given meets the appropriate format
+   * @param {string} value 
+   */
+  static validateEmail(value) {
+    let errors = [];
+
+    if (value.length > 0) {
+      if (!Valido.IsEmail(value)) {
+        errors.push("The value given is not a valid email address");
+      }
+    }
+
+    return { valid: errors.length === 0, errors };
+  }
+
+  static validatePassword(value, name, props) {
+    let errors = [];
+
+    if (value.length > 0) {
+      if (
+        !Valido.IsPassword(
+          value,
+          props[name].alphanumeric,
+          props[name].containsUpperCase,
+          props[name].minLength,
+          props[name].maxLength
+        )
+      ) {
+        if ('containsUpperCase' in props[name] && Valido.containsUpperCase.test(value) === false) {
+          errors.push(`Password must contain at least one uppercase characters`);
+        }
+
+        if ('alphanumeric' in props[name] && Valido.containsNumbers.test(value) === false) {
+          errors.push(`Password must contain at least one number`);
+        }
+      }
+      if ('containsSpecialChar' in props[name] && Valido.containsSpecialChar.test(value) === false) {
+        errors.push(`Password must contain at least one special character`);
+      }
+    }
+
+    return { valid: errors.length === 0, errors };
+  }
+
+  /**
+   * Validates if the input meets the specified min length and returns a collection of the validation errors
+   * @param {TextInputProps} props 
+   * @returns {InputValidationResult} 
+   */
+  static validateMinLength(props) {
+    let errors = [];
+
+    if (props.minLength && props.value.length < props.minLength && props.value.length > 0) {
+      errors.push(`The field ${props.fieldName} must be at least ${props.minLength} characters long`);
+    }
+
+    return { valid: errors.length === 0, errors };
+  }
+
+  /**
+   * Validates if the input meets the specified max length and returns a collection of the validation errors
+   * @param {TextInputProps} props 
+   * @returns {InputValidationResult} 
+   */
+  static validateMaxLength(props) {
+    let errors = [];
+
+    if (props.maxLength && props.value.length > props.maxLength) {
+      errors.push(`The field ${props.fieldName} does not meet the maximum length`);
+    }
+
+    return { valid: errors.length === 0, errors };
+  }
+
+  /**
+   * Validates if the input meets the specified min length and returns a collection of the validation errors
+   * @param {TextInputProps} props 
+   * @returns {InputValidationResult} 
+   */
+  static validateProperLength(props) {
+    let errors = [];
+
+    if (props.minLength && props.value.length < props.minLength && props.value.length > 0) {
+      errors.push(`The field ${props.fieldName} must be at least ${props.minLength} characters long`);
+    }
+
+    if (props.maxLength && props.value.length > props.maxLength) {
+      errors.push(`The field ${props.fieldName} does not meet the maximum length`);
+    }
+
+    return { valid: errors.length === 0, errors };
+  }
+
+  /**
+   * Validates if the input is required and has a value, and returns a valid flag along with a collection of the validation errors
+   * @param {TextInputProps} props 
+   * @returns {InputValidationResult} 
+   */
+  static validateRequired(props) {
+    let errors = [];
+
+    if (props.required && props.value.length === 0 && (props.dirty)) {
+      errors.push(`The field ${props.fieldName} is required`);
+    }
+
+    return { valid: errors.length === 0, errors };
+  }
+
+  /**
+   * 
+   * @param {{[x: string]: TextInputProps }} values 
+   * @returns {Promise<boolean>} result
+   */
+  static isFormValid(values) {
+    const inputKeys = Object.keys(values);
+
+    const result = inputKeys.every(function (propertyName) {
+
+      /**
+       * @type {boolean}
+       */
+      const propertyIsRequired = typeof values[propertyName] === "object" && values[propertyName].required;
+
+      // if not required then it evaluates to true, otherwise it checks that there are no errors and the input is not empty
+      const isValid =
+        !propertyIsRequired ||
+        (values[propertyName].errors.length === 0 && values[propertyName].value.length > 0);
+
+      return isValid;
+    });
+
+    return Promise.resolve(result);
+  }
+
 }
 
 module.exports = Valido;