dce-reactkit 4.3.4 → 5.0.0-beta-progress-size-3

package/src/helpers/getTimestampFromTimeInfoInET.ts

@@ -1,179 +0,0 @@
-// Import shared types
-import ErrorWithCode from '../errors/ErrorWithCode';
-import ReactKitErrorCode from '../types/ReactKitErrorCode';
-
-// Import shared helpers
-import getTimeInfoInET from './getTimeInfoInET';
-import padZerosLeft from './padZerosLeft';
-
-/*----------------------------------------*/
-/* --------------- Helpers -------------- */
-/*----------------------------------------*/
-
-/**
- * Check if a timestamp is valid
- * @author Gabe Abrams
- * @author Gardenia Liu
- * @param opts object containing all arguments
- * @param opts.timestamp Timestamp in milliseconds since epoch
- * @param opts.expectedYear Expected year
- * @param opts.expectedMonth Expected month
- * @param opts.expectedDay Expected day
- * @param opts.expectedHour Expected hour
- * @param opts.expectedMinute Expected minute
- * @returns 1 if the timestamp needs to be increased, -1 if it needs to be decreased, 0 if it is valid
- */
-const checkTimestamp = (
-  opts: {
-    timestamp: number,
-    expectedYear: number,
-    expectedMonth: number,
-    expectedDay: number,
-    expectedHour: number,
-    expectedMinute: number,
-  },
-): number => {
-  const {
-    timestamp,
-    expectedYear,
-    expectedMonth,
-    expectedDay,
-    expectedHour,
-    expectedMinute,
-  } = opts;
-
-  const timeInfoInET = getTimeInfoInET(timestamp);
-  if (timeInfoInET.year < expectedYear) {
-    return 1;
-  }
-  if (timeInfoInET.year > expectedYear) {
-    return -1;
-  }
-  if (timeInfoInET.month < expectedMonth) {
-    return 1;
-  }
-  if (timeInfoInET.month > expectedMonth) {
-    return -1;
-  }
-  if (timeInfoInET.day < expectedDay) {
-    return 1;
-  }
-  if (timeInfoInET.day > expectedDay) {
-    return -1;
-  }
-  if (timeInfoInET.hour < expectedHour) {
-    return 1;
-  }
-  if (timeInfoInET.hour > expectedHour) {
-    return -1;
-  }
-  if (timeInfoInET.minute < expectedMinute) {
-    return 1;
-  }
-  if (timeInfoInET.minute > expectedMinute) {
-    return -1;
-  }
-  return 0;
-};
-
-/*----------------------------------------*/
-/* ---------------- Main ---------------- */
-/*----------------------------------------*/
-
-/**
- * Get a timestamp (ms since epoch) from time info (year, month, day, hour, minute, etc.) in Eastern Time (ET)
- * @author Gardenia Liu
- * @author Gabe Abrams
- * @param opts object containing all arguments
- * @param opts.year Year (e.g. 2023)
- * @param opts.month Month (1-12)
- * @param opts.day Day of the month (1-31)
- * @param opts.hour Hour (0-23)
- * @param opts.minute Minute (0-59)
- * @returns Timestamp in milliseconds since epoch
- */
-const getTimestampFromTimeInfoInET = (
-  opts: {
-    year: number,
-    month: number,
-    day: number,
-    hour: number,
-    minute: number,
-  },
-): number => {
-  // Destructure opts
-  const {
-    year,
-    month,
-    day,
-    hour,
-    minute,
-  } = opts;
-
-  // Determine if the date is in DST in Eastern Time
-  const tempDate = new Date(year, month - 1, day);
-  const janOffset = new Date(year, 0, 1).getTimezoneOffset();
-  const isDST = tempDate.getTimezoneOffset() < janOffset;
-  const etOffset = isDST ? '-04:00' : '-05:00';
-
-  // Format with leading zeroes
-  const mm = padZerosLeft(month, 2);
-  const dd = padZerosLeft(day, 2);
-  const hh = padZerosLeft(hour, 2);
-  const min = padZerosLeft(minute, 2);
-
-  // Build ET ISO string and convert to UTC timestamp
-  const etISOString = `${year}-${mm}-${dd}T${hh}:${min}:00${etOffset}`;
-  const baseTimestamp = (new Date(etISOString)).getTime();
-  let timestamp = baseTimestamp;
-
-  // Heat seek to get the right timestamp
-  const maxOffset = 24 * 60; // 24 hours in minutes
-  let currentOffset = 0; // minutes
-  const offsetIncrement = 15; // minutes
-  const offsetDirection = checkTimestamp({
-    timestamp,
-    expectedYear: year,
-    expectedMonth: month,
-    expectedDay: day,
-    expectedHour: hour,
-    expectedMinute: minute,
-  });
-  if (offsetDirection === 0) {
-    // Valid! Return the timestamp
-    return timestamp;
-  }
-
-  // Heat seek
-  while (Math.abs(currentOffset) < maxOffset) {
-    // Update offset
-    currentOffset += (offsetDirection * offsetIncrement);
-
-    // Update timestamp
-    const offsetMs = currentOffset * 60 * 1000;
-    timestamp = baseTimestamp + offsetMs;
-
-    // Check timestamp again
-    const newDirection = checkTimestamp({
-      timestamp,
-      expectedYear: year,
-      expectedMonth: month,
-      expectedDay: day,
-      expectedHour: hour,
-      expectedMinute: minute,
-    });
-    if (newDirection === 0) {
-      // Valid! Return the timestamp
-      return timestamp;
-    }
-
-    // Invalid. Keep looping.
-  }
-
-  throw new ErrorWithCode(
-    `Timestamp mismatch: expected ${year}-${mm}-${dd} ${hh}:${min}, seeked to offset ${currentOffset} minutes but could not find a valid timestamp.`,
-    ReactKitErrorCode.ETTimestampInvalid,
-  );
-};
-
-export default getTimestampFromTimeInfoInET;

