@types/lodash 4.14.156 → 4.14.160

lodash/common/common.d.ts

@@ -2,16 +2,26 @@ import _ = require("../index");
 // tslint:disable-next-line:strict-export-declare-modifiers
 type GlobalPartial<T> = Partial<T>;
 declare module "../index" {
-    interface ConvertOptions {
-        cap?: boolean;
-        curry?: boolean;
-        fixed?: boolean;
-        immutable?: boolean;
-        rearg?: boolean;
-    }
-
+    type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
     type PartialObject<T> = GlobalPartial<T>;
     type Many<T> = T | ReadonlyArray<T>;
+    type ImpChain<T> =
+        T extends { __trapAny: any } ? Collection<any> & Function<any> & Object<any> & Primitive<any> & String :
+        T extends null | undefined ? never :
+        T extends string | null | undefined ? String :
+        T extends (...args: any) => any ? Function<T> :
+        T extends List<infer U> | null | undefined ? Collection<U> :
+        T extends object | null | undefined ? Object<T> :
+        Primitive<T>;
+    type ExpChain<T> =
+        T extends { __trapAny: any } ? CollectionChain<any> & FunctionChain<any> & ObjectChain<any> & PrimitiveChain<any> & StringChain :
+        T extends null | undefined ? never :
+        T extends string ? StringChain :
+        T extends string | null | undefined ? StringNullableChain :
+        T extends (...args: any) => any ? FunctionChain<T> :
+        T extends List<infer U> | null | undefined ? CollectionChain<U> :
+        T extends object | null | undefined ? ObjectChain<T> :
+        PrimitiveChain<T>;
     interface LoDashStatic {
         /**
         * Creates a lodash object which wraps value to enable implicit method chain sequences.
@@ -81,20 +91,23 @@ declare module "../index" {
         * toString, toUpper, trim, trimEnd, trimStart, truncate, unescape, uniqueId, upperCase,
         * upperFirst, value, and words.
         **/
-        <T>(value: T): LoDashImplicitWrapper<T>;
-
+        <TrapAny extends { __trapAny: any }>(value: TrapAny): Collection<any> & Function<any> & Object<any> & Primitive<any> & String;
+        <T extends null | undefined>(value: T): Primitive<T>;
+        (value: string | null | undefined): String;
+        <T extends (...args: any) => any>(value: T): Function<T>;
+        <T = any>(value: List<T> | null | undefined): Collection<T>;
+        <T extends object>(value: T | null | undefined): Object<T>;
+        <T>(value: T): Primitive<T>;
         /**
         * The semantic version number.
         **/
         VERSION: string;
-
         /**
         * By default, the template delimiters used by Lo-Dash are similar to those in embedded Ruby
         * (ERB). Change the following template settings to use alternative delimiters.
         **/
         templateSettings: TemplateSettings;
     }
-
     /**
     * By default, the template delimiters used by Lo-Dash are similar to those in embedded Ruby
     * (ERB). Change the following template settings to use alternative delimiters.
@@ -104,28 +117,23 @@ declare module "../index" {
         * The "escape" delimiter.
         **/
         escape?: RegExp;
-
         /**
         * The "evaluate" delimiter.
         **/
         evaluate?: RegExp;
-
         /**
         * An object to import into the template as local variables.
-        **/
+        */
         imports?: Dictionary<any>;
-
         /**
         * The "interpolate" delimiter.
-        **/
+        */
         interpolate?: RegExp;
-
         /**
         * Used to reference the data object in the template text.
-        **/
+        */
         variable?: string;
     }
-
     /**
      * Creates a cache object to store key/value pairs.
      */
