dce-reactkit 4.3.4 → 5.0.0

package/src/helpers/asyncArrayFunctions/forEachAsync.ts

@@ -1,40 +0,0 @@
-/**
- * Run the operator function on each item in the array
- * @author Gabe Abrams
- * @param operatorFunction the operator function to apply
- */
-const forEachAsync = async <T>(
-  array: T[],
-  operatorFunction: (
-    item: T,
-    index: number,
-    opts: {
-      breakNow: () => void,
-      array: Array<T>,
-    },
-  ) => void,
-) => {
-  // Create break logic
-  let done = false;
-  /**
-   * Break the loop
-   * @author Gabe Abrams
-   */
-  const breakNow = () => {
-    done = true;
-  };
-
-  // Loop through each item
-  for (let i = 0; i < array.length && !done; i++) {
-    await operatorFunction(
-      array[i],
-      i,
-      {
-        breakNow,
-        array,
-      },
-    );
-  }
-};
-
-export default forEachAsync;

package/src/helpers/asyncArrayFunctions/mapAsync.test.ts

@@ -1,125 +0,0 @@
-import waitMs from '../waitMs';
-import mapAsync from './mapAsync';
-
-describe('mapAsync', () => {
-  it('should return an empty array when given an empty array', async () => {
-    const result = await mapAsync([], async () => {
-      // Operator function logic goes here
-    });
-
-    expect(result).toEqual([]);
-  });
-
-  it('should apply the operator function to each item in the array', async () => {
-    const array = [1, 2, 3];
-    const operatorFunction = jest.fn();
-
-    await mapAsync(array, operatorFunction);
-
-    expect(operatorFunction).toHaveBeenCalledTimes(3);
-    expect(operatorFunction).toHaveBeenCalledWith(1, 0, expect.any(Object));
-    expect(operatorFunction).toHaveBeenCalledWith(2, 1, expect.any(Object));
-    expect(operatorFunction).toHaveBeenCalledWith(3, 2, expect.any(Object));
-  });
-
-  it('should collect and return the results of the operator function', async () => {
-    const array = [1, 2, 3];
-    const operatorFunction = async (item: number) => {
-      return item * 2;
-    };
-
-    const result = await mapAsync(array, operatorFunction);
-
-    expect(result).toEqual([2, 4, 6]);
-  });
-
-  it('should pass the correct index to the operator function', async () => {
-    const array = [1, 2, 3];
-    const operatorFunction = jest.fn();
-
-    await mapAsync(array, operatorFunction);
-
-    expect(operatorFunction).toHaveBeenCalledWith(expect.anything(), 0, expect.any(Object));
-    expect(operatorFunction).toHaveBeenCalledWith(expect.anything(), 1, expect.any(Object));
-    expect(operatorFunction).toHaveBeenCalledWith(expect.anything(), 2, expect.any(Object));
-  });
-
-  it('should pass the correct options object to the operator function', async () => {
-    const array = [1, 2, 3];
-    const operatorFunction = jest.fn();
-
-    await mapAsync(array, operatorFunction);
-
-    expect(operatorFunction).toHaveBeenCalledWith(expect.anything(), expect.anything(), {
-      breakNow: expect.any(Function),
-      array: expect.any(Array),
-    });
-  });
-
-  it('should allow the operator function to break the loop', async () => {
-    const array = [1, 2, 3];
-
-    const result = await mapAsync(
-      array,
-      async (
-        item,
-        index,
-        { breakNow },
-      ) => {
-        if (item === 2) {
-          breakNow();
-        }
-        return item;
-      },
-    );
-
-    expect(result).toEqual([1]);
-  });
-
-  it('should handle asynchronous operator function', async () => {
-    const array = [1, 2, 3];
-    const result = await mapAsync(
-      array,
-      async (item) => {
-        await waitMs(1000);
-        return item * 2;
-      },
-    );
-
-    expect(result).toEqual([2, 4, 6]);
-  });
-
-  it('should handle errors thrown by the operator function', async () => {
-    const array = [1, 2, 3];
-
-    await expect(
-      mapAsync(
-        array,
-        async (item) => {
-          if (item === 2) {
-            throw new Error('Error processing item');
-          }
-          return item * 2;
-        },
-      ),
-    ).rejects.toThrow('Error processing item');
-  });
-
-  it('should handle empty array with breakNow called', async () => {
-    const array: number[] = [];
-
-    const result = await mapAsync(
-      array,
-      async (
-        item,
-        index,
-        { breakNow },
-      ) => {
-        breakNow();
-        return item;
-      },
-    );
-
-    expect(result).toEqual([]);
-  });
-});

