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

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

@@ -1,136 +0,0 @@
-import forEachAsync from './forEachAsync';
-
-describe('forEachAsync', () => {
-  it('should call the operator function for each item in the array', async () => {
-    const array = [1, 2, 3];
-    const operatorFunction = jest.fn();
-
-    await forEachAsync(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 pass the correct arguments to the operator function', async () => {
-    const array = ['a', 'b', 'c'];
-    const operatorFunction = jest.fn();
-
-    await forEachAsync(array, operatorFunction);
-
-    expect(operatorFunction).toHaveBeenCalledTimes(3);
-    expect(operatorFunction).toHaveBeenCalledWith('a', 0, expect.any(Object));
-    expect(operatorFunction).toHaveBeenCalledWith('b', 1, expect.any(Object));
-    expect(operatorFunction).toHaveBeenCalledWith('c', 2, expect.any(Object));
-  });
-
-  it('should allow the operator function to break out of the loop', async () => {
-    const array = [1, 2, 3];
-    const operatorFunction = jest.fn((item, index, { breakNow }) => {
-      if (item === 2) {
-        breakNow();
-      }
-    });
-
-    await forEachAsync(array, operatorFunction);
-
-    expect(operatorFunction).toHaveBeenCalledTimes(2);
-    expect(operatorFunction).toHaveBeenCalledWith(1, 0, expect.any(Object));
-    expect(operatorFunction).toHaveBeenCalledWith(2, 1, expect.any(Object));
-  });
-
-  it('should not call the operator function if the array is empty', async () => {
-    const array: string[] = [];
-    const operatorFunction = jest.fn();
-
-    await forEachAsync(array, operatorFunction);
-
-    expect(operatorFunction).not.toHaveBeenCalled();
-  });
-
-  it('should return undefined', async () => {
-    const array = [1, 2, 3];
-    const operatorFunction = jest.fn();
-
-    const result = await forEachAsync(array, operatorFunction);
-
-    expect(result).toBeUndefined();
-  });
-
-  it('should work with an array of objects', async () => {
-    const array = [
-      { name: 'Alice', age: 30 },
-      { name: 'Bob', age: 25 },
-      { name: 'Charlie', age: 40 },
-    ];
-    const operatorFunction = jest.fn();
-
-    await forEachAsync(array, operatorFunction);
-
-    expect(operatorFunction).toHaveBeenCalledTimes(3);
-    expect(operatorFunction).toHaveBeenCalledWith(
-      { name: 'Alice', age: 30 },
-      0,
-      expect.any(Object),
-    );
-    expect(operatorFunction).toHaveBeenCalledWith(
-      { name: 'Bob', age: 25 },
-      1,
-      expect.any(Object),
-    );
-    expect(operatorFunction).toHaveBeenCalledWith(
-      { name: 'Charlie', age: 40 },
-      2,
-      expect.any(Object),
-    );
-  });
-
-  it('should work with an array of mixed types', async () => {
-    const array = [1, 'two', { three: 3 }];
-    const operatorFunction = jest.fn();
-
-    await forEachAsync(array, operatorFunction);
-
-    expect(operatorFunction).toHaveBeenCalledTimes(3);
-    expect(operatorFunction).toHaveBeenCalledWith(1, 0, expect.any(Object));
-    expect(operatorFunction).toHaveBeenCalledWith('two', 1, expect.any(Object));
-    expect(operatorFunction).toHaveBeenCalledWith(
-      { three: 3 },
-      2,
-      expect.any(Object),
-    );
-  });
-
-  it('should work with an array of length 1', async () => {
-    const array = ['a'];
-    const operatorFunction = jest.fn();
-
-    await forEachAsync(array, operatorFunction);
-
-    expect(operatorFunction).toHaveBeenCalledTimes(1);
-    expect(operatorFunction).toHaveBeenCalledWith('a', 0, expect.any(Object));
-  });
-
-  it('should work with an array of length 100', async () => {
-    const array = Array.from({ length: 100 }, (_, i) => i);
-    const operatorFunction = jest.fn();
-
-    await forEachAsync(array, operatorFunction);
-
-    expect(operatorFunction).toHaveBeenCalledTimes(100);
-    expect(operatorFunction).toHaveBeenCalledWith(0, 0, expect.any(Object));
-    expect(operatorFunction).toHaveBeenCalledWith(99, 99, expect.any(Object));
-  });
-
-  it('should work with an array of length 1000', async () => {
-    const array = Array.from({ length: 1000 }, (_, i) => i);
-    const operatorFunction = jest.fn();
-
-    await forEachAsync(array, operatorFunction);
-
-    expect(operatorFunction).toHaveBeenCalledTimes(1000);
-    expect(operatorFunction).toHaveBeenCalledWith(0, 0, expect.any(Object));
-    expect(operatorFunction).toHaveBeenCalledWith(999, 999, expect.any(Object));
-  });
-});

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;