dce-reactkit 3.5.1-beta.1 → 3.5.3

package/src/helpers/validators/validateEmail.test.ts

@@ -0,0 +1,110 @@
+// Import types
+import ValidationResult from './shared/types/ValidationResult';
+
+// Import constants
+import { INVALID_EMAIL_ERROR } from './shared/constants/ERROR_MESSAGES';
+
+// Import function
+import validateEmail from './validateEmail';
+
+/*------------------------------------------------------------------------*/
+/* ---------------------------- Valid Tests --------------------------- */
+/*------------------------------------------------------------------------*/
+
+const validEmailPairs: { input: string, cleaned: string }[] = [
+  {
+    input: 'username@gmail.com',
+    cleaned: 'username@gmail.com',
+  },
+  {
+    input: 'u@hotmail.org',
+    cleaned: 'u@hotmail.org',
+  },
+  {
+    input: '   username@gmail.com',
+    cleaned: 'username@gmail.com',
+  },
+  {
+    input: 'username@gmail.com        ',
+    cleaned: 'username@gmail.com',
+  },
+  {
+    input: ' username@gmail.com ',
+    cleaned: 'username@gmail.com',
+  },
+  {
+    input: 'username@harvard.edu',
+    cleaned: 'username@harvard.edu',
+  },
+  {
+    input: 'username@harvard.subdomain.edu',
+    cleaned: 'username@harvard.subdomain.edu',
+  },
+  {
+    input: '\nusername@harvard.subdomain.edu',
+    cleaned: 'username@harvard.subdomain.edu',
+  },
+  {
+    input: '\n\tusername@harvard.subdomain.edu',
+    cleaned: 'username@harvard.subdomain.edu',
+  },
+  {
+    input: 'username@harvard.subdomain.edu\n',
+    cleaned: 'username@harvard.subdomain.edu',
+  },
+  {
+    input: 'username@harvard.subdomain.edu\n\t',
+    cleaned: 'username@harvard.subdomain.edu',
+  },
+];
+
+test(
+  'Returns true for a given valid email and removes any leading or trailing whitespace.',
+  async () => {
+    validEmailPairs.forEach((pair) => {
+      const validResponse: ValidationResult<string> = {
+        isValid: true,
+        cleanedValue: pair.cleaned,
+      };
+
+      expect(validateEmail(pair.input)).toStrictEqual(validResponse);
+    });
+  },
+);
+
+/*------------------------------------------------------------------------*/
+/* ---------------------------- Invalid Tests --------------------------- */
+/*------------------------------------------------------------------------*/
+
+const invalidEmails: string[] = [
+  '',
+  ' ',
+  'gmail.com',
+  '@gmail.com ',
+  'username',
+  'username@.com',
+  'user name@gmail.com',
+  'username @gmail.com',
+  'username@ gmail.com',
+  'username@gmail .com',
+  'username\t@gmail.com',
+  'username\n@gmail.com',
+  'username@gmail\n.com',
+  'username@gmail.\tcom',
+  'user\nname@gmail.com',
+  'user\tname@gmail.com',
+];
+
+const invalidResponse: ValidationResult<string> = {
+  isValid: false,
+  errorMessage: INVALID_EMAIL_ERROR,
+};
+
+test(
+  'Returns false for a given invalid email.',
+  async () => {
+    invalidEmails.forEach((email) => {
+      expect(validateEmail(email)).toStrictEqual(invalidResponse);
+    });
+  },
+);

package/src/helpers/validators/validateEmail.ts

@@ -0,0 +1,47 @@
+// Import helpers
+import validateRegex from './shared/helpers/validateRegex';
+
+// Import constants
+import { INVALID_EMAIL_ERROR } from './shared/constants/ERROR_MESSAGES';
+
+// Import types
+import ValidationResult from './shared/types/ValidationResult';
+
+/**
+ * Determines whether a given email address is valid.
+ * @author Austen Money
+ * @param email email address to validate
+ * @returns whether email fulfills proper formatting requirements, includes a
+ *   cleaned version of the address without leading or trailing
+ *   whitespace if valid or an error message if invalid.
+ */
+const validateEmail = (
+  email: string,
+): ValidationResult<string> => {
+  // validation regex, sourced from HTML living standard: http://www.whatwg.org/specs/web-apps/current-work/multipage/forms.html#e-mail-state-(type=email)
+  // eslint-disable-next-line max-len
+  const emailRegex = /^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+
+  // remove leading and trailing whitespace
+  const cleanedValue: string = email.replace(/^\s+|\s+$/g, '');
+
+  // validate email with regex, and return error if not valid
+  return (
+    validateRegex(
+      {
+        input: cleanedValue,
+        regex: emailRegex,
+      },
+    ).isValid
+      ? {
+        isValid: true,
+        cleanedValue,
+      }
+      : {
+        isValid: false,
+        errorMessage: INVALID_EMAIL_ERROR,
+      }
+  );
+};
+
+export default validateEmail;

