dce-reactkit 3.4.0-beta.8 → 3.4.0

package/src/helpers/getOrdinal.test.ts

@@ -0,0 +1,84 @@
+/**
+ * Test file for the getOrdinal helper
+ * @author Gabe Abrams
+ */
+
+// Import main function
+import getOrdinal from './getOrdinal';
+
+describe('getOrdinal', () => {
+  it('should return "th" for 0', () => {
+    const result = getOrdinal(0);
+    expect(result).toEqual('th');
+  });
+
+  it('should return "st" for 1', () => {
+    const result = getOrdinal(1);
+    expect(result).toEqual('st');
+  });
+
+  it('should return "nd" for 2', () => {
+    const result = getOrdinal(2);
+    expect(result).toEqual('nd');
+  });
+
+  it('should return "rd" for 3', () => {
+    const result = getOrdinal(3);
+    expect(result).toEqual('rd');
+  });
+
+  it('should return "th" for 4', () => {
+    const result = getOrdinal(4);
+    expect(result).toEqual('th');
+  });
+
+  it('should return "th" for 11', () => {
+    const result = getOrdinal(11);
+    expect(result).toEqual('th');
+  });
+
+  it('should return "st" for 21', () => {
+    const result = getOrdinal(21);
+    expect(result).toEqual('st');
+  });
+
+  it('should return "nd" for 22', () => {
+    const result = getOrdinal(22);
+    expect(result).toEqual('nd');
+  });
+
+  it('should return "rd" for 23', () => {
+    const result = getOrdinal(23);
+    expect(result).toEqual('rd');
+  });
+
+  it('should return "th" for 24', () => {
+    const result = getOrdinal(24);
+    expect(result).toEqual('th');
+  });
+
+  it('should return "th" for 100', () => {
+    const result = getOrdinal(100);
+    expect(result).toEqual('th');
+  });
+
+  it('should return "st" for 101', () => {
+    const result = getOrdinal(101);
+    expect(result).toEqual('st');
+  });
+
+  it('should return "nd" for 102', () => {
+    const result = getOrdinal(102);
+    expect(result).toEqual('nd');
+  });
+
+  it('should return "rd" for 103', () => {
+    const result = getOrdinal(103);
+    expect(result).toEqual('rd');
+  });
+
+  it('should return "th" for 104', () => {
+    const result = getOrdinal(104);
+    expect(result).toEqual('th');
+  });
+});

package/src/helpers/{getOrdinal.tsx → getOrdinal.ts}

@@ -1,3 +1,4 @@
+// Constants
 const ORDINALS = ['th', 'st', 'nd', 'rd'];
 
 /**

package/src/helpers/getPartOfDay.test.ts

@@ -0,0 +1,56 @@
+/**
+ * Test file for the getPartOfDay helper
+ * @author Gabe Abrams
+ */
+
+import getPartOfDay from './getPartOfDay';
+
+describe('getPartOfDay', () => {
+  it('should return "morning" if the current hour is less than 12', () => {
+    // Mock the current hour to be 9am
+    jest.spyOn(Date.prototype, 'getHours').mockReturnValue(9);
+
+    const result = getPartOfDay();
+    expect(result).toEqual('morning');
+  });
+
+  it('should return "afternoon" if the current hour is between 12 and 16 (inclusive)', () => {
+    // Mock the current hour to be 2pm
+    jest.spyOn(Date.prototype, 'getHours').mockReturnValue(14);
+
+    const result = getPartOfDay();
+    expect(result).toEqual('afternoon');
+  });
+
+  it('should return "evening" if the current hour is between 17 and 24 (inclusive)', () => {
+    // Mock the current hour to be 8pm
+    jest.spyOn(Date.prototype, 'getHours').mockReturnValue(20);
+
+    const result = getPartOfDay();
+    expect(result).toEqual('evening');
+  });
+
+  it('should return "evening" if the current hour is 17', () => {
+    // Mock the current hour to be 5pm
+    jest.spyOn(Date.prototype, 'getHours').mockReturnValue(17);
+
+    const result = getPartOfDay();
+    expect(result).toEqual('evening');
+  });
+
+  it('should return "evening" if the current hour is 24', () => {
+    // Mock the current hour to be midnight
+    jest.spyOn(Date.prototype, 'getHours').mockReturnValue(24);
+
+    const result = getPartOfDay();
+    expect(result).toEqual('evening');
+  });
+
+  it('should return "morning" if the current hour is 0', () => {
+    // Mock the current hour to be midnight
+    jest.spyOn(Date.prototype, 'getHours').mockReturnValue(0);
+
+    const result = getPartOfDay();
+    expect(result).toEqual('morning');
+  });
+});

package/src/helpers/getTimeInfoInET.test.ts