package/src/helpers/asyncArrayFunctions/mapAsync.ts

@@ -1,46 +0,0 @@
-/**
- * Run the operator function on each item in the array, collecting all results
- * @author Gabe Abrams
- * @param operatorFunction the operator function to apply
- * @returns the array of results
- */
-const mapAsync = async <T, U>(
-  array: T[],
-  operatorFunction: (
-    item: T,
-    index: number,
-    opts: {
-      breakNow: () => void,
-      array: Array<T>,
-    },
-  ) => Promise<U>,
-): Promise<U[]> => {
-  // Create break logic
-  let done = false;
-  /**
-   * Break the loop
-   * @author Gabe Abrams
-   */
-  const breakNow = () => {
-    done = true;
-  };
-
-  // Loop through each item, collecting results
-  const results: U[] = [];
-  for (let i = 0; i < array.length && !done; i++) {
-    const result = await operatorFunction(
-      array[i],
-      i,
-      {
-        breakNow,
-        array,
-      },
-    );
-    results.push(result);
-  }
-
-  // Return results
-  return results;
-};
-
-export default mapAsync;

package/src/helpers/asyncArrayFunctions/someAsync.test.ts

@@ -1,92 +0,0 @@
-import waitMs from '../waitMs';
-import someAsync from './someAsync';
-
-describe('someAsync', () => {
-  it('should return false if the array is empty', async () => {
-    const result = await someAsync([], () => {
-      return Promise.resolve(true);
-    });
-    expect(result).toBe(false);
-  });
-
-  it('should return false if the operator function returns false for all items', async () => {
-    const array = [1, 2, 3, 4, 5];
-    const result = await someAsync(array, () => {
-      return Promise.resolve(false);
-    });
-    expect(result).toBe(false);
-  });
-
-  it('should return true if the operator function returns true for any item', async () => {
-    const array = [1, 2, 3, 4, 5];
-    const result = await someAsync(array, (item) => {
-      return Promise.resolve(item === 3);
-    });
-    expect(result).toBe(true);
-  });
-
-  it('should pass the correct index to the operator function', async () => {
-    const array = [1, 2, 3, 4, 5];
-    const result = await someAsync(array, (item, index) => {
-      expect(index).toBeGreaterThanOrEqual(0);
-      expect(index).toBeLessThan(array.length);
-      return Promise.resolve(false);
-    });
-    expect(result).toBe(false);
-  });
-
-  it('should pass the correct array to the operator function', async () => {
-    const array = [1, 2, 3, 4, 5];
-    const result = await someAsync(array, (item, index, { array: arr }) => {
-      expect(arr).toBe(array);
-      return Promise.resolve(false);
-    });
-    expect(result).toBe(false);
-  });
-
-  it('should stop iterating and return true if the operator function returns true for an item and breakNow is called', async () => {
-    const array = [1, 2, 3, 4, 5];
-    const result = await someAsync(array, (item, index, { breakNow }) => {
-      if (item === 3) {
-        breakNow();
-        return Promise.resolve(true);
-      }
-      return Promise.resolve(false);
-    });
-    expect(result).toBe(true);
-  });
-
-  it('should handle asynchronous operator function', async () => {
-    const array = [1, 2, 3, 4, 5];
-    const result = await someAsync(array, async (item) => {
-      await waitMs(100);
-      return Promise.resolve(item === 3);
-    });
-    expect(result).toBe(true);
-  });
-
-  it('should handle rejected promises from the operator function', async () => {
-    const array = [1, 2, 3, 4, 5];
-    const result = await someAsync(array, () => {
-      return Promise.reject(new Error('Test error'));
-    });
-    expect(result).toBe(false);
-  });
-
-  it('should handle thrown errors from the operator function', async () => {
-    const array = [1, 2, 3, 4, 5];
-    const result = await someAsync(array, () => {
-      throw new Error('Test error');
-    });
-    expect(result).toBe(false);
-  });
-
-  it('should handle empty array and asynchronous operator function', async () => {
-    const array: number[] = [];
-    const result = await someAsync(array, async () => {
-      await waitMs(100);
-      return Promise.resolve(false);
-    });
-    expect(result).toBe(false);
-  });
-});

