moderndash 0.0.10 → 0.0.11

package/src/lang/isEqualWith.ts

@@ -1,5 +1,34 @@
 import { isEqual } from '@lang/isEqual';
 
-export function isEqualWith<T>(customizer: (value: T) => unknown, a: T, b: T): boolean {
+/**
+ * This method is like `_.isEqual` except that it accepts `customizer` which
+ * is invoked to compare values. If `customizer` returns `undefined`, comparisons
+ * are handled by the method instead. The `customizer` is invoked with up to
+ * six arguments: (objValue, othValue [, index|key, object, other, stack]).
+ *
+ * @category Lang
+ * @param value1 - The value to compare.
+ * @param value2 - The other value to compare.
+ * @param customizer - The function to customize comparisons.
+ * @returns Returns `true` if the values are equivalent, else `false`.
+ * @example
+ * function isGreeting(value) {
+ *   return /^h(?:i|ello)$/.test(value);
+ * }
+ *
+ * function customizer(objValue, othValue) {
+ *   if (isGreeting(objValue) && isGreeting(othValue)) {
+ *     return true;
+ *   }
+ * }
+ *
+ * var array = ['hello', 'goodbye'];
+ * var other = ['hi', 'goodbye'];
+ *
+ * isEqualWith(array, other, customizer);
+ * // => true
+*/
+
+export function isEqualWith<T>(a: T, b: T, customizer: (value: T) => unknown): boolean {
     return isEqual(customizer(a), customizer(b));
 }

package/src/types.ts

@@ -1,9 +1,15 @@
-export type MinimumTwoArrays<T> = [T[], T[], ...T[][]];
+export type MinimumTwoArrays<TInput> = [TInput[], TInput[], ...TInput[][]];
 
 export type IterateeFunction<T> = (value: T) => unknown;
 export type PropertyShorthand<T> = keyof T;
 
 export type RecordKey = string | number | symbol;
+export type ArrayOrRecord<TInput> = TInput[] | Record<RecordKey, TInput>;
 
-export type ArrayOrRecord<T> = T[] | Record<RecordKey, T>;
-export type NoUnion<T, U = T> = T extends U ? [U] extends [T] ? T : never : never; 
+export type NoUnion<T, U = T> = T extends U ? [U] extends [T] ? T : never : never;
+
+/**
+ * @description Generic function type, should fit any function
+ * @typeParam TFunc - The input function type
+ */
+export type GenericFunction<TFunc extends (...args: Parameters<TFunc>) => ReturnType<TFunc>> = (...args: Parameters<TFunc>) => ReturnType<TFunc>;

package/src/array/union.ts

@@ -1,16 +0,0 @@
-import type { MinimumTwoArrays } from '../types';
-
-/**
- * Creates an array of unique values, in order, from all given arrays using for equality comparisons.
- *
- * @category Array
- * @param arrays - The arrays to inspect.
- * @returns Returns the new array of combined values.
- * @example
- * union([2, 3], [1, 2])
- * // => [2, 3, 1]
- */
-
-export function union<TInput>(...arrays: MinimumTwoArrays<TInput>): TInput[] {
-    return [...new Set(arrays.flat())];
-}

package/src/array/unionBy.ts

@@ -1,26 +0,0 @@
-import type { IterateeFunction, MinimumTwoArrays, PropertyShorthand } from '../types';
-
-import { unionWith } from '@array/unionWith';
-import { getIterateFunction } from '@helpers/shortHands';
-import { isEqualWith } from '@lang/isEqualWith';
-
-/**
- * This method is like `union` except that it accepts `iteratee` which is
- * invoked for each element of each `arrays` to generate the criterion by
- * which uniqueness is computed. Result values are chosen from the first
- * array in which the value occurs. The iteratee is invoked with one argument:
- * (value).
- *
- * @category Array
- * @param arrays - The arrays to inspect.
- * @param iteratee - The iteratee invoked per element. Or property shorthand.
- * @returns Returns the new array of combined values.
- * @example
- * unionBy(Math.floor, [2.1], [1.2, 2.3])
- * // => [2.1, 1.2]
- */
-
-export function unionBy<T>(iteratee: IterateeFunction<T> | PropertyShorthand<T>, ...arrays: MinimumTwoArrays<T>): T[] {
-    const iterateeFunction = getIterateFunction(iteratee);
-    return unionWith((a, b) => isEqualWith(iterateeFunction, a, b), ...arrays);
-}

package/src/array/unionWith.ts

@@ -1,31 +0,0 @@
-import type { MinimumTwoArrays } from '../types';
-
-/**
- * This method is like `union` except that it accepts `comparator` which
- * is invoked to compare elements of `arrays`. Result values are chosen from
- * the first array in which the value occurs. The comparator is invoked
- * with two arguments: (arrVal, othVal).
- *
- * @category Array
- * @param comparator - The comparator invoked per element.
- * @param arrays - The arrays to inspect.
- * @returns Returns the new array of combined values.
- * @example
- * const objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]
- * const others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]
- *
- * unionWith(isEqual, objects, others)
- * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
- */
-
-export function unionWith<TInput>(comparator: (a: TInput, b: TInput) => boolean, ...arrays: MinimumTwoArrays<TInput>): TInput[] {
-    return arrays.reduce((acc, current) => {
-        for (const item of current) {
-            if (acc.some(x => comparator(x, item))) {
-                continue;
-            }
-            acc.push(item);
-        }
-        return acc;
-    }, []);
-}