@@ -0,0 +1,72 @@
+/**
+ * Test file for the getTimeInfoInET helper
+ * @author Gabe Abrams
+ */
+
+// Import main function
+import getTimeInfoInET from './getTimeInfoInET';
+
+describe('getTimeInfoInET', () => {
+  it('should return the current time info in ET if no argument is passed', () => {
+    const result = getTimeInfoInET();
+    const now = new Date();
+    const expectedTimestamp = now.getTime();
+    const expectedYear = now.getFullYear();
+    const expectedMonth = now.getMonth() + 1;
+    const expectedDay = now.getDate();
+    const expectedHour = now.getHours();
+    const expectedHour12 = expectedHour % 12 || 12;
+    const expectedMinute = now.getMinutes();
+    const expectedIsPM = expectedHour >= 12;
+    expect(result.timestamp).toBeCloseTo(expectedTimestamp, -2);
+    expect(result.year).toEqual(expectedYear);
+    expect(result.month).toEqual(expectedMonth);
+    expect(result.day).toEqual(expectedDay);
+    expect(result.hour).toEqual(expectedHour);
+    expect(result.hour12).toEqual(expectedHour12);
+    expect(result.minute).toEqual(expectedMinute);
+    expect(result.isPM).toEqual(expectedIsPM);
+  });
+
+  it('should return the time info in ET for a specified date', () => {
+    const date = new Date('2022-01-01T00:00:00Z');
+    const result = getTimeInfoInET(date);
+    const expectedTimestamp = date.getTime();
+    const expectedYear = 2021;
+    const expectedMonth = 12;
+    const expectedDay = 31;
+    const expectedHour = 19;
+    const expectedHour12 = 7;
+    const expectedMinute = 0;
+    const expectedIsPM = false;
+    expect(result.timestamp).toEqual(expectedTimestamp);
+    expect(result.year).toEqual(expectedYear);
+    expect(result.month).toEqual(expectedMonth);
+    expect(result.day).toEqual(expectedDay);
+    expect(result.hour).toEqual(expectedHour);
+    expect(result.hour12).toEqual(expectedHour12);
+    expect(result.minute).toEqual(expectedMinute);
+    expect(result.isPM).toEqual(expectedIsPM);
+  });
+
+  it('should return the time info in ET for a specified timestamp', () => {
+    const timestamp = 1640995200000; // 2022-01-01T00:00:00Z
+    const result = getTimeInfoInET(timestamp);
+    const expectedTimestamp = timestamp;
+    const expectedYear = 2021;
+    const expectedMonth = 12;
+    const expectedDay = 31;
+    const expectedHour = 19;
+    const expectedHour12 = 7;
+    const expectedMinute = 0;
+    const expectedIsPM = false;
+    expect(result.timestamp).toEqual(expectedTimestamp);
+    expect(result.year).toEqual(expectedYear);
+    expect(result.month).toEqual(expectedMonth);
+    expect(result.day).toEqual(expectedDay);
+    expect(result.hour).toEqual(expectedHour);
+    expect(result.hour12).toEqual(expectedHour12);
+    expect(result.minute).toEqual(expectedMinute);
+    expect(result.isPM).toEqual(expectedIsPM);
+  });
+});

package/src/helpers/validators/shared/constants/ERROR_MESSAGES.ts

@@ -0,0 +1,18 @@
+/*------------------------------------------------------------------------*/
+/* ------------------------------ Constants ----------------------------- */
+/*------------------------------------------------------------------------*/
+
+export const INVALID_REGEX_ERROR = 'input does not follow the requested format';
+export const INVALID_EMAIL_ERROR = 'Please provide a valid email address.';
+export const INVALID_PHONE_ERROR = 'Please provide a valid phone number.';
+export const INVALID_STRING_ERRORS = {
+  MIN_LEN: (minLen: number) => {
+    return `input must not be under ${minLen} character(s)`;
+  },
+  MAX_LEN: (maxLen: number) => {
+    return `input must not be over ${maxLen} character(s)`;
+  },
+  LETTERS_ONLY: 'input must only contain letters',
+  NUMBERS_ONLY: 'input must only contain numbers',
+  MESSAGE_INTRO: 'The following error(s) occurred: ',
+};

package/src/helpers/validators/shared/helpers/validateRegex.ts

@@ -0,0 +1,47 @@
+// Import types
+import ValidationResult from '../types/ValidationResult';
+
+// Import constants
+import { INVALID_REGEX_ERROR } from '../constants/ERROR_MESSAGES';
+
+/**
+ * Determines whether a given input string is considered valid based on
+ *   the provided regex.
+ * @author Austen Money
+ * @param opts object containing all args
+ * @param opts.input user-provided input to validate
+ * @param opts.regex regular expression to check against input
+ * @param [opts.regexDescription] description of what regexString is checking
+ *   for, used to customize error message
+ * @returns the unchanged input if valid, or a customized error message if
+ *   invalid
+ */
+const validateRegex = (
+  opts: {
+    input: string,
+    regex: RegExp,
+    regexDescription?: string,
+  },
+): ValidationResult<string> => {
+  // customize error message in case of invalid input
+  const errorMessage = `${INVALID_REGEX_ERROR}${
+    opts.regexDescription
+      ? ': '
+      : ''
+  }${opts.regexDescription}`;
+
+  // return error message if test is invalid, or input string if valid
+  return (
+    opts.regex.test(opts.input)
+      ? {
+        isValid: true,
+        cleanedValue: opts.input,
+      }
+      : {
+        isValid: false,
+        errorMessage,
+      }
+  );
+};
+
+export default validateRegex;

package/src/helpers/validators/shared/types/ValidationResult.ts

@@ -0,0 +1,20 @@
+/**
+ * Result of a validation function.
+ * @author Austen Money
+ */
+type ValidationResult<CleanedValueType> = (
+  | {
+    // if true, the validation was successful
+    isValid: true,
+    // the cleaned version of the value
+    cleanedValue: CleanedValueType,
+  }
+  | {
+    // if false, the validation was not successful
+    isValid: false,
+    // describes why the validation failed
+    errorMessage: string,
+  }
+);
+
+export default ValidationResult;

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;