package/src/helpers/asyncArrayFunctions/someAsync.ts

@@ -1,49 +0,0 @@
-/**
- * Run the operator function on each item in the array, returning true if
- *   the operator function returns true for any item in the array
- * @author Gabe Abrams
- * @param operatorFunction the operator function to apply. If it returns true
- *   for any item, this function will return true
- * @returns true if the operator function returns true for any item in the array
- */
-const someAsync = async <T>(
-  array: T[],
-  operatorFunction: (
-    item: T,
-    index: number,
-    opts: {
-      breakNow: () => void,
-      array: Array<T>,
-    },
-  ) => Promise<any>,
-): Promise<boolean> => {
-  // Create break logic
-  let done = false;
-  /**
-   * Break the loop (checking stops here)
-   * @author Gabe Abrams
-   */
-  const breakNow = () => {
-    done = true;
-  };
-
-  // Loop through each item, checking
-  for (let i = 0; i < array.length && !done; i++) {
-    const passed = await operatorFunction(
-      array[i],
-      i,
-      {
-        breakNow,
-        array,
-      },
-    );
-    if (passed && !done) {
-      return true;
-    }
-  }
-
-  // Return false because none returned true
-  return false;
-};
-
-export default someAsync;

package/src/helpers/avg.test.ts

@@ -1,24 +0,0 @@
-/**
- * Unit tests for avg helper
- * @author Gabe Abrams
- */
-
-import avg from './avg';
-
-describe('helpers > avg', () => {
-  it('should return 0 for an empty array', () => {
-    expect(avg([])).toEqual(0);
-  });
-
-  it('should return the correct average for an array of numbers', () => {
-    expect(avg([1, 2, 3, 4, 5])).toEqual(3);
-  });
-
-  it('should handle negative numbers', () => {
-    expect(avg([-1, 0, 1])).toEqual(0);
-  });
-
-  it('should handle decimal numbers', () => {
-    expect(avg([1.5, 2.5, 3.5])).toEqual(2.5);
-  });
-});

package/src/helpers/avg.ts

@@ -1,22 +0,0 @@
-import sum from './sum';
-
-/**
- * Get the average of a set of numbers
- * @author Gabe Abrams
- * @param nums the numbers to average
- * @returns average value or 0 if no numbers
- */
-const avg = (nums: number[]) => {
-  // Handle empty array case
-  if (nums.length === 0) {
-    return 0;
-  }
-
-  // Get the total value
-  const total = sum(nums);
-
-  // Get average
-  return (total / nums.length);
-};
-
-export default avg;

package/src/helpers/capitalize.ts

@@ -1,20 +0,0 @@
-/**
- * Capitalize every word in a string (just the first letter)
- * @param str string to capitalize
- * @returns string with every word capitalized
- */
-const capitalize = (str: string): string => {
-  return (
-    str
-      // Split into words
-      .split(' ')
-      // Capitalize first letter of each word
-      .map((word) => {
-        return word.charAt(0).toUpperCase() + word.substring(1);
-      })
-      // Join back together
-      .join(' ')
-  );
-};
-
-export default capitalize;

package/src/helpers/ceilToNumDecimals.test.ts

@@ -1,39 +0,0 @@
-/**
- * Test file for the ceilToNumDecimals helper
- * @author Gabe Abrams
- */
-
-// Import main function
-import ceilToNumDecimals from './ceilToNumDecimals';
-
-describe('ceilToNumDecimals', () => {
-  it('should return 0 for 0 with 0 decimals', () => {
-    const result = ceilToNumDecimals(0, 0);
-    expect(result).toEqual(0);
-  });
-
-  it('should return 1 for 1 with 0 decimals', () => {
-    const result = ceilToNumDecimals(1, 0);
-    expect(result).toEqual(1);
-  });
-
-  it('should return 1.24 for 1.234 with 2 decimals', () => {
-    const result = ceilToNumDecimals(1.234, 2);
-    expect(result).toEqual(1.24);
-  });
-
-  it('should return -1.23 for -1.234 with 2 decimals', () => {
-    const result = ceilToNumDecimals(-1.234, 2);
-    expect(result).toEqual(-1.23);
-  });
-
-  it('should return 1234 for 1234 with 0 decimals', () => {
-    const result = ceilToNumDecimals(1234, 0);
-    expect(result).toEqual(1234);
-  });
-
-  it('should return 0.002 for 0.00123 with 3 decimals', () => {
-    const result = ceilToNumDecimals(0.00123, 3);
-    expect(result).toEqual(0.002);
-  });
-});

