moderndash 0.0.16 → 0.0.18

package/src/array/differenceBy.ts

@@ -1,30 +0,0 @@
-import type { IterateeFunction, MinimumTwoArrays, PropertyShorthand } from '../types';
-
-import { differenceWith } from '@array/differenceWith';
-import { getIterateFunction } from '@helpers/shortHands';
-import { isEqualWith } from '@lang/isEqualWith';
-
-/**
- * This method is like `difference` except that it accepts `iteratee` which
- * is invoked for each element of `array` and `values` to generate the criterion
- * by which they're compared. The order and references of result values are
- * determined by the first array.
- *
- * **Note:** Unlike `pullAllBy`, this method returns a new array.
- *
- * @category Array
- * @param iteratee - The iteratee invoked per element. Or property shorthand.
- * @param arrays - First array to inspect. Others are excluded.
-
- * @returns Returns the new array of filtered values.
- * @example
- * differenceBy(Math.floor, [2.1, 1.2], [2.3, 3.4])
- * // => [1.2]
- * differenceBy('x', [{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }])
- * // => [{ 'x': 2 }]
- */
-
-export function differenceBy<T>(iteratee: IterateeFunction<T> | PropertyShorthand<T>, ...arrays: MinimumTwoArrays<T>): T[] {
-    const iterateeFunction = getIterateFunction(iteratee);
-    return differenceWith((a, b) => isEqualWith(a, b, iterateeFunction), ...arrays);
-}

package/src/array/differenceWith.ts

@@ -1,31 +0,0 @@
-import type { MinimumTwoArrays } from '../types';
-
-/**
- * This method is like `difference` except that it accepts `comparator`
- * which is invoked to compare elements of `array` to `values`. The order and
- * references of result values are determined by the first array. The comparator
- * is invoked with two arguments: (arrVal, othVal).
- *
- * **Note:** Unlike `pullAllWith`, this method returns a new array.
- *
- * @category Array
- * @param comparator - The comparator invoked per element.
- * @param arrays - First array to inspect. Others are excluded.
- * @returns Returns the new array of filtered values.
- * @example
- * differenceWith(isEqual, [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }], [{ 'x': 1, 'y': 2 }])
- * // => [{ 'x': 2, 'y': 1 }]
- */
-
-export function differenceWith<T>(comparator: (a: T, b: T) => boolean, ...arrays: MinimumTwoArrays<T>): T[] {
-    const difference: T[] = [];
-    const [firstArray, ...restArrays] = arrays;
-
-    firstArray.forEach(element => {
-        if (!restArrays.some(array => array.some(item => comparator(item, element)))) {
-            difference.push(element);
-        }
-    });
-
-    return difference;
-}

package/src/array/dropRightWhile.ts

@@ -1,28 +0,0 @@
-/**
- * Creates a slice of `array` excluding elements dropped from the end.
- * Elements are dropped until `predicate` returns falsey. The predicate is
- * invoked with three arguments: (value, index, array).
- *
- * @category Array
- * @param predicate - The function invoked per iteration.
- * @param array - The array to query.
- * @returns Returns the slice of `array`.
- * @example
- * const users = [
- *   { 'user': 'barney',  'active': false },
- *   { 'user': 'fred',    'active': true },
- *   { 'user': 'pebbles', 'active': true }
- * ]
- *
- * dropRightWhile(({ active }) => active, users)
- * // => objects for ['barney']
- */
-
-
-export function dropRightWhile<T>(predicate: (value: T) => boolean, array: T[]) {
-    let i = array.length;
-    while (i > 0 && predicate(array[i - 1])) {
-        i--;
-    }
-    return array.slice(0, i);
-}

package/src/array/dropWhile.ts

