moderndash 0.0.9 → 0.0.11

package/src/helpers/collections.ts

@@ -1,5 +1,5 @@
-import type { Collection } from '../types';
+import type { ArrayOrRecord } from '../types';
 
-export function getValuesFromCollection<T>(collection: Collection<T>): T[] {
+export function getValuesFromCollection<T>(collection: ArrayOrRecord<T>): T[] {
     return Array.isArray(collection) ? collection : Object.values(collection);
 }

package/src/lang/isEmpty.ts

@@ -1,4 +1,36 @@
-export function isEmpty(value: unknown): boolean {
+/**
+ * Checks if `value` is an empty object, collection, map, or set.
+ *
+ * Objects are considered empty if they have no own enumerable string keyed
+ * properties.
+ *
+ * Array-like values such as `arguments` objects, arrays, buffers, strings, or
+ * Similarly, maps and sets are considered empty if they have a `size` of `0`.
+ *
+ * @category Lang
+ * @param value - The value to check.
+ * @returns Returns `true` if `value` is empty, else `false`.
+ * @example
+ * isEmpty(null)
+ * // => true
+ *
+ * isEmpty({})
+ * // => true
+ *
+ * isEmpty("")
+ * // => true
+ *
+ * isEmpty([1, 2, 3])
+ * // => false
+ *
+ * isEmpty('abc')
+ * // => false
+ *
+ * isEmpty({ 'a': 1 })
+ * // => false
+ */
+
+export function isEmpty(value: string | object | null | undefined): boolean {
     if (value === null || value === undefined) {
         return true;
     }
@@ -7,10 +39,6 @@ export function isEmpty(value: unknown): boolean {
         return value.length === 0;
     }
 
-    if (typeof value === 'number') {
-        return false;
-    }
-
     if (value instanceof Map || value instanceof Set) {
         return value.size === 0;
     }

package/src/lang/isEqual.ts

@@ -1,5 +1,31 @@
 import type { RecordKey } from '../types';
 
+
+/**
+ * Performs a deep comparison between two values to determine if they are
+ * equivalent.
+ *
+ * **Note:** This method supports comparing arrays, array buffers, booleans,
+ * date objects, error objects, maps, numbers, `Object` objects, regexes,
+ * sets, strings, symbols, and typed arrays. `Object` objects are compared
+ * by their own, not inherited, enumerable properties. Functions and DOM
+ * nodes are compared by strict equality, i.e. `===`.
+ *
+ * @category Lang
+ * @param value1 - The value to compare.
+ * @param value2 - The other value to compare.
+ * @returns Returns `true` if the values are equivalent, else `false`.
+ * @example
+ * var object = { 'a': 1 };
+ * var other = { 'a': 1 };
+ *
+ * _.isEqual(object, other);
+ * // => true
+ *
+ * object === other;
+ * // => false
+ */
+
 export function isEqual(value1: unknown, value2: unknown): boolean {
     if (value1 === value2) return true;
 

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 Collection<T> = T[] | Record<RecordKey, T>;
 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;
-    }, []);
-}