@@ -136,21 +144,18 @@ declare module "../index" {
          * @return Returns `true` if the entry was removed successfully, else `false`.
          */
         delete(key: any): boolean;
-
         /**
          * Gets the cached value for `key`.
          * @param key The key of the value to get.
          * @return Returns the cached value.
          */
         get(key: any): any;
-
         /**
          * Checks if a cached value for `key` exists.
          * @param key The key of the entry to check.
          * @return Returns `true` if an entry for `key` exists, else `false`.
          */
         has(key: any): boolean;
-
         /**
          * Sets `value` to `key` of the cache.
          * @param key The key of the value to cache.
@@ -158,7 +163,6 @@ declare module "../index" {
          * @return Returns the cache object.
          */
         set(key: any, value: any): this;
-
         /**
          * Removes all key-value entries from the map.
          */
@@ -167,55 +171,68 @@ declare module "../index" {
     interface MapCacheConstructor {
         new (): MapCache;
     }
-
-    interface LoDashImplicitWrapper<TValue> extends LoDashWrapper<TValue> {
-        pop<T>(this: LoDashImplicitWrapper<List<T> | null | undefined>): T | undefined;
-        push<T>(this: LoDashImplicitWrapper<List<T> | null | undefined>, ...items: T[]): this;
-        shift<T>(this: LoDashImplicitWrapper<List<T> | null | undefined>): T | undefined;
-        sort<T>(this: LoDashImplicitWrapper<List<T> | null | undefined>, compareFn?: (a: T, b: T) => number): this;
-        splice<T>(this: LoDashImplicitWrapper<List<T> | null | undefined>, start: number, deleteCount?: number, ...items: T[]): this;
-        unshift<T>(this: LoDashImplicitWrapper<List<T> | null | undefined>, ...items: T[]): this;
+    interface Collection<T> {
+        pop(): T | undefined;
+        push(...items: T[]): this;
+        shift(): T | undefined;
+        sort(compareFn?: (a: T, b: T) => number): this;
+        splice(start: number, deleteCount?: number, ...items: T[]): this;
+        unshift(...items: T[]): this;
+    }
+    interface CollectionChain<T> {
+        pop(): ExpChain<T | undefined>;
+        push(...items: T[]): this;
+        shift(): ExpChain<T | undefined>;
+        sort(compareFn?: (a: T, b: T) => number): this;
+        splice(start: number, deleteCount?: number, ...items: T[]): this;
+        unshift(...items: T[]): this;
+    }
+    interface Function<T extends (...args: any) => any> extends LoDashImplicitWrapper<T> {
+    }
+    interface String extends LoDashImplicitWrapper<string> {
+    }
+    interface Object<T> extends LoDashImplicitWrapper<T> {
+    }
+    interface Collection<T> extends LoDashImplicitWrapper<T[]> {
+    }
+    interface Primitive<T> extends LoDashImplicitWrapper<T> {
+    }
+    interface FunctionChain<T extends (...args: any) => any> extends LoDashExplicitWrapper<T> {
+    }
+    interface StringChain extends LoDashExplicitWrapper<string> {
+    }
+    interface StringNullableChain extends LoDashExplicitWrapper<string | undefined> {
+    }
+    interface ObjectChain<T> extends LoDashExplicitWrapper<T> {
+    }
+    interface CollectionChain<T> extends LoDashExplicitWrapper<T[]> {
     }
-
-    interface LoDashExplicitWrapper<TValue> extends LoDashWrapper<TValue> {
-        pop<T>(this: LoDashExplicitWrapper<List<T> | null | undefined>): LoDashExplicitWrapper<T | undefined>;
-        push<T>(this: LoDashExplicitWrapper<List<T> | null | undefined>, ...items: T[]): this;
-        shift<T>(this: LoDashExplicitWrapper<List<T> | null | undefined>): LoDashExplicitWrapper<T | undefined>;
-        sort<T>(this: LoDashExplicitWrapper<List<T> | null | undefined>, compareFn?: (a: T, b: T) => number): this;
-        splice<T>(this: LoDashExplicitWrapper<List<T> | null | undefined>, start: number, deleteCount?: number, ...items: T[]): this;
-        unshift<T>(this: LoDashExplicitWrapper<List<T> | null | undefined>, ...items: T[]): this;
+    interface PrimitiveChain<T> extends LoDashExplicitWrapper<T> {
     }
-
-    type NotVoid = {} | null | undefined;
-    type IterateeShorthand<T> = PropertyName | [PropertyName, any] | PartialDeep<T>;
+    type NotVoid = unknown;
+    type IterateeShorthand<T> = PropertyName | [PropertyName, any] | PartialShallow<T>;
     type ArrayIterator<T, TResult> = (value: T, index: number, collection: T[]) => TResult;
     type ListIterator<T, TResult> = (value: T, index: number, collection: List<T>) => TResult;
     type ListIteratee<T> = ListIterator<T, NotVoid> | IterateeShorthand<T>;
     type ListIterateeCustom<T, TResult> = ListIterator<T, TResult> | IterateeShorthand<T>;
     type ListIteratorTypeGuard<T, S extends T> = (value: T, index: number, collection: List<T>) => value is S;
-
     // Note: key should be string, not keyof T, because the actual object may contain extra properties that were not specified in the type.
     type ObjectIterator<TObject, TResult> = (value: TObject[keyof TObject], key: string, collection: TObject) => TResult;
     type ObjectIteratee<TObject> = ObjectIterator<TObject, NotVoid> | IterateeShorthand<TObject[keyof TObject]>;
     type ObjectIterateeCustom<TObject, TResult> = ObjectIterator<TObject, TResult> | IterateeShorthand<TObject[keyof TObject]>;
     type ObjectIteratorTypeGuard<TObject, S extends TObject[keyof TObject]> = (value: TObject[keyof TObject], key: string, collection: TObject) => value is S;
-
     type StringIterator<TResult> = (char: string, index: number, string: string) => TResult;
-
     /** @deprecated Use MemoVoidArrayIterator or MemoVoidDictionaryIterator instead. */
     type MemoVoidIterator<T, TResult> = (prev: TResult, curr: T, indexOrKey: any, list: T[]) => void;
-
     /** @deprecated Use MemoListIterator or MemoObjectIterator instead. */
     type MemoIterator<T, TResult> = (prev: TResult, curr: T, indexOrKey: any, list: T[]) => TResult;
     type MemoListIterator<T, TResult, TList> = (prev: TResult, curr: T, index: number, list: TList) => TResult;
     type MemoObjectIterator<T, TResult, TList> = (prev: TResult, curr: T, key: string, list: TList) => TResult;
     type MemoIteratorCapped<T, TResult> = (prev: TResult, curr: T) => TResult;
     type MemoIteratorCappedRight<T, TResult> = (curr: T, prev: TResult) => TResult;
-
     type MemoVoidArrayIterator<T, TResult> = (acc: TResult, curr: T, index: number, arr: T[]) => void;
     type MemoVoidDictionaryIterator<T, TResult> = (acc: TResult, curr: T, key: string, dict: Dictionary<T>) => void;
     type MemoVoidIteratorCapped<T, TResult> = (acc: TResult, curr: T) => void;
-
     type ValueIteratee<T> = ((value: T) => NotVoid) | IterateeShorthand<T>;
     type ValueIterateeCustom<T, TResult> = ((value: T) => TResult) | IterateeShorthand<T>;
     type ValueIteratorTypeGuard<T, S extends T> = (value: T) => value is S;
@@ -223,37 +240,27 @@ declare module "../index" {
     type ValueKeyIterateeTypeGuard<T, S extends T> = (value: T, key: string) => value is S;
     type Comparator<T> = (a: T, b: T) => boolean;
     type Comparator2<T1, T2> = (a: T1, b: T2) => boolean;
-
     type PropertyName = string | number | symbol;
     type PropertyPath = Many<PropertyName>;
-
-    type Omit<T, K extends keyof T> = Pick<T, ({ [P in keyof T]: P } & { [P in K]: never } & { [x: string]: never })[keyof T]>;
-
     /** Common interface between Arrays and jQuery objects */
     type List<T> = ArrayLike<T>;
-
     interface Dictionary<T> {
         [index: string]: T;
     }
-
     interface NumericDictionary<T> {
         [index: number]: T;
     }
-
     // Crazy typedef needed get _.omit to work properly with Dictionary and NumericDictionary
     type AnyKindOfDictionary =
-        | Dictionary<{} | null | undefined>
-        | NumericDictionary<{} | null | undefined>;
-
+        | Dictionary<unknown>
+        | NumericDictionary<unknown>;
     interface Cancelable {
         cancel(): void;
         flush(): void;
     }
-
-    type PartialDeep<T> = {
-        [P in keyof T]?: PartialDeep<T[P]>;
+    type PartialShallow<T> = {
+        [P in keyof T]?: T[P] extends object ? object : T[P]
     };
-
     // For backwards compatibility
     type LoDashImplicitArrayWrapper<T> = LoDashImplicitWrapper<T[]>;
     type LoDashImplicitNillableArrayWrapper<T> = LoDashImplicitWrapper<T[] | null | undefined>;
@@ -267,7 +274,6 @@ declare module "../index" {
     type LoDashExplicitNillableObjectWrapper<T> = LoDashExplicitWrapper<T | null | undefined>;
     type LoDashExplicitNumberArrayWrapper = LoDashExplicitWrapper<number[]>;
     type LoDashExplicitStringWrapper = LoDashExplicitWrapper<string>;
-
     type DictionaryIterator<T, TResult> = ObjectIterator<Dictionary<T>, TResult>;
     type DictionaryIteratee<T> = ObjectIteratee<Dictionary<T>>;
     type DictionaryIteratorTypeGuard<T, S extends T> = ObjectIteratorTypeGuard<Dictionary<T>, S>;

lodash/common/date.d.ts

@@ -1,27 +1,23 @@
 import _ = require("../index");
 declare module "../index" {
-    // now
-
     interface LoDashStatic {
-        /**
+        /*
          * Gets the number of milliseconds that have elapsed since the Unix epoch (1 January 1970 00:00:00 UTC).
          *
          * @return The number of milliseconds.
          */
         now(): number;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.now
          */
         now(): number;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.now
          */
-        now(): LoDashExplicitWrapper<number>;
+        now(): PrimitiveChain<number>;
     }
 }