moderndash 0.0.10 → 0.0.11

package/dist/index.d.ts

@@ -14,12 +14,17 @@
  */
 declare function chunk<TInput>(chunkSize: number, array: TInput[]): TInput[][];
 
-type MinimumTwoArrays<T> = [T[], T[], ...T[][]];
+type MinimumTwoArrays<TInput> = [TInput[], TInput[], ...TInput[][]];
 type IterateeFunction<T> = (value: T) => unknown;
 type PropertyShorthand<T> = keyof T;
 type RecordKey = string | number | symbol;
-type ArrayOrRecord<T> = T[] | Record<RecordKey, T>;
-type NoUnion<T, U = T> = T extends U ? [U] extends [T] ? T : never : never;
+type ArrayOrRecord<TInput> = TInput[] | Record<RecordKey, TInput>;
+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
+ */
+type GenericFunction<TFunc extends (...args: Parameters<TFunc>) => ReturnType<TFunc>> = (...args: Parameters<TFunc>) => ReturnType<TFunc>;
 
 /**
  * Creates an array of `array` values not included in the other given arrays. The order and references of result values are determined by the first array.
@@ -31,9 +36,9 @@ type NoUnion<T, U = T> = T extends U ? [U] extends [T] ? T : never : never;
  * @returns Returns the new array of filtered values.
  * @example
  * difference([2, 1], [2, 3])
- * // =\> [1]
+ * // => [1]
  */
-declare function difference<T>(...arrays: MinimumTwoArrays<T>): T[];
+declare function difference<TInput>(...arrays: MinimumTwoArrays<TInput>): TInput[];
 
 /**
  * This method is like `difference` except that it accepts `iteratee` which
@@ -250,54 +255,6 @@ declare function takeRightWhile<T>(predicate: (elem: T) => boolean, array: T[]):
  */
 declare function takeWhile<T>(predicate: (elem: T) => boolean, array: T[]): T[];
 
-/**
- * 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]
- */
-declare function union<TInput>(...arrays: MinimumTwoArrays<TInput>): TInput[];
-
-/**
- * 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]
- */
-declare function unionBy<T>(iteratee: IterateeFunction<T> | PropertyShorthand<T>, ...arrays: MinimumTwoArrays<T>): T[];
-
-/**
- * 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 }]
- */
-declare function unionWith<TInput>(comparator: (a: TInput, b: TInput) => boolean, ...arrays: MinimumTwoArrays<TInput>): TInput[];
-
 /**
  * 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.
@@ -456,16 +413,19 @@ declare function sortBy<T, U>(iteratee: (item: T) => NoUnion<number | bigint | D
  * @param func The function to restrict.
  * @returns Returns the new restricted function.
  * @example
- * const caution = () => alert("Caution!");
+ * const caution = () => console.log("Caution!");
  *
- * // Display alert only after it has been called 5 times
- * after(5, caution)
+ * const afterFN = after(2, caution);
+ *
+ * afterFN()
+ * afterFN()
+ * afterFN()
+ * // => `caution` is invoked after called twice
  */
-declare function after<TFunc extends (...args: Parameters<TFunc>) => ReturnType<TFunc>>(n: number, func: TFunc): (...args: Parameters<TFunc>) => ReturnType<TFunc> | undefined;
+declare function after<TFunc extends GenericFunction<TFunc>>(n: number, func: TFunc): (...args: Parameters<TFunc>) => ReturnType<TFunc> | undefined;
 
 /**
- * Creates a function that invokes `func`, with the `this` binding and arguments
- * of the created function, while it's called less than `n` times. Subsequent
+ * Creates a function that invokes `func`, while it's called less than `n` times. Subsequent
  * calls to the created function return the result of the last `func` invocation.
  *
  * @category Function
@@ -473,20 +433,24 @@ declare function after<TFunc extends (...args: Parameters<TFunc>) => ReturnType<
  * @param func - The function to restrict.
  * @returns Returns the new restricted function.
  * @example
- * const caution = () => alert("Caution!");
+ * const caution = () => console.log("Caution!");
  *
  * // Only call caution two times
- * before(2, caution)
+ * const reducedCaution = before(2, caution)
+ *
+ * reducedCaution()
+ * reducedCaution()
+ * reducedCaution()
+ * // => `caution` is invoked twice
  */
 declare function before<TFunc extends (...args: Parameters<TFunc>) => ReturnType<TFunc>>(n: number, func: TFunc): TFunc;
 