package/src/helpers/validators/validatePhoneNumber.test.ts

@@ -0,0 +1,94 @@
+// Import types
+import ValidationResult from './shared/types/ValidationResult';
+
+// Import constants
+import { INVALID_PHONE_ERROR } from './shared/constants/ERROR_MESSAGES';
+
+// Import function
+import validatePhoneNumber from './validatePhoneNumber';
+
+/*------------------------------------------------------------------------*/
+/* ---------------------------- Valid Tests --------------------------- */
+/*------------------------------------------------------------------------*/
+
+const cleanedNumber = '1234567890';
+const cleanedNumberExt = '11234567890';
+
+const validPhoneNumbers: { input: string, cleaned: string }[] = [
+  {
+    input: '1234567890',
+    cleaned: cleanedNumber,
+  },
+  {
+    input: '(123)-456-7890',
+    cleaned: cleanedNumber,
+  },
+  {
+    input: '123-456-7890',
+    cleaned: cleanedNumber,
+  },
+  {
+    input: '(123)456-7890',
+    cleaned: cleanedNumber,
+  },
+  {
+    input: '(123)4567890',
+    cleaned: cleanedNumber,
+  },
+  {
+    input: '    123456-7890 ',
+    cleaned: cleanedNumber,
+  },
+  {
+    input: '+1 123 456 7890',
+    cleaned: cleanedNumberExt,
+  },
+  {
+    input: '+1123456 7890',
+    cleaned: cleanedNumberExt,
+  },
+  {
+    input: '+1(123)456-7890',
+    cleaned: cleanedNumberExt,
+  },
+];
+
+test(
+  'Returns true for a given valid phone number and removes any non-digit characters.',
+  async () => {
+    validPhoneNumbers.forEach((pair) => {
+      const validResponse: ValidationResult<string> = {
+        isValid: true,
+        cleanedValue: pair.cleaned,
+      };
+
+      expect(validatePhoneNumber(pair.input)).toStrictEqual(validResponse);
+    });
+  },
+);
+
+/*------------------------------------------------------------------------*/
+/* ---------------------------- Invalid Tests --------------------------- */
+/*------------------------------------------------------------------------*/
+
+const invalidPhoneNumbers: string[] = [
+  '123456789',
+  '1234567894567890',
+  '1234-567-890',
+  '123456m78',
+  '123 4567 890',
+];
+
+const invalidResponse: ValidationResult<string> = {
+  isValid: false,
+  errorMessage: INVALID_PHONE_ERROR,
+};
+
+test(
+  'Returns false for a given valid phone number.',
+  async () => {
+    invalidPhoneNumbers.forEach((phoneNumber) => {
+      expect(validatePhoneNumber(phoneNumber)).toStrictEqual(invalidResponse);
+    });
+  },
+);

package/src/helpers/validators/validatePhoneNumber.ts

