dce-reactkit 3.5.1-beta.1 → 3.5.3

package/src/helpers/genCSV.test.ts

@@ -0,0 +1,61 @@
+/**
+ * Test file for the genCSV helper
+ * @author Gabe Abrams
+ */
+
+// Import main helper
+import genCSV from './genCSV';
+
+describe('genCSV', () => {
+  it('should return an empty string for empty data', () => {
+    const result = genCSV([], []);
+    expect(result).toEqual('');
+  });
+
+  it('should generate a CSV with the correct headers and data', () => {
+    const columns = [
+      { title: 'Name', param: 'name' },
+      { title: 'Age', param: 'age' },
+      { title: 'Email', param: 'email' },
+    ];
+    const data = [
+      { name: 'Alice', age: 25, email: 'alice@example.com' },
+      { name: 'Bob', age: 30, email: 'bob@example.com' },
+      { name: 'Charlie', age: 35, email: 'charlie@example.com' },
+    ];
+    const expected = `Name,Age,Email\nAlice,25,alice@example.com\nBob,30,bob@example.com\nCharlie,35,charlie@example.com`;
+    const result = genCSV(data, columns);
+    expect(result).toEqual(expected);
+  });
+
+  it('should handle undefined and null values correctly', () => {
+    const columns = [
+      { title: 'Name', param: 'name' },
+      { title: 'Age', param: 'age' },
+      { title: 'Email', param: 'email' },
+    ];
+    const data = [
+      { name: 'Alice', age: undefined, email: null },
+      { name: 'Bob', age: null, email: 'bob@example.com' },
+      { name: 'Charlie', age: 35, email: undefined },
+    ];
+    const expected = `Name,Age,Email\nAlice,,\nBob,,bob@example.com\nCharlie,35,`;
+    const result = genCSV(data, columns);
+    expect(result).toEqual(expected);
+  });
+
+  it('should handle objects in cells correctly', () => {
+    const columns = [
+      { title: 'Name', param: 'name' },
+      { title: 'Data', param: 'data' },
+    ];
+    const data = [
+      { name: 'Alice', data: { foo: 'bar' } },
+      { name: 'Bob', data: [1, 2, 3] },
+      { name: 'Charlie', data: null },
+    ];
+    const expected = `Name,Data\nAlice,"{""foo"":""bar""}"\nBob,"[1,2,3]"\nCharlie,`;
+    const result = genCSV(data, columns);
+    expect(result).toEqual(expected);
+  });
+});

package/src/helpers/genCSV.ts

@@ -5,13 +5,16 @@
  * @returns escaped cell text
  */
 const escapeCellText = (text: string): string => {
-  if (!String(text).includes(',')) {
+  if (
+    !String(text).includes(',')
+    && !String(text).includes('"')
+  ) {
     // No need to escape
     return String(text);
   }
 
   // Perform escape
-  return `"${String(text).replace(/"/g, '""')}`;
+  return `"${String(text).replace(/"/g, '""')}"`;
 };
 
 /**

package/src/helpers/genCommaList.test.ts

@@ -0,0 +1,57 @@
+// Import function
+import genCommaList from './genCommaList';
+
+test(
+  'Empty list.',
+  async () => {
+    const emptyList: string[] = [];
+    const emptyListResponse: string = '';
+
+    const result = genCommaList(emptyList);
+    expect(result).toStrictEqual(emptyListResponse);
+  },
+);
+
+test(
+  'One word list.',
+  async () => {
+    const oneList: string[] = ['apples'];
+    const oneListResponse: string = 'apples';
+
+    const result = genCommaList(oneList);
+    expect(result).toStrictEqual(oneListResponse);
+  },
+);
+
+test(
+  'Two word list.',
+  async () => {
+    const twoList: string[] = ['apples', 'oranges'];
+    const twoListResponse: string = 'apples and oranges';
+
+    const result = genCommaList(twoList);
+    expect(result).toStrictEqual(twoListResponse);
+  },
+);
+
+test(
+  'Three word list.',
+  async () => {
+    const threeList: string[] = ['apples', 'oranges', 'bananas'];
+    const threeListResponse: string = 'apples, oranges, and bananas';
+
+    const result = genCommaList(threeList);
+    expect(result).toStrictEqual(threeListResponse);
+  },
+);
+
+test(
+  'Four word list.',
+  async () => {
+    const fourList: string[] = ['apples', 'oranges', 'bananas', 'grapes'];
+    const fourListResponse: string = 'apples, oranges, bananas, and grapes';
+
+    const result = genCommaList(fourList);
+    expect(result).toStrictEqual(fourListResponse);
+  },
+);

package/src/helpers/genCommaList.ts

@@ -0,0 +1,21 @@
+/**
+ * Given an array of strings, create a single comma-separated string that includes
+ * 'and' as well as an oxford comma.
+ *   Ex: ['apples'] => 'apples'
+ *   Ex: ['apples', 'bananas'] => 'apples and bananas'
+ *   Ex: ['apples', 'bananas', 'grapes'] => 'apples, bananas, and grapes'
+ * @author Austen Money
+ * @param list an array of elements to be made into a single comma-separated string.
+ * @returns a comma-separated string.
+ */
+const genCommaList = (list: string[]): string => {
+  const { length } = list;
+
+  return (
+    length < 2
+      ? list.join('')
+      : `${list.slice(0, length - 1).join(', ')}${length < 3 ? ' and ' : ', and '}${list[length - 1]}`
+  );
+};
+
+export default genCommaList;

package/src/helpers/getHumanReadableDate.test.ts

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

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

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

@@ -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 = true;
+    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 = true;
+    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;