dce-reactkit 4.3.4 → 5.0.0

package/src/helpers/prefixWithAOrAn.ts

@@ -1,29 +0,0 @@
-// Constants
-const VOWELS = ['a', 'e', 'i', 'o', 'u'];
-
-/**
- * Prefix a word or name with "a" or "an" depending on whether it starts with a
- *   vowel or not
- * @author Gabe Abrams
- * @param text the text to prefix
- * @param capitalize whether to capitalize the "A" or "An"
- * @returns the text prefixed with "a" or "an"
- */
-const prefixWithAOrAn = (text: string, capitalize = false): string => {
-  // Get the first letter
-  const firstLetter = text.charAt(0).toLowerCase();
-
-  // Check if starts with vowel
-  const startsWithVowel = VOWELS.includes(firstLetter);
-
-  // Determine prefix
-  let prefix = startsWithVowel ? 'an' : 'a';
-  if (capitalize) {
-    prefix = prefix.charAt(0).toUpperCase() + prefix.substring(1);
-  }
-
-  // Return the text prefixed with "a" or "an"
-  return `${prefix} ${text}`;
-};
-
-export default prefixWithAOrAn;

package/src/helpers/roundToNumDecimals.tsx

@@ -1,13 +0,0 @@
-/**
- * Round a number to a certain number of decimals
- * @author Gabe Abrams
- * @param num the number to round
- * @param numDecimals the number of decimals to round to
- * @returns rounded number
- */
-const roundToNumDecimals = (num: number, numDecimals: number): number => {
-  const rounder = 10 ** numDecimals;
-  return (Math.round(num * rounder) / rounder);
-};
-
-export default roundToNumDecimals;

package/src/helpers/shuffleArray.ts

@@ -1,19 +0,0 @@
-/**
- * Shuffle a given array
- * @author Austen Money
- * @param arr the array to shuffle
- * @returns the shuffled array
- */
-const shuffleArray = <T>(arr: T[]): T[] => {
-  const newArr = [...arr];
-
-  // Shuffle using Durstenfeld algorithm
-  for (let i = arr.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
-    [newArr[i], newArr[j]] = [newArr[j], newArr[i]];
-  }
-
-  return newArr;
-};
-
-export default shuffleArray;

package/src/helpers/startMinWait.ts

@@ -1,33 +0,0 @@
-// Import other helpers
-import waitMs from './waitMs';
-
-/**
- * Start a dynamic wait, call the function once the operation has completed and
- *   the dynamic wait will continue waiting for the rest of the minimum time
- * @author Gabe Abrams
- * @param minWaitMs the minimum number of ms to wait
- * @returns async function to call to finish the wait
- */
-const startMinWait = (minWaitMs: number): () => Promise<void> => {
-  const startTimestamp = Date.now();
-
-  /**
-   * Finish the remaining time to wait
-   * @author Gabe Abrams
-   */
-  return async () => {
-    const endTimestamp = Date.now();
-
-    // Calculate remaining time to wait
-    const elapsedTimeMs = (endTimestamp - startTimestamp);
-    const remainingTimeToWaitMs = minWaitMs - elapsedTimeMs;
-    if (remainingTimeToWaitMs <= 0) {
-      return;
-    }
-
-    // Perform wait
-    await waitMs(remainingTimeToWaitMs);
-  };
-};
-
-export default startMinWait;

package/src/helpers/stringsToHumanReadableList.ts

@@ -1,39 +0,0 @@
-/**
- * Create a human readable list from an array of strings.
- *   For example, ['apple', 'orange'] becomes "apple and orange"
- *   and ['apple', 'orange', 'mango'] becomes "apple, orange, and mango"
- * @author Gabe Abrams
- * @param items list of items in the list
- * @returns human-readable list
- */
-const stringsToHumanReadableList = (items: string[]): string => {
-  // Handle 0-item case
-  if (items.length === 0) {
-    return '';
-  }
-
-  // Handle 1-item case
-  if (items.length === 1) {
-    return items[0];
-  }
-
-  // Handle 2-item case
-  if (items.length === 2) {
-    return `${items[0]} and ${items[1]}`;
-  }
-
-  // Handle 3+ item case
-  let list = '';
-  items.forEach((item, i) => {
-    if (i === items.length - 1) {
-      // Last item
-      list += `, and ${item}`;
-    }
-
-    // Previous items
-    list += `, ${item}`;
-  });
-  return list;
-};
-
-export default stringsToHumanReadableList;