@@ -1,24 +0,0 @@
-/**
- * Creates a slice of `array` excluding elements dropped from the beginning.
- * Elements are dropped until `predicate` returns falsey. The predicate is
- * invoked with three arguments: (value, index, array).
- *
- * @category Array
- * @param predicate - The function invoked per iteration.
- * @param array - The array to query.
- * @returns Returns the slice of `array`.
- * @example
- * const users = [
- *   { 'user': 'barney',  'active': true },
- *   { 'user': 'fred',    'active': true },
- *   { 'user': 'pebbles', 'active': false }
- * ]
- *
- * dropWhile(({ active }) => active, users)
- * // => objects for ['pebbles']
- */
-
-export function dropWhile<T>(predicate: (value: T) => boolean, array: T[]): T[] {
-    const index = array.findIndex(x => !predicate(x));
-    return array.slice(index === -1 ? array.length : index);
-}

package/src/array/index.ts

@@ -1,21 +0,0 @@
-export * from './chunk';
-export * from './difference';
-export * from './differenceBy';
-export * from './differenceWith';
-export * from './dropRightWhile';
-export * from './dropWhile';
-export * from './intersection';
-export * from './intersectionBy';
-export * from './intersectionWith';
-export * from './sample';
-export * from './sampleSize';
-export * from './shuffle';
-export * from './takeRightWhile';
-export * from './takeWhile';
-export * from './uniq';
-export * from './uniqBy';
-export * from './uniqWith';
-export * from './unzip';
-export * from './unzipWith';
-export * from './zip';
-export * from './zipWith';

package/src/array/intersection.ts

@@ -1,20 +0,0 @@
-import type { MinimumTwoArrays } from '../types';
-
-import { intersectionWith } from '@array/intersectionWith';
-import { isEqual } from '@lang/isEqual';
-
-/**
- * Creates an array of unique values that are included in all given arrays.
- * The order and references of result values are determined by the first array.
- *
- * @category Array
- * @param arrays - The arrays to inspect.
- * @returns Returns the new array of intersecting values.
- * @example
- * intersection([2, 1], [2, 3])
- * // => [2]
- */
-
-export function intersection<TInput>(...arrays: MinimumTwoArrays<TInput>): TInput[] {
-    return intersectionWith(isEqual, ...arrays);
-}

package/src/array/intersectionBy.ts

@@ -1,26 +0,0 @@
-import type { IterateeFunction, MinimumTwoArrays, PropertyShorthand } from '../types';
-
-import { intersectionWith } from '@array/intersectionWith';
-import { getIterateFunction } from '@helpers/shortHands';
-import { isEqualWith } from '@lang/isEqualWith';
-
-/**
- * This method is like `intersection` except that it accepts `iteratee`
- * which is invoked for each element of each `arrays` to generate the criterion
- * by which they're compared. The order and references of result values are
- * determined by the first array. The iteratee is invoked with one argument:
- * (value).
- *
- * @example
- * intersectionBy(Math.floor, [2.1, 1.2], [2.3, 3.4])
- * // => [2.1]
- * @category Array
- * @param iteratee - The iteratee invoked per element. Or property shorthand.
- * @param arrays - The arrays to inspect.
- * @returns Returns the new array of intersecting values.
- */
-
-export function intersectionBy<TInput>(iteratee: IterateeFunction<TInput> | PropertyShorthand<TInput>, ...arrays: MinimumTwoArrays<TInput>): TInput[] {
-    const iterateeFunction = getIterateFunction(iteratee);
-    return intersectionWith((a, b) => isEqualWith(a, b, iterateeFunction), ...arrays);
-}

package/src/array/intersectionWith.ts