package/src/helpers/getWordCount.ts

@@ -1,26 +0,0 @@
-const punctuationRegex = /[!@#$%^&*(),.?\/;:'"\-\[\]]/g;
-
-/**
- * Get number of words in string 
- * @author Gardenia Liu
- * @author Allison Zhang
- * @author Gabe Abrams
- * @param text the string to check
- * @returns number of words in the string
- */
-const getWordCount = (text: string): number => {
-  const trimmedTextWithoutPunctuation = (
-    text
-      // Remove leading and trailing whitespace
-      .trim()
-      // Remove punctuation
-      .replace(punctuationRegex, '')
-  );
-  if (trimmedTextWithoutPunctuation.length === 0) {
-    return 0;
-  }
-
-  return trimmedTextWithoutPunctuation.split(/\s+/g).length;
-};
-
-export default getWordCount;

package/src/helpers/idify.ts

@@ -1,24 +0,0 @@
-/**
- * Convert a string to hyphenated lowercase format with no space or
- *   non-alphanumeric characters
- * @author Gabe Abrams
- * @param str the string to convert
- * @returns the idified string
- */
-const idify = (str: string): string => {
-  return (
-    str
-      // Trim whitespace
-      .trim()
-      // Convert to lowercase
-      .toLowerCase()
-      // Replace non-alphanumeric characters with hyphens
-      .replace(/[^a-z0-9]+/g, '-')
-      // Change multiple hyphens in a row for a single hyphen
-      .replace(/-+/g, '-')
-      // Remove hyphens at the beginning and end of the string
-      .replace(/^-+|-+$/g, '')
-  );
-};
-
-export default idify;

package/src/helpers/onlyKeepLetters.ts

@@ -1,11 +0,0 @@
-/**
- * Given a string, only keep the letters inside it
- * @author Gabe Abrams
- * @param str the string to parse
- * @returns only the letters inside of the string
- */
-const onlyKeepLetters = (str: string): string => {
-  return str.replace(/[^a-zA-Z]+/g, '');
-};
-
-export default onlyKeepLetters;

package/src/helpers/padDecimalZeros.tsx

@@ -1,32 +0,0 @@
-/**
- * Pad a number's decimal with zeros on the right
- *   (e.g. 5.2 becomes 5.20 with 2 digit padding)
- * @author Gabe Abrams
- * @param num the number to pad
- * @param numDigits the minimum number of digits after the decimal
- * @returns padded number
- */
-const padDecimalZeros = (num: number, numDigits: number): string => {
-  // Skip if nothing to do
-  if (numDigits < 1) {
-    return String(num);
-  }
-
-  // Convert to string
-  let out = String(num);
-
-  // Add a decimal point if there isn't one
-  if (!out.includes('.')) {
-    out += '.';
-  }
-
-  // Add zeros
-  while (out.split('.')[1].length < numDigits) {
-    out = `${out}0`;
-  }
-
-  // Return
-  return out;
-};
-
-export default padDecimalZeros;

package/src/helpers/padZerosLeft.tsx

@@ -1,21 +0,0 @@
-/**
- * Pad a number with zeros on the left (e.g. 5 becomes 05 with 2 digit padding)
- * @author Gabe Abrams
- * @param num the number to pad
- * @param numDigits the minimum number of digits before the decimal
- * @returns padded number
- */
-const padZerosLeft = (num: number, numDigits: number): string => {
-  // Convert to string
-  let out = String(num);
-
-  // Add zeros
-  while (out.split('.')[0].length < numDigits) {
-    out = `0${out}`;
-  }
-
-  // Return
-  return out;
-};
-
-export default padZerosLeft;

package/src/helpers/parallelLimit.ts

@@ -1,63 +0,0 @@
-/**
- * Run tasks in parallel with a limit on how many tasks can execute at once.
- *   No guarantees are made about the order of task execution
- * @author Gabe Abrams
- * @param taskFunctions functions that start asynchronous tasks and optionally
- *   resolve with values
- * @param [limit=no limit] maximum number of asynchronous tasks to permit to run at
- *   once
- * @returns array of resolved values in the same order as the task functions
- */
-const parallelLimit = async (
-  taskFunctions: (() => Promise<any>)[],
-  limit?: number,
-): Promise<any[]> => {
-  const results: any[] = [];
-
-  // Wait until finished with all tasks
-  await new Promise<void>((resolve) => {
-    /* ------------- Helpers ------------ */
-
-    let nextTaskIndex = 0;
-    let numFinishedTasks = 0;
-    /**
-     * Start the next task
-     * @author Gabe Abrams
-     */
-    const startTask = async () => {
-      const taskIndex = nextTaskIndex++;
-
-      // Get the task
-      const taskFunction = taskFunctions[taskIndex];
-      if (!taskFunction) {
-        return;
-      }
-
-      // Execute task
-      const result = await taskFunction();
-
-      // Add results
-      results[taskIndex] = result;
-
-      // Tally and finish
-      if (++numFinishedTasks === taskFunctions.length) {
-        return resolve();
-      }
-
-      // Not finished! Start another task
-      startTask();
-    };
-
-    /* ----------- Start Tasks ---------- */
-    
-    // If no limit, start all tasks. At least start 1 task
-    const numTasks = Math.max((limit || taskFunctions.length), 1);
-    for (let i = 0; i < numTasks; i++) {
-      startTask();
-    }
-  });
-
-  return results;
-};
-
-export default parallelLimit;

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 
-};