@types/lodash 4.14.177 → 4.14.180

lodash/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for Lo-Dash (https://lodash.com).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/lodash.
 
 ### Additional Details
- * Last updated: Mon, 15 Nov 2021 17:31:57 GMT
+ * Last updated: Mon, 14 Mar 2022 19:31:43 GMT
  * Dependencies: none
  * Global values: `_`
 

lodash/common/array.d.ts

@@ -106,8 +106,8 @@ declare module "../index" {
     }
     interface LoDashStatic {
         /**
-         * Creates an array of unique array values not included in the other provided arrays using SameValueZero for
-         * equality comparisons.
+         * Creates an array of `array` values not included in the other provided arrays using SameValueZero for
+         * equality comparisons. The order and references of result values are determined by the first array.
          *
          * @param array The array to inspect.
          * @param values The arrays of values to exclude.
@@ -129,9 +129,9 @@ declare module "../index" {
     }
     interface LoDashStatic {
         /**
-         * 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 uniqueness is computed. The iteratee is invoked with one
-         * argument: (value).
+         * 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. The iteratee is invoked with one argument: (value).
          *
          * @param array The array to inspect.
          * @param values The values to exclude.
@@ -186,9 +186,9 @@ declare module "../index" {
     }
     interface LoDashStatic {
         /**
-         * Creates an array of unique `array` values not included in the other
-         * provided arrays using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)
-         * for equality comparisons.
+         * 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).
          *
          * @category Array
          * @param [values] The arrays to inspect.

lodash/common/collection.d.ts

@@ -946,53 +946,53 @@ declare module "../index" {
          * @param iteratee The function invoked per iteration.
          * @return Returns the composed aggregate object.
          */
-        groupBy<T>(collection: List<T> | null | undefined, iteratee?: ValueIteratee<T>): Dictionary<[T, ...T[]]>;
+        groupBy<T>(collection: List<T> | null | undefined, iteratee?: ValueIteratee<T>): Dictionary<T[]>;
         /**
          * @see _.groupBy
          */
-        groupBy<T extends object>(collection: T | null | undefined, iteratee?: ValueIteratee<T[keyof T]>): Dictionary<[T[keyof T], ...Array<T[keyof T]>]>;
+        groupBy<T extends object>(collection: T | null | undefined, iteratee?: ValueIteratee<T[keyof T]>): Dictionary<Array<T[keyof T]>>;
     }
     interface String {
         /**
          * @see _.groupBy
          */
-        groupBy(iteratee?: ValueIteratee<string>): Object<Dictionary<[string, ...string[]]>>;
+        groupBy(iteratee?: ValueIteratee<string>): Object<Dictionary<string[]>>;
     }
     interface Collection<T> {
         /**
          * @see _.groupBy
          */
-        groupBy(iteratee?: ValueIteratee<T>): Object<Dictionary<[T, ...T[]]>>;
+        groupBy(iteratee?: ValueIteratee<T>): Object<Dictionary<T[]>>;
     }
     interface Object<T> {
         /**
          * @see _.groupBy
          */
-        groupBy(iteratee?: ValueIteratee<T[keyof T]>): Object<Dictionary<[T[keyof T], ...Array<T[keyof T]>]>>;
+        groupBy(iteratee?: ValueIteratee<T[keyof T]>): Object<Dictionary<Array<T[keyof T]>>>;
     }
     interface StringChain {
         /**
          * @see _.groupBy
          */
-        groupBy(iteratee?: ValueIteratee<string>): ObjectChain<Dictionary<[string, ...string[]]>>;
+        groupBy(iteratee?: ValueIteratee<string>): ObjectChain<Dictionary<string[]>>;
     }
     interface StringNullableChain {
         /**
          * @see _.groupBy
          */
-        groupBy(iteratee?: ValueIteratee<string>): ObjectChain<Dictionary<[string, ...string[]]>>;
+        groupBy(iteratee?: ValueIteratee<string>): ObjectChain<Dictionary<string[]>>;
     }
     interface CollectionChain<T> {
         /**
          * @see _.groupBy
          */
-        groupBy(iteratee?: ValueIteratee<T>): ObjectChain<Dictionary<[T, ...T[]]>>;
+        groupBy(iteratee?: ValueIteratee<T>): ObjectChain<Dictionary<T[]>>;
     }
     interface ObjectChain<T> {
         /**
          * @see _.groupBy
          */
-        groupBy(iteratee?: ValueIteratee<T[keyof T]>): ObjectChain<Dictionary<[T[keyof T], ...Array<T[keyof T]>]>>;
+        groupBy(iteratee?: ValueIteratee<T[keyof T]>): ObjectChain<Dictionary<Array<T[keyof T]>>>;
     }
     interface LoDashStatic {
         /**

lodash/common/lang.d.ts

@@ -220,7 +220,8 @@ declare module "../index" {
          */
         conformsTo(source: ConformsPredicateObject<TValue>): PrimitiveChain<boolean>;
     }
-    type CondPair<T, R> = [(val: T) => boolean, (val: T) => R];
+    type CondPairNullary<R> = [() => boolean, () => R];
+    type CondPairUnary<T, R> = [(val: T) => boolean, (val: T) => R];
     interface LoDashStatic {
         /**
          * Performs a [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)

lodash/common/util.d.ts

@@ -79,7 +79,8 @@ declare module "../index" {
          * func({ 'a': '1', 'b': '2' });
          * // => 'no match'
          */
-        cond<T, R>(pairs: Array<CondPair<T, R>>): (Target: T) => R;
+        cond<R>(pairs: Array<CondPairNullary<R>>): () => R;
+        cond<T, R>(pairs: Array<CondPairUnary<T, R>>): (Target: T) => R;
     }
 
     type ConformsPredicateObject<T> = {

lodash/fp.d.ts

@@ -317,7 +317,10 @@ declare namespace _ {
     }
     type LodashConcat1x1<T> = (values: lodash.Many<T>) => T[];
     type LodashConcat1x2<T> = (array: lodash.Many<T>) => T[];
-    type LodashCond = <T, R>(pairs: Array<lodash.CondPair<T, R>>) => (Target: T) => R;
+    interface LodashCond {
+        <R>(pairs: Array<lodash.CondPairNullary<R>>): () => R;
+        <T, R>(pairs: Array<lodash.CondPairUnary<T, R>>): (Target: T) => R;
+    }
     interface LodashConformsTo {
         <T>(source: lodash.ConformsPredicateObject<T>): LodashConformsTo1x1<T>;
         <T>(source: lodash.__, object: T): LodashConformsTo1x2<T>;
@@ -1593,13 +1596,13 @@ declare namespace _ {
     interface LodashGroupBy {
         <T>(iteratee: lodash.ValueIteratee<T>): LodashGroupBy1x1<T>;
         <T>(iteratee: lodash.__, collection: lodash.List<T> | null | undefined): LodashGroupBy1x2<T>;
-        <T>(iteratee: lodash.ValueIteratee<T>, collection: lodash.List<T> | null | undefined): lodash.Dictionary<[T, ...T[]]>;
+        <T>(iteratee: lodash.ValueIteratee<T>, collection: lodash.List<T> | null | undefined): lodash.Dictionary<T[]>;
         <T extends object>(iteratee: lodash.__, collection: T | null | undefined): LodashGroupBy2x2<T>;
-        <T extends object>(iteratee: lodash.ValueIteratee<T[keyof T]>, collection: T | null | undefined): lodash.Dictionary<[T[keyof T], ...Array<T[keyof T]>]>;
+        <T extends object>(iteratee: lodash.ValueIteratee<T[keyof T]>, collection: T | null | undefined): lodash.Dictionary<Array<T[keyof T]>>;
     }
-    type LodashGroupBy1x1<T> = (collection: lodash.List<T> | object | null | undefined) => lodash.Dictionary<[T, ...T[]]>;
-    type LodashGroupBy1x2<T> = (iteratee: lodash.ValueIteratee<T>) => lodash.Dictionary<[T, ...T[]]>;
-    type LodashGroupBy2x2<T> = (iteratee: lodash.ValueIteratee<T[keyof T]>) => lodash.Dictionary<[T[keyof T], ...Array<T[keyof T]>]>;
+    type LodashGroupBy1x1<T> = (collection: lodash.List<T> | object | null | undefined) => lodash.Dictionary<T[]>;
+    type LodashGroupBy1x2<T> = (iteratee: lodash.ValueIteratee<T>) => lodash.Dictionary<T[]>;
+    type LodashGroupBy2x2<T> = (iteratee: lodash.ValueIteratee<T[keyof T]>) => lodash.Dictionary<Array<T[keyof T]>>;
     interface LodashGt {
         (value: any): LodashGt1x1;
         (value: lodash.__, other: any): LodashGt1x2;

lodash/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/lodash",
-    "version": "4.14.177",
+    "version": "4.14.180",
     "description": "TypeScript definitions for Lo-Dash",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/lodash",
     "license": "MIT",
@@ -60,6 +60,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "62c83f6b673d4d070131f428e31523cd62295c6966c79eada66ab2f7179e9aeb",
-    "typeScriptVersion": "3.7"
+    "typesPublisherContentHash": "866f70e18f129356be318f5ed741df1d7045aed3ba2063f3c44809f9015d1059",
+    "typeScriptVersion": "3.9"
 }