@@ -0,0 +1,49 @@
+// Import helpers
+import validateRegex from './shared/helpers/validateRegex';
+
+// Import constants
+import { INVALID_PHONE_ERROR } from './shared/constants/ERROR_MESSAGES';
+
+// Import types
+import ValidationResult from './shared/types/ValidationResult';
+
+/**
+ * Determines whether a given phone number is valid.
+ * @author Austen Money
+ * @param phoneNumber phone number to validate
+ * @returns whether phone number is considered valid - if valid, also returns
+ *   a cleaned version of the number without any formatting. If invalid,
+ *   returns an error message.
+ */
+const validatePhoneNumber = (
+  phoneNumber: string,
+): ValidationResult<string> => {
+  // regex to validate phone number
+  const validationRegex = /^\s*(?:\+?(\d{1,3}))?[-. (]*(\d{3})[-. )]*(\d{3})[-. ]*(\d{4})(?: *x(\d+))?\s*$/;
+
+  // validate phone number with regex
+  const validationResponse = validateRegex(
+    {
+      input: phoneNumber,
+      regex: validationRegex,
+    },
+  );
+
+  // remove all non-digits from number
+  const cleanedValue: string = phoneNumber.replace(/\D/g, '');
+
+  // return cleaned value if valid, or error message if invalid
+  return (
+    validationResponse.isValid
+      ? {
+        isValid: true,
+        cleanedValue,
+      }
+      : {
+        isValid: false,
+        errorMessage: INVALID_PHONE_ERROR,
+      }
+  );
+};
+
+export default validatePhoneNumber;

package/src/helpers/validators/validateString.test.ts

@@ -0,0 +1,173 @@
+// Import helpers
+import genCommaList from '../genCommaList';
+
+// Import types
+import ValidationResult from './shared/types/ValidationResult';
+
+// Import constants
+import { INVALID_STRING_ERRORS, INVALID_REGEX_ERROR } from './shared/constants/ERROR_MESSAGES';
+
+// Import function
+import validateString from './validateString';
+
+/*------------------------------------------------------------------------*/
+/* ---------------------------- Valid Tests --------------------------- */
+/*------------------------------------------------------------------------*/
+
+const validStrings: string[] = [
+  'users',
+  'username',
+  'MyValidString',
+  'HereisAnotherValidString',
+  'WoahAnotherValidStringIsHere',
+];
+
+const validReqs: {
+  // whitespace is removed from input before checking and returning
+  ignoreWhitespace?: boolean,
+  // input length must be at least minLen
+  minLen?: number,
+  // input length must be at most maxLen
+  maxLen?: number,
+  // input must only contain letters
+  lettersOnly?: boolean,
+  // input must only contain numbers
+  numbersOnly?: boolean,
+  // input must match given regExp
+  regexTest?: RegExp,
+  // description of regExp test, used to customize error messages
+  regexDescription?: string,
+}[] = [
+  {
+  },
+  {
+    minLen: 5,
+  },
+  {
+    minLen: 5,
+    maxLen: 30,
+  },
+  {
+    minLen: 5,
+    maxLen: 30,
+    lettersOnly: true,
+  },
+  {
+    minLen: 5,
+    maxLen: 30,
+    lettersOnly: true,
+    numbersOnly: false,
+  },
+  {
+    minLen: 5,
+    maxLen: 30,
+    lettersOnly: true,
+    numbersOnly: false,
+    ignoreWhitespace: false,
+  },
+];
+
+test(
+  'Returns true for a given valid string.',
+  async () => {
+    validStrings.forEach((validString) => {
+      validReqs.forEach((validReq) => {
+        const validResponse: ValidationResult<string> = {
+          isValid: true,
+          cleanedValue: validString,
+        };
+
+        expect(validateString(validString, validReq)).toStrictEqual(validResponse);
+      });
+    });
+
+    const validString = 'A string with whitespace!';
+
+    const validResponse: ValidationResult<string> = {
+      isValid: true,
+      cleanedValue: 'Astringwithwhitespace!',
+    };
+
+    const validOpt = {
+      maxLen: 22,
+      ignoreWhitespace: true,
+    };
+
+    expect(validateString(validString, validOpt)).toStrictEqual(validResponse);
+  },
+);
+
+/*------------------------------------------------------------------------*/
+/* ---------------------------- Invalid Tests --------------------------- */
+/*------------------------------------------------------------------------*/
+
+const invalidStrings: {
+  input: string,
+  reqs: {
+    // whitespace is removed from input before checking and returning
+    ignoreWhitespace?: boolean,
+    // input length must be at least minLen
+    minLen?: number,
+    // input length must be at most maxLen
+    maxLen?: number,
+    // input must only contain letters
+    lettersOnly?: boolean,
+    // input must only contain numbers
+    numbersOnly?: boolean,
+    // input must match given regExp
+    regexTest?: RegExp,
+    // description of regExp test, used to customize error messages
+    regexDescription?: string,
+  },
+  error: string[]
+}[] = [
+  {
+    input: 'ûšër',
+    reqs: {
+      minLen: 5,
+      lettersOnly: true,
+    },
+    error: [INVALID_STRING_ERRORS.MIN_LEN(5)],
+  },
+  {
+    input: '123456789',
+    reqs: {
+      minLen: 10,
+      maxLen: 5,
+      lettersOnly: true,
+    },
+    error: [INVALID_STRING_ERRORS.MIN_LEN(10), INVALID_STRING_ERRORS.MAX_LEN(5), INVALID_STRING_ERRORS.LETTERS_ONLY],
+  },
+  {
+    input: 'String with non-letters!!',
+    reqs: {
+      lettersOnly: true,
+      numbersOnly: true,
+      ignoreWhitespace: true,
+    },
+    error: [INVALID_STRING_ERRORS.LETTERS_ONLY, INVALID_STRING_ERRORS.NUMBERS_ONLY],
+  },
+  {
+    input: '12345678',
+    reqs: {
+      lettersOnly: true,
+      regexTest: /^\s*(?:\+?(\d{1,3}))?[-. (]*(\d{3})[-. )]*(\d{3})[-. ]*(\d{4})(?: *x(\d+))?\s*$/,
+      regexDescription: 'should be a phone number',
+    },
+    error: [INVALID_STRING_ERRORS.LETTERS_ONLY, `${INVALID_REGEX_ERROR}: should be a phone number`],
+  },
+];
+
+test(
+  'Returns false for a given invalid string.',
+  async () => {
+    invalidStrings.forEach((triple) => {
+      const invalidResponse: ValidationResult<string> = {
+        isValid: false,
+        errorMessage: `${INVALID_STRING_ERRORS.MESSAGE_INTRO}${genCommaList(triple.error)}.`,
+      };
+
+      expect(validateString(triple.input, triple.reqs)).toStrictEqual(invalidResponse);
+    });
+  },
+);