@@ -1,33 +0,0 @@
-import type { MinimumTwoArrays } from '../types';
-
-/**
- * This method is like `intersection` except that it accepts `comparator`
- * which is invoked to compare elements of `arrays`. The order and references
- * of result values are determined by the first array. The comparator is
- * invoked with two arguments: (arrVal, othVal).
- *
- * @example
- * const objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]
- * const others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]
- *
- * intersectionWith(isEqual, objects, others)
- * // => [{ 'x': 1, 'y': 2 }]
- * @category Array
- * @param comparator - The comparator invoked per element.
- * @param arrays - The arrays to inspect.
- * @returns Returns the new array of intersecting values.
- */
-
-export function intersectionWith<T>(comparator: (a: T, b: T) => boolean, ...arrays: MinimumTwoArrays<T>): T[] {
-    const intersection: T[] = [];
-
-    const [firstArray, ...restArrays] = arrays;
-
-    firstArray.forEach(element => {
-        if (restArrays.every(array => array.some(item => comparator(item, element)))) {
-            intersection.push(element);
-        }
-    });
-
-    return intersection;
-}

package/src/array/sample.ts

@@ -1,18 +0,0 @@
-/**
- * Gets a random element from `array`.
- *
- * @category Array
- * @param array - The array to sample.
- * @returns Returns the random element.
- * @example
- * sample([1, 2, 3, 4])
- * // => 2
- */
-
-export function sample<T>(array: T[]): T | undefined {
-    if (array.length === 0) {
-        return undefined;
-    }
-    const randomIndex = Math.floor(Math.random() * array.length);
-    return array[randomIndex];
-}

package/src/array/sampleSize.ts

@@ -1,31 +0,0 @@
-import { sample } from '@array/sample';
-
-/**
- * Gets `n` random elements at unique keys from `array` up to the
- * size of `array`.
- *
- * @category Array
- * @param size The number of elements to sample.
- * @param array The array to sample.
- * @returns Returns the random elements.
- * @example
- * sampleSize([1, 2, 3], 2)
- * // => [3, 1]
- *
- * sampleSize([1, 2, 3], 4)
- * // => [2, 3, 1]
- */
-
-export function sampleSize<TInput>(size: number, array: TInput[]): TInput[] {
-    const sampleArray: TInput[] = [];
-
-    if (array.length === 0 || size <= 0) {
-        return sampleArray;
-    }
-
-    for (let i = 0; i < size; i++) {
-        sampleArray.push(sample(array) as TInput);
-    }
-
-    return sampleArray;
-}

package/src/array/shuffle.ts

@@ -1,33 +0,0 @@
-/**
- * Creates an array of shuffled values, using a version of the
- * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle).
- *
- * @since 0.1.0
- * @category Array
- * @param array - The array or object to shuffle.
- * @returns Returns the new shuffled array.
- * @example
- * shuffle([1, 2, 3, 4])
- * // => [4, 1, 3, 2]
- */
-
-export function shuffle<TInput>(array: TInput[]): TInput[] {
-    const shuffledArray = [...array];
-    let currentIndex = shuffledArray.length;
-    let temporaryValue: TInput;
-    let randomIndex: number;
-
-    // While there remain elements to shuffle...
-    while (0 !== currentIndex) {
-        // Pick a remaining element...
-        randomIndex = Math.floor(Math.random() * currentIndex);
-        currentIndex -= 1;
-
-        // And swap it with the current element.
-        temporaryValue = shuffledArray[currentIndex];
-        shuffledArray[currentIndex] = shuffledArray[randomIndex];
-        shuffledArray[randomIndex] = temporaryValue;
-    }
-
-    return shuffledArray;
-}

package/src/array/takeRightWhile.ts

@@ -1,33 +0,0 @@
-/**
- * Creates a slice of `array` with elements taken from the end. Elements are
- * taken until `predicate` returns falsey. The predicate is invoked with
- * three arguments: (value, index, array).
- *
- * @category Array
- * @param predicate - The function invoked per iteration.
- * @param array - The array to query.
- * @returns Returns the slice of `array`.
- * @example
- * const users = [
- *   { 'user': 'barney',  'active': false },
- *   { 'user': 'fred',    'active': true },
- *   { 'user': 'pebbles', 'active': true }
- * ]
- *
- * takeRightWhile(({ active }) => active, users)
- * // => objects for ['fred', 'pebbles']
- */
-
-export function takeRightWhile<T>(predicate: (elem: T) => boolean, array: T[]): T[] {
-    const result: T[] = [];
-
-    for (let i = array.length - 1; i >= 0; i--) {
-        if (predicate(array[i])) {
-            result.unshift(array[i]);
-        } else {
-            break;
-        }
-    }
-
-    return result;
-}