package/src/helpers/ceilToNumDecimals.ts

@@ -1,13 +0,0 @@
-/**
- * Round a number (ceiling) 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 ceilToNumDecimals = (num: number, numDecimals: number): number => {
-  const rounder = 10 ** numDecimals;
-  return (Math.ceil(num * rounder) / rounder);
-};
-
-export default ceilToNumDecimals;

package/src/helpers/cloneDeep.ts

@@ -1,11 +0,0 @@
-import clone from 'nanoclone';
-
-/**
- * Deeply clones an object
- * @author Yuen Ler Chow
- * @param obj the object to clone
- * @returns a deep clone of the object
- */
-const cloneDeep: <T>(obj: T) => T = clone;
-
-export default cloneDeep;

package/src/helpers/compareArraysByProp.test.ts

@@ -1,147 +0,0 @@
-/**
- * Test file for the compareArraysByProp helper
- * @author Gabe Abrams
- */
-
-// Import main helper
-import compareArraysByProp from './compareArraysByProp';
-
-describe('compareArraysByProp', () => {
-  it('should return true for two empty arrays', () => {
-    const result = compareArraysByProp([], [], 'id');
-    expect(result).toEqual(true);
-  });
-
-  it('should return true for two arrays with the same objects in the same order', () => {
-    const a = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 3, name: 'Charlie' }];
-    const b = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 3, name: 'Charlie' }];
-    const result = compareArraysByProp(a, b, 'id');
-    expect(result).toEqual(true);
-  });
-
-  it('should return true for two arrays with the same objects in a different order', () => {
-    const a = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 3, name: 'Charlie' }];
-    const b = [{ id: 3, name: 'Charlie' }, { id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
-    const result = compareArraysByProp(a, b, 'id');
-    expect(result).toEqual(true);
-  });
-
-  it('should return false for two arrays with different objects', () => {
-    const a = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 3, name: 'Charlie' }];
-    const b = [{ id: 4, name: 'Dave' }, { id: 5, name: 'Eve' }, { id: 6, name: 'Frank' }];
-    const result = compareArraysByProp(a, b, 'id');
-    expect(result).toEqual(false);
-  });
-
-  it('should return false for two arrays with different objects and some shared objects', () => {
-    const a = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 3, name: 'Charlie' }];
-    const b = [{ id: 2, name: 'Bob' }, { id: 3, name: 'Charlie' }, { id: 4, name: 'Dave' }];
-    const result = compareArraysByProp(a, b, 'id');
-    expect(result).toEqual(false);
-  });
-
-  it('should return true for two arrays with the same objects with multiple properties', () => {
-    const a = [
-      { id: 1, name: 'Alice', age: 25 },
-      { id: 2, name: 'Bob', age: 30 },
-      { id: 3, name: 'Charlie', age: 35 },
-    ];
-    const b = [
-      { id: 1, name: 'Alice', age: 25 },
-      { id: 2, name: 'Bob', age: 30 },
-      { id: 3, name: 'Charlie', age: 35 },
-    ];
-    const result = compareArraysByProp(a, b, 'id');
-    expect(result).toEqual(true);
-  });
-
-  it('should return true for two arrays with the same objects with multiple properties in a different order', () => {
-    const a = [
-      { id: 1, name: 'Alice', age: 25 },
-      { id: 2, name: 'Bob', age: 30 },
-      { id: 3, name: 'Charlie', age: 35 },
-    ];
-    const b = [
-      { id: 3, name: 'Charlie', age: 35 },
-      { id: 1, name: 'Alice', age: 25 },
-      { id: 2, name: 'Bob', age: 30 },
-    ];
-    const result = compareArraysByProp(a, b, 'id');
-    expect(result).toEqual(true);
-  });
-
-  it('should return false for two arrays with different objects with multiple properties', () => {
-    const a = [
-      { id: 1, name: 'Alice', age: 25 },
-      { id: 2, name: 'Bob', age: 30 },
-      { id: 3, name: 'Charlie', age: 35 },
-    ];
-    const b = [
-      { id: 4, name: 'Dave', age: 40 },
-      { id: 5, name: 'Eve', age: 45 },
-      { id: 6, name: 'Frank', age: 50 },
-    ];
-    const result = compareArraysByProp(a, b, 'id');
-    expect(result).toEqual(false);
-  });
-
-  it('should return false for two arrays with different objects with multiple properties and some shared objects', () => {
-    const a = [
-      { id: 1, name: 'Alice', age: 25 },
-      { id: 2, name: 'Bob', age: 30 },
-      { id: 3, name: 'Charlie', age: 35 },
-    ];
-    const b = [
-      { id: 2, name: 'Bob', age: 30 },
-      { id: 3, name: 'Charlie', age: 35 },
-      { id: 4, name: 'Dave', age: 40 },
-    ];
-    const result = compareArraysByProp(a, b, 'id');
-    expect(result).toEqual(false);
-  });
-
-  it('should return true for two arrays with the same objects with multiple properties and multiple props', () => {
-    const a = [
-      { id: 1, name: 'Alice', age: 25 },
-      { id: 2, name: 'Bob', age: 30 },
-      { id: 3, name: 'Charlie', age: 35 },
-    ];
-    const b = [
-      { id: 1, name: 'Alice', age: 25 },
-      { id: 2, name: 'Bob', age: 30 },
-      { id: 3, name: 'Charlie', age: 35 },
-    ];
-    const result = compareArraysByProp(a, b, ['id', 'name']);
-    expect(result).toEqual(true);
-  });
-
-  it('should return true for two arrays with the same objects with multiple properties and multiple props in a different order', () => {
-    const a = [
-      { id: 1, name: 'Alice', age: 25 },
-      { id: 2, name: 'Bob', age: 30 },
-      { id: 3, name: 'Charlie', age: 35 },
-    ];
-    const b = [
-      { id: 3, name: 'Charlie', age: 35 },
-      { id: 1, name: 'Alice', age: 25 },
-      { id: 2, name: 'Bob', age: 30 },
-    ];
-    const result = compareArraysByProp(a, b, ['id', 'name']);
-    expect(result).toEqual(true);
-  });
-
-  it('should return false for two arrays with different objects with multiple properties and multiple props', () => {
-    const a = [
-      { id: 1, name: 'Alice', age: 25 },
-      { id: 2, name: 'Bob', age: 30 },
-      { id: 3, name: 'Charlie', age: 35 },
-    ];
-    const b = [
-      { id: 1, name: 'Bob', age: 40 },
-      { id: 2, name: 'Alice', age: 45 },
-      { id: 3, name: 'Charlie', age: 50 },
-    ];
-    const result = compareArraysByProp(a, b, ['id', 'name']);
-    expect(result).toEqual(false);
-  });
-});