package/src/helpers/validators/validateString.ts

@@ -0,0 +1,171 @@
+// Import helpers
+import validateRegex from './shared/helpers/validateRegex';
+import genCommaList from '../genCommaList';
+
+// Import constants
+import { INVALID_STRING_ERRORS } from './shared/constants/ERROR_MESSAGES';
+
+// Import types
+import ValidationResult from './shared/types/ValidationResult';
+
+/*------------------------------------------------------------------------*/
+/* ------------------------------ Constants ----------------------------- */
+/*------------------------------------------------------------------------*/
+
+// define minimum and maximum range for lowercase ASCII chars
+const LOWERCASE_MIN = 65;
+const LOWERCASE_MAX = 90;
+
+// define minimum and maximum range for uppercase ASCII chars
+const UPPERCASE_MIN = 97;
+const UPPERCASE_MAX = 122;
+
+// define minimum and maximum range for ASCII digits
+const DIGIT_MIN = 48;
+const DIGIT_MAX = 57;
+
+/*------------------------------------------------------------------------*/
+/* ---------------------------- Main Function --------------------------- */
+/*------------------------------------------------------------------------*/
+
+/**
+ * Determines whether a given input string is considered valid based on
+ *   the provided requirements.
+ * @author Austen Money
+ * @param input input string
+ * @param opts options for validation
+ * @returns whether input is considered valid according to reqs - if
+ *   valid, returns a cleaned version of input; if invalid, returns
+ *   a string containing error messages describing which requirements
+ *   were not met.
+ */
+const validateString = (
+  input: string,
+  opts: {
+    // whitespace is removed from input before checking and returning
+    ignoreWhitespace?: boolean,
+    // input length must be at least minLen
+    minLen?: number,
+    // input length must be at most maxLen
+    maxLen?: number,
+    // input must only contain letters
+    // (future TODO: add option for passing in an array of permitted chars)
+    lettersOnly?: boolean,
+    // input must only contain numbers
+    numbersOnly?: boolean,
+    // input must match given regExp
+    regexTest?: RegExp,
+    // description of regExp test, used to customize error messages
+    regexDescription?: string,
+  },
+): ValidationResult<string> => {
+  // stores all invalid input errors
+  const errorMessages: string[] = [];
+
+  // contains version of input that will be returned
+  let cleanedValue: string = input;
+
+  // remove whitespace if required
+  if (opts.ignoreWhitespace) {
+    cleanedValue = input.replace(/\s+/g, '');
+  }
+
+  // apply max char requirement
+  if (opts.minLen) {
+    if (cleanedValue.length < opts.minLen) {
+      errorMessages.push(INVALID_STRING_ERRORS.MIN_LEN(opts.minLen));
+    }
+  }
+
+  // apply max char requirement
+  if (opts.maxLen) {
+    if (cleanedValue.length > opts.maxLen) {
+      errorMessages.push(INVALID_STRING_ERRORS.MAX_LEN(opts.maxLen));
+    }
+  }
+
+  // apply alphabetical requirement
+  if (opts.lettersOnly) {
+    // remove diacritics
+    cleanedValue = cleanedValue.normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+
+    const containsNonLetters = (
+      cleanedValue
+        // split into characters
+        .split('')
+        // convert into character codes
+        .map((curr) => {
+          return curr.charCodeAt(0);
+        })
+        // check for non-letters
+        .some((currCode) => {
+          return (
+            !(currCode >= LOWERCASE_MIN && currCode <= LOWERCASE_MAX)
+            && !(currCode >= UPPERCASE_MIN && currCode <= UPPERCASE_MAX)
+          );
+        })
+    );
+
+    if (containsNonLetters) {
+      errorMessages.push(INVALID_STRING_ERRORS.LETTERS_ONLY);
+    }
+  }
+
+  // apply numerical requirement
+  if (opts.numbersOnly) {
+    const containsNonNumbers = (
+      cleanedValue
+        // split into characters
+        .split('')
+        // convert into character codes
+        .map((curr) => {
+          return curr.charCodeAt(0);
+        })
+        // check for non-numbers
+        .some((currCode) => {
+          return (
+            !(currCode >= DIGIT_MIN && currCode <= DIGIT_MAX)
+          );
+        })
+    );
+
+    if (containsNonNumbers) {
+      errorMessages.push(INVALID_STRING_ERRORS.NUMBERS_ONLY);
+    }
+  }
+
+  // apply regex requirement
+  if (opts.regexTest) {
+    const regex = opts.regexTest;
+
+    // validate and create customized error message if description is provided
+    const result = validateRegex({
+      input: cleanedValue,
+      regex,
+      regexDescription: opts.regexDescription,
+    });
+
+    // if string did not pass regex validation, add error message
+    if (result.isValid === false) {
+      errorMessages.push(result.errorMessage);
+    }
+  }
+
+  // combine all error messages into one string to return
+  const errorMessage = `${INVALID_STRING_ERRORS.MESSAGE_INTRO}${genCommaList(errorMessages)}.`;
+
+  return (
+    // if no error messages, string is valid; if not, it is invalid
+    errorMessages.length === 0
+      ? {
+        isValid: true,
+        cleanedValue,
+      }
+      : {
+        isValid: false,
+        errorMessage,
+      }
+  );
+};
+
+export default validateString;

package/src/index.ts

@@ -66,6 +66,10 @@ import extractProp from './helpers/extractProp';
 import compareArraysByProp from './helpers/compareArraysByProp';
 import getLocalTimeInfo from './helpers/getLocalTimeInfo';
 import addDBEditorEndpoints from './helpers/addDBEditorEndpoints';
+import genCommaList from './helpers/genCommaList';
+import validateEmail from './helpers/validators/validateEmail';
+import validatePhoneNumber from './helpers/validators/validatePhoneNumber';
+import validateString from './helpers/validators/validateString';
 
 // Import types
 import ModalButtonType from './types/ModalButtonType';
@@ -149,6 +153,10 @@ export {
   isMobileOrTablet,
   extractProp,
   compareArraysByProp,
+  genCommaList,
+  validateEmail,
+  validatePhoneNumber,
+  validateString,
   getLocalTimeInfo,
   // Client helpers
   initClient,

package/tsconfig.json

@@ -15,8 +15,12 @@
     "allowSyntheticDefaultImports": true,
     "emitDeclarationOnly": true
   },
-
   "include": [
     "./src/**/*"
-  ]
+  ],
+  "ts-node": {
+    "compilerOptions": {
+      "module": "commonjs"
+    }
+  },
 }