package/src/helpers/sum.tsx

@@ -1,16 +0,0 @@
-/**
- * Sum the numbers in an array
- * @author Gabe Abrams
- * @param nums the numbers to sum
- * @returns the sum of the numbers
- */
-const sum = (nums: number[]): number => {
-  return nums.reduce(
-    (a: number, b: number) => {
-      return (a + b);
-    },
-    0,
-  );
-};
-
-export default sum;

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

@@ -1,85 +0,0 @@
-// Importing the testing function
-// import chicagoTitleCase from './chicagoTitleCase';
-
-// // Import constants
-// import { INVALID_STRING_ERRORS, INVALID_REGEX_ERROR } from './shared/constants/ERROR_MESSAGES';
-
-// /*------------------------------------------------------------------------*/
-// /* ---------------------------- Valid Tests --------------------------- */
-// /*------------------------------------------------------------------------*/
-
-// const validTests: { input: string, expected: string }[] = [
-//   {
-//     input: 'this is the american language',
-//     expected: 'This the American language',
-//   },
-//   {
-//     input: 'to kill a mockingbird',
-//     expected: 'To Kill a Mockingbird',
-//   },
-//   {
-//     input: 'the lord of the rings',
-//     expected: 'The Lord of the Rings',
-//   },
-//   {
-//     input: 'pride and prejudice',
-//     expected: 'Pride and Prejudice',
-//   },
-//   {
-//     input: 'the road not taken',
-//     expected: 'The Road Not Taken',
-//   },
-// ];
-
-// test(
-//   'Converts strings to Chicago title case correctly.',
-//   async () => {
-//     validTests.forEach(({ input, expected }) => {
-//       expect(chicagoTitleCase(input)).toBe(expected);
-//     });
-//   },
-// );
-
-// /*------------------------------------------------------------------------*/
-// /* ---------------------------- Edge Cases ---------------------------- */
-// /*------------------------------------------------------------------------*/
-
-// const edgeCases: { input: string, expected: string }[] = [
-//   {
-//     input: 'x',
-//     expected: 'X',
-//   },
-//   {
-//     input: ' ',
-//     expected: ' ',
-//   },
-//   {
-//     input: '',
-//     expected: '',
-//   },
-//   {
-//     input: 'the',
-//     expected: 'The',
-//   },
-//   {
-//     input: 'THE ROAD NOT TAKEN',
-//     expected: 'The Road Not Taken',
-//   },
-//   {
-//     input: 'tO kiLL A mOckingBirD',
-//     expected: 'To Kill a Mockingbird',
-//   },
-//   {
-//     input: 'pRiDe And pReduJiCe',
-//     expected: 'Pride and Prejudice',
-//   },
-// ];
-
-// test(
-//   'Handles the edge cases for the function that converts a string to Chicago Title Case.',
-//   async () => {
-//     edgeCases.forEach(({ input, expected }) => {
-//       expect(chicagoTitleCase(input)).toBe(expected);
-//     });
-//   },
-// );

package/src/helpers/validators/ChicagoTitleCase.ts

@@ -1,32 +0,0 @@
-/**
- * This function converts a string to title case based on Chicago Title Case 
- * Style rules.
- * @author Leisha Bhandari
- * @param input: The input string that needs to be converted to Chicago title
- *               case.
- * @returns Input string converted to title case
- */
-
-
-const chicagoTitleCase = (input: string): string => {
-   // List of lowercase words according to Chicago Manual of Style
-  const lowerCaseWords: string[] = [
-    'in', 'nor', 'of', 'on', 'or', 'as', 'at', 'but', 'by',
-    'for', 'if', 'so', 'the', 'a', 'an', 'and', 'to', 'up',
-    'yet'
-  ];
-
-  return input
-    // Converts given input string to lowercase
-    .toLowerCase() 
-    // Splits the given string into separate words
-    .split(' ') 
-    .map((word, index, words) => 
-      // Capitalize the first word, last word, and the words that aren't
-      // in lowerCaseWords
-      index === 0 || !lowerCaseWords.includes(word) || index === words.length - 1
-        ? `${word.charAt(0).toUpperCase()}${word.slice(1)}` // Capitalize the first letter
-        : word // Nothing happens to the word
-    )
-    .join(' '); // Joins the words back 
-};

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