package/src/helpers/compareArraysByProp.ts

@@ -1,56 +0,0 @@
-/**
- * Compare two arrays of objects by only comparing the values in a specific
- *  property (e.g. compare user arrays by comparing their user.id values)
- * @author Gabe Abrams
- * @param a the first array
- * @param b the second array
- * @param prop the property to compare with, or an array of props to compare
- *   with (if array, all values associated with those props must match)
- * @returns true if the arrays contain the same objects as determined by
- *   the values associated with each object's prop
- */
-const compareArraysByProp = (
-  a: any[],
-  b: any[],
-  prop: string | string[],
-): boolean => {
-  // Immediately return if size of arrays is different
-  if (a.length !== b.length) {
-    return false;
-  }
-
-  // Get all props
-  const props = (Array.isArray(prop) ? prop : [prop]);
-
-  // Clone second array so we can work on it
-  const bCloned = [...b];
-
-  // Remove elements from b as we find them in a
-  for (let i = 0; i < a.length; i++) {
-    // Find matching element in b
-    const matchingIndex = bCloned.findIndex((bItem) => {
-      // Compare based on all props
-      return props.every((propToCompareBy) => {
-        const aVal = (a[i] ?? {})[propToCompareBy];
-        const bVal = (bItem ?? {})[propToCompareBy];
-        return aVal === bVal;
-      });
-    });
-
-    // Check if no match
-    const noMatch = (matchingIndex < 0);
-
-    // If no match, there's no corresponding element in b
-    if (noMatch) {
-      return false;
-    }
-
-    // Remove the matching element
-    bCloned.splice(matchingIndex, 1);
-  }
-
-  // If we made it here, all elements in a have a corresponding element in b
-  return true;
-};
-
-export default compareArraysByProp;