-declare function debounce<T extends (...args: Parameters<T>) => ReturnType<T>>(fn: T, wait?: number, options?: {
+declare function debounce<TFunc extends GenericFunction<TFunc>>(fn: TFunc, wait?: number, options?: {
     leading?: boolean;
     maxWait?: number;
     trailing?: boolean;
-}): (this: ThisParameterType<T>, ...args: Parameters<T>) => ReturnType<T>;
+}): (this: ThisParameterType<TFunc>, ...args: Parameters<TFunc>) => ReturnType<TFunc>;
 
-type Cache = Map<string | symbol, unknown>;
 /**
  * Creates a function that memoizes the result of `func`. If `resolver` is
  * provided, it determines the cache key for storing the result based on the
@@ -502,6 +466,8 @@ type Cache = Map<string | symbol, unknown>;
  * @category Function
  * @param func - The function to have its output memoized.
  * @param resolver - The function to resolve the cache key.
+ * @typeParam TFunc - The input function type
+ * @typeParam Cache - The cache map type
  * @returns  Returns the new memoized function.
  * @example
  * const object = \{ 'a': 1, 'b': 2 \}
@@ -525,22 +491,139 @@ type Cache = Map<string | symbol, unknown>;
  * // Replace `memoize.Cache`.
  * memoize.Cache = WeakMap
  */