@@ -1,83 +0,0 @@
-// Import the function to be tested
-// import findURLs from './findURL';
-
-// // Import constants
-// import { INVALID_STRING_ERRORS, INVALID_REGEX_ERROR } from './shared/constants/ERROR_MESSAGES';
-
-// /*------------------------------------------------------------------------*/
-// /* ---------------------------- Valid Tests --------------------------- */
-// /*------------------------------------------------------------------------*/
-
-// const validTests: { block: string, expected: { start: number, end: number }[] }[] = [
-//   {
-//     block: 'Visit http://example.com for more information.',
-//     expected: [{ start: 6, end: 23 }],
-//   },
-//   {
-//     block: 'Multiple URLs: http://one.com and http://two.com.',
-//     expected: [
-//       { start: 15, end: 29 },
-//       { start: 34, end: 48 },
-//     ],
-//   },
-//   {
-//     block: 'Localhost URLs: http://localhost and http://127.0.0.1.',
-//     expected: [
-//       { start: 16, end: 31 },
-//       { start: 36, end: 52 },
-//     ],
-//   },
-//   {
-//     block: 'Embedded URL: text https://embedded-url.com?query=1&value=2.',
-//     expected: [{ start: 13, end: 51 }],
-//   },
-//   {
-//     block: 'Secure site: https://secure-site.com/path?query=string#fragment',
-//     expected: [{ start: 13, end: 58 }],
-//   },
-// ];
-
-// test(
-//   'Returns correct start and end indices for valid URLs within a string.',
-//   async () => {
-//     validTests.forEach(({ block, expected }) => {
-//       expect(findURLs(block)).toStrictEqual(expected);
-//     });
-//   },
-// );
-
-// /*------------------------------------------------------------------------*/
-// /* ---------------------------- Invalid Tests --------------------------- */
-// /*------------------------------------------------------------------------*/
-
-// const invalidTests: { block: string, expected: { start: number, end: number }[] }[] = [
-//   {
-//     block: 'No URL.',
-//     expected: [],
-//   },
-//   {
-//     block: 'URL format is wrong: http:/example.com and htt://example.com.',
-//     expected: [],
-//   },
-//   {
-//     block: 'Any punctuation after the URL http://example.com, should not count.',
-//     expected: [{ start: 20, end: 37 }],
-//   },
-//   {
-//     block: 'Starting punctuation ,http://example.com should not count.',
-//     expected: [{ start: 22, end: 39 }],
-//   },
-//   {
-//     block: 'Spaces in the middle http://exa mple.com is invalid.',
-//     expected: [],
-//   },
-// ];
-
-// test(
-//   'Returns empty array for strings without valid URLs.',
-//   async () => {
-//     invalidTests.forEach(({ block, expected }) => {
-//       expect(findURLs(block)).toStrictEqual(expected);
-//     });
-//   },
-// );

package/src/helpers/validators/findURL.ts

@@ -1,43 +0,0 @@
-// /**
-//  * This function finds URLs within a given string and returns an array of 
-//  * their locations.
-//  * @author Leisha Bhandari
-//  * @param block: The block of text to search for URLs
-//  * @returns Arrays where each of them contain the start and end index of the URL
-//  */
-// function findURLs(block: string): { start: number, end: number }[] {
-//   // Expression representing the skeleton of a URL to help match and find the  
-//   // URLs within the block of text (Also takes care of Unicode characters)
-//   const urlSkeleton = /(https?:\/\/[^\s\u0000-\u001F.,]+[^\s\u0000-\u001F.,]?(?:\?[^\s\u0000-\u001F]+)?(?:#[^\s\u0000-\u001F]+)?)/g;
-//   const found: { start: number, end: number }[] = [];
-//   let match: RegExpExecArray | null;
-
-//   // While loop to find the URLs in the given block of texts using the URL 
-//   // skeleton
-//   while ((match === urlSkeleton.exec(block)) 
-//          && match !== null) {
-//     // To find the beginning index of the URL
-//     let start = match.index;
-//     // To find the last index of the URL
-//     let end = match.index + match[0].length;
-
-//     // If statements to check whether the URL is followed by some kind of 
-//     // punctuation mark
-//     if (block.charAt(end) === '.' || /[,;:!?"]/.test(block.charAt(end))) {
-//       end--;
-//     }
-
-//     // While statement to make sure that the URL does not start with a 
-//     // punctuation mark
-//     while (start > 0 && /[.,:;!?]/.test(block.charAt(start - 1))) {
-//       start--;
-//     }
-
-//     // The object with start and end index of the URL is found and pushed to 
-//     // the found array
-//     found.push({ start, end });
-//   }
-  
-//   // Returns the array of the found URLs location
-//   return found;
-// }

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/validURL.test.ts