package/src/array/takeWhile.ts

@@ -1,33 +0,0 @@
-/**
- * Creates a slice of `array` with elements taken from the beginning. Elements
- * are taken until `predicate` returns falsey. The predicate is invoked with
- * three arguments: (value, index, array).
- *
- * @category Array
- * @param predicate The function invoked per iteration.
- * @param array The array to query.
- * @returns Returns the slice of `array`.
- * @example
- * const users = [
- *   { 'user': 'barney',  'active': true },
- *   { 'user': 'fred',    'active': true },
- *   { 'user': 'pebbles', 'active': false }
- * ]
- *
- * takeWhile(({ active }) => active, users)
- * // => objects for ['barney', 'fred']
- */
-
-export function takeWhile<T>(predicate: (elem: T) => boolean, array: T[]): T[] {
-    const result: T[] = [];
-
-    for (const element of array) {
-        if (predicate(element)) {
-            result.push(element);
-        } else {
-            break;
-        }
-    }
-
-    return result;
-}

package/src/array/uniq.ts

@@ -1,18 +0,0 @@
-import { uniqWith } from '@array/uniqWith';
-import { isEqual } from '@lang/isEqual';
-
-/**
- * Creates a duplicate-free version of an array, in which only the first occurrence of each element is kept.
- * The order of result values is determined by the order they occur in the array.
- *
- * @category Array
- * @param array - The array to inspect.
- * @returns Returns the new duplicate free array.
- * @example
- * uniq([2, 1, 2])
- * // => [2, 1]
- */
-
-export function uniq<TInput>(array: TInput[]): TInput[] {
-    return uniqWith(isEqual, array);
-}

package/src/array/uniqBy.ts

@@ -1,25 +0,0 @@
-import type { IterateeFunction, PropertyShorthand } from '../types';
-
-import { uniqWith } from '@array/uniqWith';
-import { getIterateFunction } from '@helpers/shortHands';
-
-/**
- * This method is like `uniq` except that it accepts `iteratee` which is
- * invoked for each element in `array` to generate the criterion by which
- * uniqueness is computed. The order of result values is determined by the
- * order they occur in the array.
- *
- * @category Array
- * @param array - The array to inspect.
- * @param iteratee - The iteratee invoked per element. Or property shorthand.
- * @returns Returns the new duplicate free array.
- * @example
- * uniqBy(Math.floor, [2.1, 1.2, 2.3])
- * // => [2.1, 1.2]
- */
-
-export function uniqBy<T>(iteratee: IterateeFunction<T> | PropertyShorthand<T>, array: T[]): T[] {
-    const iterateeFunction = getIterateFunction(iteratee);
-
-    return uniqWith((a, b) => iterateeFunction(a) === iterateeFunction(b), array);
-}

package/src/array/uniqWith.ts

@@ -1,20 +0,0 @@
-/**
- * This method is like `uniq` except that it accepts `comparator` which is invoked to compare elements of `array`.
- * The order of result values is determined by the order they occur in the array.
- *
- * @category Array
- * @param array - The array to inspect.
- * @param comparator - The comparator invoked per element.
- * @returns Returns the new duplicate free array.
- * @example
- * const objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }]
- *
- * uniqWith(isEqual, objects)
- * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]
- */
-
-export function uniqWith<TInput>(comparator: (a: TInput, b: TInput) => boolean, array: TInput[]): TInput[] {
-    return array.filter((value, index, self) => {
-        return self.findIndex(otherValue => comparator(value, otherValue)) === index;
-    });
-}

package/src/array/unzip.ts