-declare function memoize<TFunc extends (...args: Parameters<TFunc>) => ReturnType<TFunc>>(func: TFunc, resolver?: ((...args: Parameters<TFunc>) => string | symbol)): TFunc & {
+declare function memoize<TFunc extends GenericFunction<TFunc>, Cache extends Map<string | symbol, ReturnType<TFunc>>>(func: TFunc, resolver?: ((...args: Parameters<TFunc>) => string | symbol)): TFunc & {
     cache: Cache;
 };
 
-declare function once<TFunc extends (...args: Parameters<TFunc>) => ReturnType<TFunc>>(func: TFunc): TFunc;
+/**
+ * Creates a function that is restricted to invoking `func` once. Repeat calls
+ * to the function return the value of the first invocation. The `func` is
+ * invoked with the `this` binding and arguments of the created function.
+ *
+ * @category Function
+ * @param func - The function to restrict.
+ * @returns Returns the new restricted function.
+ * @example
+ * const initialize = once(() => console.log('initialize'))
+ * initialize()
+ * initialize()
+ * // => `createApplication` is invoked once
+ */
+declare function once<TFunc extends GenericFunction<TFunc>>(func: TFunc): TFunc;
 
-declare function throttle<T extends (...args: Parameters<T>) => ReturnType<T>>(func: T, wait?: number, options?: {
+declare function throttle<TFunc extends GenericFunction<TFunc>>(func: TFunc, wait?: number, options?: {
     leading?: boolean;
     trailing?: boolean;
-}): (this: ThisParameterType<T>, ...args: Parameters<T>) => ReturnType<T>;
+}): (this: ThisParameterType<TFunc>, ...args: Parameters<TFunc>) => ReturnType<TFunc>;
 
-declare function isEmpty(value: unknown): boolean;
+/**
+ * Invokes the iteratee `n` times, returning an array of the results of
+ * each invocation. The function is invoked with one argument: (index).
+ *
+ * @category Function
+ * @param n - The number of times to invoke `func`.
+ * @param iteratee - The function invoked per iteration.
+ * @returns Returns the array of results.
+ * @example
+ * times(3, index => console.log("Run", index)))
+ * // => "Run 0" | "Run 1" | "Run 2"
+ *
+ * times(3, Math.random)
+ * // => [0.123, 0.456, 0.789]
+ *
+ * times(4, () => 0)
+ * // => [0, 0, 0, 0]
+ */
+declare function times<T>(n: number, func: (index: number) => T): T[];
+
+/**
+ * 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
+ */
+declare function isEmpty(value: string | object | null | undefined): boolean;
 
+/**
+ * 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
+ */
 declare function isEqual(value1: unknown, value2: unknown): boolean;
 
-declare 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
+*/
+declare function isEqualWith<T>(a: T, b: T, customizer: (value: T) => unknown): boolean;
 
 declare function isPlainObject(value: unknown): value is object;
 
@@ -582,4 +665,4 @@ declare function stripSpecialChars(str: string): string;
 
 declare function unescapeHTML(html: string): string;
 
-export { ArrayOrRecord, IterateeFunction, MinimumTwoArrays, NoUnion, PropertyShorthand, RecordKey, after, before, camelCase, capitalize, chunk, countBy, debounce, deburr, difference, differenceBy, differenceWith, dropRightWhile, dropWhile, escape, escapeRegExp, groupBy, intersection, intersectionBy, intersectionWith, isEmpty, isEqual, isEqualWith, isPlainObject, kebabCase, memoize, once, pascalCase, pick, sample, sampleSize, shuffle, snakeCase, sortBy, startCase, stripSpecialChars, takeRightWhile, takeWhile, throttle, unescapeHTML, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, zip, zipWith };
+export { ArrayOrRecord, GenericFunction, IterateeFunction, MinimumTwoArrays, NoUnion, PropertyShorthand, RecordKey, after, before, camelCase, capitalize, chunk, countBy, debounce, deburr, difference, differenceBy, differenceWith, dropRightWhile, dropWhile, escape, escapeRegExp, groupBy, intersection, intersectionBy, intersectionWith, isEmpty, isEqual, isEqualWith, isPlainObject, kebabCase, memoize, once, pascalCase, pick, sample, sampleSize, shuffle, snakeCase, sortBy, startCase, stripSpecialChars, takeRightWhile, takeWhile, throttle, times, unescapeHTML, uniq, uniqBy, uniqWith, unzip, unzipWith, zip, zipWith };

package/dist/index.js

@@ -89,14 +89,14 @@ function getIterateFunction(iteratee) {
 }
 
 // src/lang/isEqualWith.ts
-function isEqualWith(customizer, a, b) {
+function isEqualWith(a, b, customizer) {
   return isEqual(customizer(a), customizer(b));
 }
 
 // src/array/differenceBy.ts
 function differenceBy(iteratee, ...arrays) {
   const iterateeFunction = getIterateFunction(iteratee);
-  return differenceWith((a, b) => isEqualWith(iterateeFunction, a, b), ...arrays);
+  return differenceWith((a, b) => isEqualWith(a, b, iterateeFunction), ...arrays);
 }
 
 // src/array/dropRightWhile.ts
@@ -134,7 +134,7 @@ function intersection(...arrays) {
 // src/array/intersectionBy.ts
 function intersectionBy(iteratee, ...arrays) {
   const iterateeFunction = getIterateFunction(iteratee);
-  return intersectionWith((a, b) => isEqualWith(iterateeFunction, a, b), ...arrays);
+  return intersectionWith((a, b) => isEqualWith(a, b, iterateeFunction), ...arrays);
 }
 
 // src/array/sample.ts
@@ -200,30 +200,6 @@ function takeWhile(predicate, array) {
   return result;
 }
 
-// src/array/union.ts
-function union(...arrays) {
-  return [...new Set(arrays.flat())];
-}
-
-// src/array/unionWith.ts
-function unionWith(comparator, ...arrays) {
-  return arrays.reduce((acc, current) => {
-    for (const item of current) {
-      if (acc.some((x) => comparator(x, item))) {
-        continue;
-      }
-      acc.push(item);
-    }
-    return acc;
-  }, []);
-}
-
-// src/array/unionBy.ts
-function unionBy(iteratee, ...arrays) {
-  const iterateeFunction = getIterateFunction(iteratee);
-  return unionWith((a, b) => isEqualWith(iterateeFunction, a, b), ...arrays);
-}
-
 // src/array/uniqWith.ts
 function uniqWith(comparator, array) {
   return array.filter((value, index, self) => {
@@ -462,6 +438,15 @@ function throttle(func, wait = 0, options = {}) {
   });
 }
 
+// src/function/times.ts
+function times(n, func) {
+  const result = [];
+  for (let i = 0; i < n; i++) {
+    result.push(func(i));
+  }
+  return result;
+}
+
 // src/lang/isEmpty.ts
 function isEmpty(value) {
   if (value === null || value === void 0) {
@@ -470,9 +455,6 @@ function isEmpty(value) {
   if (typeof value === "string" || Array.isArray(value)) {
     return value.length === 0;
   }
-  if (typeof value === "number") {
-    return false;
-  }
   if (value instanceof Map || value instanceof Set) {
     return value.size === 0;
   }
@@ -643,10 +625,8 @@ export {
   takeRightWhile,
   takeWhile,
   throttle,
+  times,
   unescapeHTML,
-  union,
-  unionBy,
-  unionWith,
   uniq,
   uniqBy,
   uniqWith,