@@ -1,90 +0,0 @@
-
-// Import the function to be tested
-// import isValid from './validURL';
-
-// // Import constants
-// import { INVALID_STRING_ERRORS, INVALID_REGEX_ERROR } from './shared/constants/ERROR_MESSAGES';
-
-// /*------------------------------------------------------------------------*/
-// /* ---------------------------- Valid Tests --------------------------- */
-// /*------------------------------------------------------------------------*/
-
-// const validUrls: string[] = [
-//   'http://example.com',
-//   'https://example.com',
-//   'http://www.example.com',
-//   'https://www.example.com',
-//   'https://example.com/path',
-//   'http://example.com/path',
-//   'https://example.com?query=string',
-//   'http://example.com?query=string',
-//   'https://example.com#fragment',
-//   'http://example.com#fragment',
-//   'http://localhost',
-//   'https://localhost:3000',
-//   'http://localhost:3000',
-//   'http://127.0.0.1',
-//   'http://127.0.0.1:3000',
-//   'ftp://example.com/path',
-//   'ftp://example.com',
-//   'https://127.0.0.1:3000',
-//   'file:///C:/path/to/file'
-// ];
-
-// test(
-//   'Returns true for a given valid URL.',
-//   async () => {
-//     validUrls.forEach((url) => {
-//       expect(isValid(url)).toBe(true);
-//     });
-//   },
-// );
-
-// /*------------------------------------------------------------------------*/
-// /* ---------------------------- Invalid Tests --------------------------- */
-// /*------------------------------------------------------------------------*/
-
-// const invalidUrls: string[] = [
-//   '',
-//   ' ',
-//   'example',
-//   'http://',
-//   'http://.',
-//   'http://..',
-//   'http://##/',
-//   'http://../',
-//   'http://??/',
-//   'http://#',
-//   'http://##',
-//   '//',
-//   '//a',
-//   '///a',
-//   '///',
-//   'http:///a',
-//   'http://www.foo.bar./',
-//   'http://foo.bar/foo(bar)baz quux',
-//   'http://3628126748',
-//   'http://.www.foo.bar/',
-//   'http://.www.foo.bar./',
-//   'http://123.123.123',
-//   'http://1.1.1.1.1',
-//   'http://example.com:99999',
-//   'http://example.com:80:80',
-//   'http://example.com::80',
-//   'http://example.com:-80',
-//   'http://-example.com',
-//   'http://example.com-',
-//   'http://example.com_',
-//   'http://example..com',
-//   'http://example.com.',
-//   'http://.example.com'
-// ];
-
-// test(
-//   'Returns false for a given invalid URL.',
-//   async () => {
-//     invalidUrls.forEach((url) => {
-//       expect(isValid(url)).toBe(false);
-//     });
-//   },
-// );

package/src/helpers/validators/validURL.ts

@@ -1,18 +0,0 @@
-/**
- * This function checks if a given input string is a valid URL.
- * @author Leisha Bhandari
- * @param URL: The input string that needs checked as a URL or not.
- * @returns A true boolean value if the input string is a valid URL, and a false
- *          boolean value if the input string is a invalid URL
- */
-function isValid(url: string): boolean {
-  // Uses the input URL to create a URL object
-  try {
-    new URL(url);
-    // URL constructor does not throw an error, so input URL is valid
-    return true;
-  } catch (err) {
-    // URL constructor throws an error, so input URL is invalid
-    return false;
-  }
-}