@@ -1,20 +0,0 @@
-import { unzipWith } from '@array/unzipWith';
-
-/**
- * This method is like `zip` except that it accepts an array of grouped
- * elements and creates an array regrouping the elements to their pre-zip configuration.
- *
- * @category Array
- * @param array - The array of grouped elements to process.
- * @returns Returns the new array of regrouped elements.
- * @example
- * const zipped = zip(['a', 'b'], [1, 2], [true, false])
- * // => [['a', 1, true], ['b', 2, false]]
- *
- * unzip(zipped)
- * // => [['a', 'b'], [1, 2], [true, false]]
- */
-
-export function unzip<TInput extends unknown[]>(array: TInput[]): TInput[] {
-    return unzipWith((...t) => t, array);
-}

package/src/array/unzipWith.ts

@@ -1,26 +0,0 @@
-/**
- * This method is like `unzip` except that it accepts `iteratee` to specify
- * how regrouped values should be combined. The iteratee is invoked with the
- * elements of each group: (...group).
- *
- * @category Array
- * @param iteratee - The function to combine regrouped values.
- * @param array - The array of grouped elements to process.
- * @returns Returns the new array of regrouped elements.
- * @example
- * const zipped = zip([1, 2], [10, 20], [100, 200])
- * // => [[1, 10, 100], [2, 20, 200]]
- *
- * unzipWith(add, zipped)
- * // => [3, 30, 300]
- */
-
-export function unzipWith<TInput extends unknown[], TOutput>(iteratee: (...t: TInput) => TOutput, array: TInput[]): TOutput[] {
-    const result: TOutput[] = [];
-
-    for (const elements of array) {
-        result.push(iteratee(...elements));
-    }
-
-    return result;
-}

package/src/array/zip.ts

@@ -1,17 +0,0 @@
-import { zipWith } from '@array/zipWith';
-
-/**
- * Creates an array of grouped elements, the first of which contains the first elements of the given arrays,
- * the second of which contains the second elements of the given arrays, and so on.
- *
- * @category Array
- * @param arrays - The arrays to process.
- * @returns Returns the new array of grouped elements.
- * @example
- * zip(['a', 'b'], [1, 2], [true, false])
- * // => [['a', 1, true], ['b', 2, false]]
- */
-
-export function zip<TInput>(...arrays: TInput[][]): TInput[][] {
-    return zipWith((...t) => t, ...arrays);
-}

package/src/array/zipWith.ts

@@ -1,28 +0,0 @@
-// Types from https://gist.github.com/briancavalier/c4af1538ae9b2e4ab97caf14306625ab
-type UnZip<A extends readonly unknown[]> = {
-    [K in keyof A]: readonly A[K][]
-};
-
-/**
- * This method is like `zip` except that it accepts `iteratee` to specify
- * how grouped values should be combined. The iteratee is invoked with the
- * elements of each group: (...group).
- *
- * @category Array
- * @param combineFunc - The function to combine grouped values.
- * @param arrays - The arrays to process.
- * @returns Returns the new array of grouped elements.
- * @example
- * zipWith([1, 2], [10, 20], [100, 200], (a, b, c) => a + b + c)
- * // => [111, 222]
- */
-
-export function zipWith<Args extends unknown[], TOutput>(combineFunc: (...args: Args) => TOutput, ...arrays: UnZip<Args>): TOutput[] {
-    const len = Math.min(...arrays.map(a => a.length));
-    const zipped: TOutput[] = [];
-    for (let i = 0; i < len; i++) {
-        // Typescript needs the Args hint, or it infers any[]
-        zipped[i] = combineFunc(...arrays.map(a => a[i]) as Args);
-    }
-    return zipped;
-}

package/src/collection/countBy.ts

