dce-reactkit 3.4.0 → 3.5.1-beta.1

package/src/helpers/getHumanReadableDate.test.ts

@@ -1,29 +0,0 @@
-/**
- * Test file for the getHumanReadableDate helper
- * @author Gabe Abrams
- */
-
-// Import helpers
-import getHumanReadableDate from './getHumanReadableDate';
-import getOrdinal from './getOrdinal';
-
-describe('getHumanReadableDate', () => {
-  it('should return the current date if no argument is passed', () => {
-    const result = getHumanReadableDate();
-    const now = new Date();
-    const expected = `${now.toLocaleString('default', { month: 'short' })} ${now.getDate()}${getOrdinal(now.getDate())}`;
-    expect(result).toEqual(expected);
-  });
-
-  it('should return the correct date for a given timestamp', () => {
-    const timestamp = 1629822000000; // 2021-08-24T12:20:00.000Z
-    const result = getHumanReadableDate(timestamp);
-    expect(result).toEqual('Aug 24th 2021');
-  });
-
-  it('should return the correct date for a given Date object', () => {
-    const date = new Date('2021-08-24T12:20:00.000Z');
-    const result = getHumanReadableDate(date);
-    expect(result).toEqual('Aug 24th 2021');
-  });
-});

package/src/helpers/getLocalTimeInfo.test.ts

@@ -1,48 +0,0 @@
-/**
- * Test for getLocalTimeInfo helper function
- *   NOTE: only works if this test is run on a machine in ET
- * @author Gabe Abrams
- */
-
-// Import main function
-import getLocalTimeInfo from './getLocalTimeInfo';
-
-describe('getLocalTimeInfo', () => {
-  it('should return current time info if no argument is passed', () => {
-    const result = getLocalTimeInfo();
-    const now = new Date();
-    expect(result.timestamp).toBeCloseTo(now.getTime(), -3);
-    expect(result.year).toEqual(now.getFullYear());
-    expect(result.month).toEqual(now.getMonth() + 1);
-    expect(result.day).toEqual(now.getDate());
-    expect(result.hour).toEqual(now.getHours());
-    expect(result.minute).toEqual(now.getMinutes());
-    expect(result.isPM).toEqual(now.getHours() >= 12);
-  });
-
-  it('should return correct time info for a given timestamp', () => {
-    const timestamp = 1629822000000; // 2021-08-24T12:20:00.000Z
-    const result = getLocalTimeInfo(timestamp);
-    expect(result.timestamp).toEqual(timestamp);
-    expect(result.year).toEqual(2021);
-    expect(result.month).toEqual(8);
-    expect(result.day).toEqual(24);
-    expect(result.hour).toEqual(12);
-    expect(result.hour12).toEqual(12);
-    expect(result.minute).toEqual(20);
-    expect(result.isPM).toEqual(true);
-  });
-
-  it('should return correct time info for a given Date object', () => {
-    const date = new Date('2021-08-24T12:20:00.000Z');
-    const result = getLocalTimeInfo(date);
-    expect(result.timestamp).toEqual(date.getTime());
-    expect(result.year).toEqual(2021);
-    expect(result.month).toEqual(8);
-    expect(result.day).toEqual(24);
-    expect(result.hour).toEqual(8);
-    expect(result.hour12).toEqual(8);
-    expect(result.minute).toEqual(20);
-    expect(result.isPM).toEqual(false);
-  });
-});

package/src/helpers/getMonthName.test.ts

@@ -1,79 +0,0 @@
-/**
- * Test for getMonthName helper
- * @author Gabe Abrams
- */
-
-// Import main helper
-import getMonthName from './getMonthName';
-
-describe('getMonthName', () => {
-  it('should return January for 1', () => {
-    const result = getMonthName(1);
-    expect(result).toEqual({ short: 'Jan', full: 'January' });
-  });
-
-  it('should return February for 2', () => {
-    const result = getMonthName(2);
-    expect(result).toEqual({ short: 'Feb', full: 'February' });
-  });
-
-  it('should return March for 3', () => {
-    const result = getMonthName(3);
-    expect(result).toEqual({ short: 'Mar', full: 'March' });
-  });
-
-  it('should return April for 4', () => {
-    const result = getMonthName(4);
-    expect(result).toEqual({ short: 'Apr', full: 'April' });
-  });
-
-  it('should return May for 5', () => {
-    const result = getMonthName(5);
-    expect(result).toEqual({ short: 'May', full: 'May' });
-  });
-
-  it('should return June for 6', () => {
-    const result = getMonthName(6);
-    expect(result).toEqual({ short: 'Jun', full: 'June' });
-  });
-
-  it('should return July for 7', () => {
-    const result = getMonthName(7);
-    expect(result).toEqual({ short: 'Jul', full: 'July' });
-  });
-
-  it('should return August for 8', () => {
-    const result = getMonthName(8);
-    expect(result).toEqual({ short: 'Aug', full: 'August' });
-  });
-
-  it('should return September for 9', () => {
-    const result = getMonthName(9);
-    expect(result).toEqual({ short: 'Sep', full: 'September' });
-  });
-
-  it('should return October for 10', () => {
-    const result = getMonthName(10);
-    expect(result).toEqual({ short: 'Oct', full: 'October' });
-  });
-
-  it('should return November for 11', () => {
-    const result = getMonthName(11);
-    expect(result).toEqual({ short: 'Nov', full: 'November' });
-  });
-
-  it('should return December for 12', () => {
-    const result = getMonthName(12);
-    expect(result).toEqual({ short: 'Dec', full: 'December' });
-  });
-
-  it('should return January for 0', () => {
-    const result = getMonthName(0);
-    expect(result).toEqual({ short: 'Jan', full: 'January' });
-  });
-
-  it('should return January for 13', () => {
-    const result = getMonthName(13);
-    expect(result).toEqual({ short: 'Jan', full: 'January' });
-  });
-});

package/src/helpers/getOrdinal.test.ts

@@ -1,84 +0,0 @@
-/**
- * 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/getPartOfDay.test.ts

@@ -1,56 +0,0 @@
-/**
- * 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

@@ -1,72 +0,0 @@
-/**
- * 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

@@ -1,18 +0,0 @@
-/*------------------------------------------------------------------------*/
-/* ------------------------------ 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

@@ -1,47 +0,0 @@
-// 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

@@ -1,20 +0,0 @@
-/**
- * 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

@@ -1,110 +0,0 @@
-// 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

@@ -1,47 +0,0 @@
-// 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;