@@ -1,38 +0,0 @@
-import type { ArrayOrRecord, RecordKey } from '../types';
-
-import { getValuesFromCollection } from '@helpers/collections';
-
-/**
- * Creates an object composed of keys generated from the results of running
- * each element of `collection` thru `iteratee`. The corresponding value of
- * each key is the number of times the key was returned by `iteratee`.
- *
- * @example
- * const users = [
- *   { 'user': 'barney', 'active': true },
- *   { 'user': 'betty', 'active': true },
- *   { 'user': 'fred', 'active': false }
- * ]
- *
- * countBy(users, value => value.active);
- * // => { 'true': 2, 'false': 1 }
- * @category Collection
- * @param iteratee - The iteratee to transform keys.
- * @param collection - The array or record to iterate over.
- * @returns Returns the composed aggregate object.
- */
-
-export function countBy<TInput, TKey extends RecordKey>(collection: ArrayOrRecord<TInput>, iteratee: (value: TInput) => TKey): Record<TKey, number> {
-    const result = {} as Record<TKey, number>;
-    const values = getValuesFromCollection(collection);
-    for (const value of values) {
-        const key = iteratee(value);
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        if (result[key] === undefined) {
-            result[key] = 1;
-        } else {
-            result[key] += 1;
-        }
-    }
-    return result;
-}

package/src/collection/groupBy.ts

@@ -1,32 +0,0 @@
-import type { RecordKey, ArrayOrRecord } from '../types';
-
-import { getValuesFromCollection } from '@helpers/collections';
-
-
-/**
- * Creates an object composed of keys generated from the results of running
- * each element of `collection` thru `iteratee`. The order of grouped values
- * is determined by the order they occur in `collection`. The corresponding
- * value of each key is an array of elements responsible for generating the
- * key.
- *
- * @example
- * groupBy([6.1, 4.2, 6.3], Math.floor)
- * // => { '4': [4.2], '6': [6.1, 6.3] }
- * @category Collection
- * @param collection - The array or object to iterate over.
- * @param iteratee - The iteratee to transform keys.
- * @returns Returns the composed aggregate object.
- */
-
-export function groupBy<T, U extends RecordKey>(collection: ArrayOrRecord<T>, iteratee: (value: T) => U): Record<U, T[]> {
-    const result = {} as Record<U, T[]>;
-    const values = getValuesFromCollection(collection);
-    for (const value of values) {
-        const key = iteratee(value);
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        result[key] = result[key] ?? [];
-        result[key].push(value);
-    }
-    return result;
-}

package/src/collection/index.ts

@@ -1,3 +0,0 @@
-export * from './countBy';
-export * from './groupBy';
-export * from './sortBy';

package/src/collection/sortBy.ts

@@ -1,15 +0,0 @@
-import type { NoUnion } from '../types';
-
-export function sortBy<T, U>(iteratee: (item: T) => NoUnion<number | bigint | Date | string, U>, array: T[]): T[] {
-    return array.sort((a, b) => {
-        const aValue = iteratee(a);
-        const bValue = iteratee(b);
-        if (aValue < bValue) {
-            return -1;
-        }
-        if (aValue > bValue) {
-            return 1;
-        }
-        return 0;
-    });
-}

package/src/function/after.ts

@@ -1,29 +0,0 @@
-import type { GenericFunction } from '../types.js';
-
-/**
- * The opposite of `before`. This method creates a function that invokes `func` once it's called `n` or more times.
- *
- * @category Function
- * @param n The number of calls before `func` is invoked.
- * @param func The function to restrict.
- * @returns Returns the new restricted function.
- * @example
- * const caution = () => console.log("Caution!");
- *
- * const afterFN = after(2, caution);
- *
- * afterFN()
- * afterFN()
- * afterFN()
- * // => `caution` is invoked after called twice
- */
-
-export function after<TFunc extends GenericFunction<TFunc>>(n: number, func: TFunc) {
-    let count = 1;
-    return (...args: Parameters<TFunc>): ReturnType<TFunc> | undefined => {
-        if (count >= n) {
-            return func(...args);
-        }
-        count += 1;
-    };
-}