@types/lodash
Version:
TypeScript definitions for Lo-Dash
1,621 lines (1,438 loc) • 582 kB
TypeScript
// Type definitions for Lo-Dash 4.14
// Project: http://lodash.com/
// Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>, Eric L Anderson <https://github.com/ericanderson>, AJ Richardson <https://github.com/aj-r>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.2
/**
### 4.0.0 Changelog (https://github.com/lodash/lodash/wiki/Changelog)
#### TODO:
removed:
- [x] Removed _.support
- [x] Removed _.findWhere in favor of _.find with iteratee shorthand
- [x] Removed _.where in favor of _.filter with iteratee shorthand
- [x] Removed _.pluck in favor of _.map with iteratee shorthand
renamed:
- [x] Renamed _.first to _.head
- [x] Renamed _.indexBy to _.keyBy
- [x] Renamed _.invoke to _.invokeMap
- [x] Renamed _.overArgs to _.overArgs
- [x] Renamed _.padLeft & _.padRight to _.padStart & _.padEnd
- [x] Renamed _.pairs to _.toPairs
- [x] Renamed _.rest to _.tail
- [x] Renamed _.restParam to _.rest
- [x] Renamed _.sortByOrder to _.orderBy
- [x] Renamed _.trimLeft & _.trimRight to _.trimStart & _.trimEnd
- [x] Renamed _.trunc to _.truncate
split:
- [x] Split _.indexOf & _.lastIndexOf into _.sortedIndexOf & _.sortedLastIndexOf
- [x] Split _.max & _.min into _.maxBy & _.minBy
- [x] Split _.omit & _.pick into _.omitBy & _.pickBy
- [x] Split _.sample into _.sampleSize
- [x] Split _.sortedIndex into _.sortedIndexBy
- [x] Split _.sortedLastIndex into _.sortedLastIndexBy
- [x] Split _.uniq into _.sortedUniq, _.sortedUniqBy, & _.uniqBy
changes:
- [x] Absorbed _.sortByAll into _.sortBy
- [x] Changed the category of _.at to “Object”
- [x] Changed the category of _.bindAll to “Utility”
- [x] Made _.capitalize uppercase the first character & lowercase the rest
- [x] Made _.functions return only own method names
added 23 array methods:
- [x] _.concat
- [x] _.differenceBy
- [x] _.differenceWith
- [x] _.flatMap
- [x] _.fromPairs
- [x] _.intersectionBy
- [x] _.intersectionWith
- [x] _.join
- [x] _.pullAll
- [x] _.pullAllBy
- [x] _.reverse
- [x] _.sortedIndexBy
- [x] _.sortedIndexOf
- [x] _.sortedLastIndexBy
- [x] _.sortedLastIndexOf
- [x] _.sortedUniq
- [x] _.sortedUniqBy
- [x] _.unionBy
- [x] _.unionWith
- [x] _.uniqBy
- [x] _.uniqWith
- [x] _.xorBy
- [x] _.xorWith
added 20 lang methods:
- [x] _.cloneDeepWith
- [x] _.cloneWith
- [x] _.eq
- [x] _.isArrayLike
- [x] _.isArrayLikeObject
- [x] _.isEqualWith
- [x] _.isInteger
- [x] _.isLength
- [x] _.isMatchWith
- [x] _.isNil
- [x] _.isObjectLike
- [x] _.isSafeInteger
- [x] _.isSymbol
- [x] _.toInteger
- [x] _.toLength
- [x] _.toNumber
- [x] _.toSafeInteger
- [x] _.toString
- [X] _.conforms
- [X] _.conformsTo
added 13 object methods:
- [x] _.assignIn
- [x] _.assignInWith
- [x] _.assignWith
- [x] _.functionsIn
- [x] _.hasIn
- [x] _.mergeWith
- [x] _.omitBy
- [x] _.pickBy
added 8 string methods:
- [x] _.lowerCase
- [x] _.lowerFirst
- [x] _.upperCase
- [x] _.upperFirst
- [x] _.toLower
- [x] _.toUpper
added 8 utility methods:
- [x] _.toPath
added 4 math methods:
- [x] _.maxBy
- [x] _.mean
- [x] _.minBy
- [x] _.sumBy
added 2 function methods:
- [x] _.flip
- [x] _.unary
added 2 number methods:
- [x] _.clamp
- [x] _.subtract
added collection method:
- [x] _.sampleSize
Added 3 aliases
- [x] _.first as an alias of _.head
Removed 17 aliases
- [x] Removed aliase _.all
- [x] Removed aliase _.any
- [x] Removed aliase _.backflow
- [x] Removed aliase _.callback
- [x] Removed aliase _.collect
- [x] Removed aliase _.compose
- [x] Removed aliase _.contains
- [x] Removed aliase _.detect
- [x] Removed aliase _.foldl
- [x] Removed aliase _.foldr
- [x] Removed aliase _.include
- [x] Removed aliase _.inject
- [x] Removed aliase _.methods
- [x] Removed aliase _.object
- [x] Removed aliase _.run
- [x] Removed aliase _.select
- [x] Removed aliase _.unique
Other changes
- [x] Added support for array buffers to _.isEqual
- [x] Added support for converting iterators to _.toArray
- [x] Added support for deep paths to _.zipObject
- [x] Changed UMD to export to window or self when available regardless of other exports
- [x] Ensured debounce cancel clears args & thisArg references
- [x] Ensured _.add, _.subtract, & _.sum don’t skip NaN values
- [x] Ensured _.clone treats generators like functions
- [x] Ensured _.clone produces clones with the source’s [[Prototype]]
- [x] Ensured _.defaults assigns properties that shadow Object.prototype
- [x] Ensured _.defaultsDeep doesn’t merge a string into an array
- [x] Ensured _.defaultsDeep & _.merge don’t modify sources
- [x] Ensured _.defaultsDeep works with circular references
- [x] Ensured _.keys skips “length” on strict mode arguments objects in Safari 9
- [x] Ensured _.merge doesn’t convert strings to arrays
- [x] Ensured _.merge merges plain-objects onto non plain-objects
- [x] Ensured _#plant resets iterator data of cloned sequences
- [x] Ensured _.random swaps min & max if min is greater than max
- [x] Ensured _.range preserves the sign of start of -0
- [x] Ensured _.reduce & _.reduceRight use getIteratee in their array branch
- [x] Fixed rounding issue with the precision param of _.floor
- [x] Added flush method to debounced & throttled functions
** LATER **
Misc:
- [ ] Made _.forEach, _.forIn, _.forOwn, & _.times implicitly end a chain sequence
- [ ] Removed thisArg params from most methods
- [ ] Made “By” methods provide a single param to iteratees
- [ ] Made _.words chainable by default
- [ ] Removed isDeep params from _.clone & _.flatten
- [ ] Removed _.bindAll support for binding all methods when no names are provided
- [ ] Removed func-first param signature from _.before & _.after
- [ ] _.extend as an alias of _.assignIn
- [ ] _.extendWith as an alias of _.assignInWith
- [ ] Added clear method to _.memoize.Cache
- [ ] Added support for ES6 maps, sets, & symbols to _.clone, _.isEqual, & _.toArray
- [x] Enabled _.flow & _.flowRight to accept an array of functions
- [ ] Ensured “Collection” methods treat functions as objects
- [ ] Ensured _.assign, _.defaults, & _.merge coerce object values to objects
- [ ] Ensured _.bindKey bound functions call object[key] when called with the new operator
- [ ] Ensured _.isFunction returns true for generator functions
- [ ] Ensured _.merge assigns typed arrays directly
- [ ] Made _(...) an iterator & iterable
- [ ] Made _.drop, _.take, & right forms coerce n of undefined to 0
Methods:
- [ ] _.concat
- [ ] _.differenceBy
- [ ] _.differenceWith
- [ ] _.flatMap
- [ ] _.fromPairs
- [ ] _.intersectionBy
- [ ] _.intersectionWith
- [ ] _.join
- [ ] _.pullAll
- [ ] _.pullAllBy
- [ ] _.reverse
- [ ] _.sortedLastIndexOf
- [ ] _.unionBy
- [ ] _.unionWith
- [ ] _.uniqWith
- [ ] _.xorBy
- [ ] _.xorWith
- [ ] _.toString
- [ ] _.invoke
- [ ] _.setWith
- [ ] _.toPairs
- [ ] _.toPairsIn
- [ ] _.unset
- [ ] _.replace
- [ ] _.split
- [ ] _.cond
- [ ] _.nthArg
- [ ] _.over
- [ ] _.overEvery
- [ ] _.overSome
- [ ] _.rangeRight
- [ ] _.next
*/
export = _;
export as namespace _;
declare var _: _.LoDashStatic;
type PartialObject<T> = Partial<T>;
declare namespace _ {
type Many<T> = T | T[];
interface LoDashStatic {
/**
* Creates a lodash object which wraps the given value to enable intuitive method chaining.
*
* In addition to Lo-Dash methods, wrappers also have the following Array methods:
* concat, join, pop, push, reverse, shift, slice, sort, splice, and unshift
*
* Chaining is supported in custom builds as long as the value method is implicitly or
* explicitly included in the build.
*
* The chainable wrapper functions are:
* after, assign, bind, bindAll, bindKey, chain, chunk, compact, compose, concat, countBy,
* createCallback, curry, debounce, defaults, defer, delay, difference, filter, flatten,
* forEach, forEachRight, forIn, forInRight, forOwn, forOwnRight, functions, groupBy,
* keyBy, initial, intersection, invert, invoke, keys, map, max, memoize, merge, min,
* object, omit, once, pairs, partial, partialRight, pick, pluck, pull, push, range, reject,
* remove, rest, reverse, sample, shuffle, slice, sort, sortBy, splice, tap, throttle, times,
* toArray, transform, union, uniq, unset, unshift, unzip, values, where, without, wrap, and zip
*
* The non-chainable wrapper functions are:
* clone, cloneDeep, contains, escape, every, find, findIndex, findKey, findLast,
* findLastIndex, findLastKey, has, identity, indexOf, isArguments, isArray, isBoolean,
* isDate, isElement, isEmpty, isEqual, isFinite, isFunction, isNaN, isNull, isNumber,
* isObject, isPlainObject, isRegExp, isString, isUndefined, join, lastIndexOf, mixin,
* noConflict, parseInt, pop, random, reduce, reduceRight, result, shift, size, some,
* sortedIndex, runInContext, template, unescape, uniqueId, and value
*
* The wrapper functions first and last return wrapped values when n is provided, otherwise
* they return unwrapped values.
*
* Explicit chaining can be enabled by using the _.chain method.
**/
(value: number): LoDashImplicitWrapper<number>;
(value: string): LoDashImplicitStringWrapper;
(value: boolean): LoDashImplicitWrapper<boolean>;
(value: null | undefined): LoDashImplicitWrapper<null | undefined>;
(value: number[]): LoDashImplicitNumberArrayWrapper;
<T>(value: T[]): LoDashImplicitArrayWrapper<T>;
<T>(value: T[] | null | undefined): LoDashImplicitNillableArrayWrapper<T>;
<T extends {}>(value: T): LoDashImplicitObjectWrapper<T>;
<T extends {}>(value: T | null | undefined): LoDashImplicitNillableObjectWrapper<T>;
(value: any): LoDashImplicitWrapper<any>;
/**
* 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.
**/
interface TemplateSettings {
/**
* 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.
*/
interface MapCache {
/**
* Removes `key` and its value from the cache.
* @param key The key of the value to remove.
* @return Returns `true` if the entry was removed successfully, else `false`.
*/
delete(key: string): boolean;
/**
* Gets the cached value for `key`.
* @param key The key of the value to get.
* @return Returns the cached value.
*/
get(key: string): 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: string): boolean;
/**
* Sets `value` to `key` of the cache.
* @param key The key of the value to cache.
* @param value The value to cache.
* @return Returns the cache object.
*/
set(key: string, value: any): _.Dictionary<any>;
}
interface MapCacheConstructor {
new (): MapCache;
}
interface LoDashWrapperBase<T, TWrapper> { }
interface LoDashImplicitWrapperBase<T, TWrapper> extends LoDashWrapperBase<T, TWrapper> { }
interface LoDashExplicitWrapperBase<T, TWrapper> extends LoDashWrapperBase<T, TWrapper> { }
interface LoDashImplicitWrapper<T> extends LoDashImplicitWrapperBase<T, LoDashImplicitWrapper<T>> { }
interface LoDashExplicitWrapper<T> extends LoDashExplicitWrapperBase<T, LoDashExplicitWrapper<T>> { }
interface LoDashImplicitStringWrapper extends LoDashImplicitWrapper<string> { }
interface LoDashExplicitStringWrapper extends LoDashExplicitWrapper<string> { }
interface LoDashImplicitObjectWrapperBase<T, TObject extends T | null | undefined, TWrapper> extends LoDashImplicitWrapperBase<TObject, TWrapper> { }
interface LoDashImplicitObjectWrapper<T> extends LoDashImplicitObjectWrapperBase<T, T, LoDashImplicitObjectWrapper<T>> { }
interface LoDashImplicitNillableObjectWrapper<T> extends LoDashImplicitObjectWrapperBase<T, T | null | undefined, LoDashImplicitNillableObjectWrapper<T>> { }
interface LoDashExplicitObjectWrapperBase<T, TObject extends T | null | undefined, TWrapper> extends LoDashExplicitWrapperBase<TObject, TWrapper> { }
interface LoDashExplicitObjectWrapper<T> extends LoDashExplicitObjectWrapperBase<T, T, LoDashExplicitObjectWrapper<T>> { }
interface LoDashExplicitNillableObjectWrapper<T> extends LoDashExplicitObjectWrapperBase<T, T | null | undefined, LoDashExplicitNillableObjectWrapper<T>> { }
interface LoDashImplicitArrayWrapperBase<T, TArray extends T[] | null | undefined, TWrapper> extends LoDashImplicitWrapperBase<TArray, TWrapper> {
pop(): T | undefined;
push(...items: T[]): TWrapper;
shift(): T | undefined;
sort(compareFn?: (a: T, b: T) => number): TWrapper;
splice(start: number): TWrapper;
splice(start: number, deleteCount: number, ...items: T[]): TWrapper;
unshift(...items: T[]): TWrapper;
}
interface LoDashImplicitArrayWrapper<T> extends LoDashImplicitArrayWrapperBase<T, T[], LoDashImplicitArrayWrapper<T>> { }
interface LoDashImplicitNillableArrayWrapper<T> extends LoDashImplicitArrayWrapperBase<T, T[] | null | undefined, LoDashImplicitNillableArrayWrapper<T>> { }
interface LoDashImplicitNumberArrayWrapperBase<TArray extends number[] | null | undefined, TWrapper> extends LoDashImplicitArrayWrapperBase<number, TArray, TWrapper> { }
interface LoDashImplicitNumberArrayWrapper extends LoDashImplicitArrayWrapper<number> { }
interface LoDashExplicitArrayWrapperBase<T, TArray extends T[] | null | undefined, TWrapper> extends LoDashExplicitWrapperBase<TArray, TWrapper> {
pop(): LoDashExplicitObjectWrapper<T | undefined>;
push(...items: T[]): TWrapper;
shift(): LoDashExplicitObjectWrapper<T | undefined>;
sort(compareFn?: (a: T, b: T) => number): TWrapper;
splice(start: number): TWrapper;
splice(start: number, deleteCount: number, ...items: T[]): TWrapper;
unshift(...items: T[]): TWrapper;
}
interface LoDashExplicitArrayWrapper<T> extends LoDashExplicitArrayWrapperBase<T, T[], LoDashExplicitArrayWrapper<T>> { }
interface LoDashExplicitNillableArrayWrapper<T> extends LoDashExplicitArrayWrapperBase<T, T[] | null | undefined, LoDashExplicitNillableArrayWrapper<T>> { }
interface LoDashExplicitNumberArrayWrapper extends LoDashExplicitArrayWrapper<number> { }
/*********
* Array *
*********/
//_.chunk
interface LoDashStatic {
/**
* Creates an array of elements split into groups the length of size. If collection can’t be split evenly, the
* final chunk will be the remaining elements.
*
* @param array The array to process.
* @param size The length of each chunk.
* @return Returns the new array containing chunks.
*/
chunk<T>(
array: List<T> | null | undefined,
size?: number
): T[][];
}
interface LoDashImplicitArrayWrapperBase<T, TArray extends T[] | null | undefined, TWrapper> {
/**
* @see _.chunk
*/
chunk(size?: number): LoDashImplicitArrayWrapper<T[]>;
}
interface LoDashImplicitObjectWrapperBase<T, TObject extends T | null | undefined, TWrapper> {
/**
* @see _.chunk
*/
chunk<TResult>(size?: number): LoDashImplicitArrayWrapper<TResult[]>;
}
interface LoDashExplicitArrayWrapperBase<T, TArray extends T[] | null | undefined, TWrapper> {
/**
* @see _.chunk
*/
chunk(size?: number): LoDashExplicitArrayWrapper<T[]>;
}
interface LoDashExplicitObjectWrapperBase<T, TObject extends T | null | undefined, TWrapper> {
/**
* @see _.chunk
*/
chunk<TResult>(size?: number): LoDashExplicitArrayWrapper<TResult[]>;
}
//_.compact
interface LoDashStatic {
/**
* Creates an array with all falsey values removed. The values false, null, 0, "", undefined, and NaN are
* falsey.
*
* @param array The array to compact.
* @return (Array) Returns the new array of filtered values.
*/
compact<T>(array?: List<T | null | undefined | false | "" | 0> | null | undefined): T[];
}
interface LoDashImplicitArrayWrapperBase<T, TArray extends T[] | null | undefined, TWrapper> {
/**
* @see _.compact
*/
compact(): LoDashImplicitArrayWrapper<T>;
}
interface LoDashImplicitObjectWrapperBase<T, TObject extends T | null | undefined, TWrapper> {
/**
* @see _.compact
*/
compact<TResult>(): LoDashImplicitArrayWrapper<TResult>;
}
interface LoDashExplicitArrayWrapperBase<T, TArray extends T[] | null | undefined, TWrapper> {
/**
* @see _.compact
*/
compact(): LoDashExplicitArrayWrapper<T>;
}
interface LoDashExplicitObjectWrapperBase<T, TObject extends T | null | undefined, TWrapper> {
/**
* @see _.compact
*/
compact<TResult>(): LoDashExplicitArrayWrapper<TResult>;
}
//_.concat DUMMY
interface LoDashStatic {
/**
* Creates a new array concatenating `array` with any additional arrays
* and/or values.
*
* @static
* @memberOf _
* @category Array
* @param {Array} array The array to concatenate.
* @param {...*} [values] The values to concatenate.
* @returns {Array} Returns the new concatenated array.
* @example
*
* var array = [1];
* var other = _.concat(array, 2, [3], [[4]]);
*
* console.log(other);
* // => [1, 2, 3, [4]]
*
* console.log(array);
* // => [1]
*/
concat<T>(array: List<T>, ...values: Array<T|List<T>>): T[];
}
//_.difference
interface LoDashStatic {
/**
* Creates an array of unique array values not included in the other provided arrays using SameValueZero for
* equality comparisons.
*
* @param array The array to inspect.
* @param values The arrays of values to exclude.
* @return Returns the new array of filtered values.
*/
difference<T>(
array: List<T> | null | undefined,
...values: Array<List<T>>
): T[];
}
interface LoDashImplicitArrayWrapperBase<T, TArray extends T[] | null | undefined, TWrapper> {
/**
* @see _.difference
*/
difference(...values: Array<List<T>>): LoDashImplicitArrayWrapper<T>;
}
interface LoDashImplicitObjectWrapperBase<T, TObject extends T | null | undefined, TWrapper> {
/**
* @see _.difference
*/
difference<TValue>(...values: Array<List<TValue>>): LoDashImplicitArrayWrapper<TValue>;
}
interface LoDashExplicitArrayWrapperBase<T, TArray extends T[] | null | undefined, TWrapper> {
/**
* @see _.difference
*/
difference(...values: Array<List<T>>): LoDashExplicitArrayWrapper<T>;
}
interface LoDashExplicitObjectWrapperBase<T, TObject extends T | null | undefined, TWrapper> {
/**
* @see _.difference
*/
difference<TValue>(...values: Array<List<TValue>>): LoDashExplicitArrayWrapper<TValue>;
}
//_.differenceBy
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).
*
* @param array The array to inspect.
* @param values The values to exclude.
* @param iteratee The iteratee invoked per element.
* @returns Returns the new array of filtered values.
*/
differenceBy<T>(
array: List<T> | null | undefined,
values?: List<T>,
iteratee?: ((value: T) => any)|string
): T[];
/**
* @see _.differenceBy
*/
differenceBy<T, W extends Object>(
array: List<T> | null | undefined,
values?: List<T>,
iteratee?: W
): T[];
/**
* @see _.differenceBy
*/
differenceBy<T>(
array: List<T> | null | undefined,
values1?: List<T>,
values2?: List<T>,
iteratee?: ((value: T) => any)|string
): T[];
/**
* @see _.differenceBy
*/
differenceBy<T, W extends Object>(
array: List<T> | null | undefined,
values1?: List<T>,
values2?: List<T>,
iteratee?: W
): T[];
/**
* @see _.differenceBy
*/
differenceBy<T>(
array: List<T> | null | undefined,
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
iteratee?: ((value: T) => any)|string
): T[];
/**
* @see _.differenceBy
*/
differenceBy<T, W extends Object>(
array: List<T> | null | undefined,
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
iteratee?: W
): T[];
/**
* @see _.differenceBy
*/
differenceBy<T, W extends Object>(
array: List<T> | null | undefined,
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
values4?: List<T>,
iteratee?: W
): T[];
/**
* @see _.differenceBy
*/
differenceBy<T>(
array: List<T> | null | undefined,
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
values4?: List<T>,
iteratee?: ((value: T) => any)|string
): T[];
/**
* @see _.differenceBy
*/
differenceBy<T>(
array: List<T> | null | undefined,
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
values4?: List<T>,
values5?: List<T>,
iteratee?: ((value: T) => any)|string
): T[];
/**
* @see _.differenceBy
*/
differenceBy<T, W extends Object>(
array: List<T> | null | undefined,
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
values4?: List<T>,
values5?: List<T>,
iteratee?: W
): T[];
/**
* @see _.differenceBy
*/
differenceBy<T>(
array: List<T> | null | undefined,
...values: any[]
): T[];
}
interface LoDashImplicitArrayWrapperBase<T, TArray extends T[] | null | undefined, TWrapper> {
/**
* @see _.differenceBy
*/
differenceBy<T>(
values?: List<T>,
iteratee?: ((value: T) => any)|string
): LoDashImplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T, W extends Object>(
values?: List<T>,
iteratee?: W
): LoDashImplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T>(
values1?: List<T>,
values2?: List<T>,
iteratee?: ((value: T) => any)|string
): LoDashImplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T, W extends Object>(
values1?: List<T>,
values2?: List<T>,
iteratee?: W
): LoDashImplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T>(
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
iteratee?: ((value: T) => any)|string
): LoDashImplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T, W extends Object>(
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
iteratee?: W
): LoDashImplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T>(
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
values4?: List<T>,
iteratee?: ((value: T) => any)|string
): LoDashImplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T, W extends Object>(
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
values4?: List<T>,
iteratee?: W
): LoDashImplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T>(
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
values4?: List<T>,
values5?: List<T>,
iteratee?: ((value: T) => any)|string
): LoDashImplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T, W extends Object>(
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
values4?: List<T>,
values5?: List<T>,
iteratee?: W
): LoDashImplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T>(
...values: any[]
): LoDashImplicitArrayWrapper<T>;
}
interface LoDashImplicitObjectWrapperBase<T, TObject extends T | null | undefined, TWrapper> {
/**
* @see _.differenceBy
*/
differenceBy<T>(
values?: List<T>,
iteratee?: ((value: T) => any)|string
): LoDashImplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T, W extends Object>(
values?: List<T>,
iteratee?: W
): LoDashImplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T>(
values1?: List<T>,
values2?: List<T>,
iteratee?: ((value: T) => any)|string
): LoDashImplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T, W extends Object>(
values1?: List<T>,
values2?: List<T>,
iteratee?: W
): LoDashImplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T>(
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
iteratee?: ((value: T) => any)|string
): LoDashImplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T, W extends Object>(
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
iteratee?: W
): LoDashImplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T>(
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
values4?: List<T>,
iteratee?: ((value: T) => any)|string
): LoDashImplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T, W extends Object>(
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
values4?: List<T>,
iteratee?: W
): LoDashImplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T>(
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
values4?: List<T>,
values5?: List<T>,
iteratee?: ((value: T) => any)|string
): LoDashImplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T, W extends Object>(
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
values4?: List<T>,
values5?: List<T>,
iteratee?: W
): LoDashImplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T>(
...values: any[]
): LoDashImplicitArrayWrapper<T>;
}
interface LoDashExplicitArrayWrapperBase<T, TArray extends T[] | null | undefined, TWrapper> {
/**
* @see _.differenceBy
*/
differenceBy<T>(
values?: List<T>,
iteratee?: ((value: T) => any)|string
): LoDashExplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T, W extends Object>(
values?: List<T>,
iteratee?: W
): LoDashExplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T>(
values1?: List<T>,
values2?: List<T>,
iteratee?: ((value: T) => any)|string
): LoDashExplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T, W extends Object>(
values1?: List<T>,
values2?: List<T>,
iteratee?: W
): LoDashExplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T>(
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
iteratee?: ((value: T) => any)|string
): LoDashExplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T, W extends Object>(
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
iteratee?: W
): LoDashExplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T>(
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
values4?: List<T>,
iteratee?: ((value: T) => any)|string
): LoDashExplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T, W extends Object>(
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
values4?: List<T>,
iteratee?: W
): LoDashExplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T>(
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
values4?: List<T>,
values5?: List<T>,
iteratee?: ((value: T) => any)|string
): LoDashExplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T, W extends Object>(
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
values4?: List<T>,
values5?: List<T>,
iteratee?: W
): LoDashExplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T>(
...values: any[]
): LoDashExplicitArrayWrapper<T>;
}
interface LoDashExplicitObjectWrapperBase<T, TObject extends T | null | undefined, TWrapper> {
/**
* @see _.differenceBy
*/
differenceBy<T>(
values?: List<T>,
iteratee?: ((value: T) => any)|string
): LoDashExplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T, W extends Object>(
values?: List<T>,
iteratee?: W
): LoDashExplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T>(
values1?: List<T>,
values2?: List<T>,
iteratee?: ((value: T) => any)|string
): LoDashExplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T, W extends Object>(
values1?: List<T>,
values2?: List<T>,
iteratee?: W
): LoDashExplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T>(
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
iteratee?: ((value: T) => any)|string
): LoDashExplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T, W extends Object>(
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
iteratee?: W
): LoDashExplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T>(
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
values4?: List<T>,
iteratee?: ((value: T) => any)|string
): LoDashExplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T, W extends Object>(
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
values4?: List<T>,
iteratee?: W
): LoDashExplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T>(
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
values4?: List<T>,
values5?: List<T>,
iteratee?: ((value: T) => any)|string
): LoDashExplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T, W extends Object>(
values1?: List<T>,
values2?: List<T>,
values3?: List<T>,
values4?: List<T>,
values5?: List<T>,
iteratee?: W
): LoDashExplicitArrayWrapper<T>;
/**
* @see _.differenceBy
*/
differenceBy<T>(
...values: any[]
): LoDashExplicitArrayWrapper<T>;
}
//_.differenceWith DUMMY
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.
*
* @static
* @memberOf _
* @category Array
* @param {Array} array The array to inspect.
* @param {...Array} [values] The values to exclude.
* @returns {Array} Returns the new array of filtered values.
* @example
*
* _.difference([3, 2, 1], [4, 2]);
* // => [3, 1]
*/
differenceWith(
array: List<any>,
...values: any[]
): any[];
}
//_.drop
interface LoDashStatic {
/**
* Creates a slice of array with n elements dropped from the beginning.
*
* @param array The array to query.
* @param n The number of elements to drop.
* @return Returns the slice of array.
*/
drop<T>(array: List<T> | null | undefined, n?: number): T[];
}
interface LoDashImplicitArrayWrapperBase<T, TArray extends T[] | null | undefined, TWrapper> {
/**
* @see _.drop
*/
drop(n?: number): LoDashImplicitArrayWrapper<T>;
}
interface LoDashImplicitObjectWrapperBase<T, TObject extends T | null | undefined, TWrapper> {
/**
* @see _.drop
*/
drop<T>(n?: number): LoDashImplicitArrayWrapper<T>;
}
interface LoDashExplicitArrayWrapperBase<T, TArray extends T[] | null | undefined, TWrapper> {
/**
* @see _.drop
*/
drop(n?: number): LoDashExplicitArrayWrapper<T>;
}
interface LoDashExplicitObjectWrapperBase<T, TObject extends T | null | undefined, TWrapper> {
/**
* @see _.drop
*/
drop<T>(n?: number): LoDashExplicitArrayWrapper<T>;
}
//_.dropRight
interface LoDashStatic {
/**
* Creates a slice of array with n elements dropped from the end.
*
* @param array The array to query.
* @param n The number of elements to drop.
* @return Returns the slice of array.
*/
dropRight<T>(
array: List<T> | null | undefined,
n?: number
): T[];
}
interface LoDashImplicitArrayWrapperBase<T, TArray extends T[] | null | undefined, TWrapper> {
/**
* @see _.dropRight
*/
dropRight(n?: number): LoDashImplicitArrayWrapper<T>;
}
interface LoDashImplicitObjectWrapperBase<T, TObject extends T | null | undefined, TWrapper> {
/**
* @see _.dropRight
*/
dropRight<TResult>(n?: number): LoDashImplicitArrayWrapper<TResult>;
}
interface LoDashExplicitArrayWrapperBase<T, TArray extends T[] | null | undefined, TWrapper> {
/**
* @see _.dropRight
*/
dropRight(n?: number): LoDashExplicitArrayWrapper<T>;
}
interface LoDashExplicitObjectWrapperBase<T, TObject extends T | null | undefined, TWrapper> {
/**
* @see _.dropRight
*/
dropRight<TResult>(n?: number): LoDashExplicitArrayWrapper<TResult>;
}
//_.dropRightWhile
interface LoDashStatic {
/**
* Creates a slice of array excluding elements dropped from the end. Elements are dropped until predicate
* returns falsey. The predicate is bound to thisArg and invoked with three arguments: (value, index, array).
*
* If a property name is provided for predicate the created _.property style callback returns the property
* value of the given element.
*
* If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
* elements that have a matching property value, else false.
*
* If an object is provided for predicate the created _.matches style callback returns true for elements that
* match the properties of the given object, else false.
*
* @param array The array to query.
* @param predicate The function invoked per iteration.
* @param thisArg The this binding of predicate.
* @return Returns the slice of array.
*/
dropRightWhile<TValue>(
array: List<TValue> | null | undefined,
predicate?: ListIterator<TValue, boolean>
): TValue[];
/**
* @see _.dropRightWhile
*/
dropRightWhile<TValue>(
array: List<TValue> | null | undefined,
predicate?: string
): TValue[];
/**
* @see _.dropRightWhile
*/
dropRightWhile<TWhere, TValue>(
array: List<TValue> | null | undefined,
predicate?: TWhere
): TValue[];
}
interface LoDashImplicitArrayWrapperBase<T, TArray extends T[] | null | undefined, TWrapper> {
/**
* @see _.dropRightWhile
*/
dropRightWhile(
predicate?: ListIterator<T, boolean>
): LoDashImplicitArrayWrapper<T>;
/**
* @see _.dropRightWhile
*/
dropRightWhile(
predicate?: string
): LoDashImplicitArrayWrapper<T>;
/**
* @see _.dropRightWhile
*/
dropRightWhile<TWhere>(
predicate?: TWhere
): LoDashImplicitArrayWrapper<T>;
}
interface LoDashImplicitObjectWrapperBase<T, TObject extends T | null | undefined, TWrapper> {
/**
* @see _.dropRightWhile
*/
dropRightWhile<TValue>(
predicate?: ListIterator<TValue, boolean>
): LoDashImplicitArrayWrapper<TValue>;
/**
* @see _.dropRightWhile
*/
dropRightWhile<TValue>(
predicate?: string
): LoDashImplicitArrayWrapper<TValue>;
/**
* @see _.dropRightWhile
*/
dropRightWhile<TWhere, TValue>(
predicate?: TWhere
): LoDashImplicitArrayWrapper<TValue>;
}
interface LoDashExplicitArrayWrapperBase<T, TArray extends T[] | null | undefined, TWrapper> {
/**
* @see _.dropRightWhile
*/
dropRightWhile(
predicate?: ListIterator<T, boolean>
): LoDashExplicitArrayWrapper<T>;
/**
* @see _.dropRightWhile
*/
dropRightWhile(
predicate?: string
): LoDashExplicitArrayWrapper<T>;
/**
* @see _.dropRightWhile
*/
dropRightWhile<TWhere>(
predicate?: TWhere
): LoDashExplicitArrayWrapper<T>;
}
interface LoDashExplicitObjectWrapperBase<T, TObject extends T | null | undefined, TWrapper> {
/**
* @see _.dropRightWhile
*/
dropRightWhile<TValue>(
predicate?: ListIterator<TValue, boolean>
): LoDashExplicitArrayWrapper<TValue>;
/**
* @see _.dropRightWhile
*/
dropRightWhile<TValue>(
predicate?: string
): LoDashExplicitArrayWrapper<TValue>;
/**
* @see _.dropRightWhile
*/
dropRightWhile<TWhere, TValue>(
predicate?: TWhere
): LoDashExplicitArrayWrapper<TValue>;
}
//_.dropWhile
interface LoDashStatic {
/**
* Creates a slice of array excluding elements dropped from the beginning. Elements are dropped until predicate
* returns falsey. The predicate is bound to thisArg and invoked with three arguments: (value, index, array).
*
* If a property name is provided for predicate the created _.property style callback returns the property
* value of the given element.
*
* If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
* elements that have a matching property value, else false.
*
* If an object is provided for predicate the created _.matches style callback returns true for elements that
* have the properties of the given object, else false.
*
* @param array The array to query.
* @param predicate The function invoked per iteration.
* @param thisArg The this binding of predicate.
* @return Returns the slice of array.
*/
dropWhile<TValue>(
array: List<TValue> | null | undefined,
predicate?: ListIterator<TValue, boolean>
): TValue[];
/**
* @see _.dropWhile
*/
dropWhile<TValue>(
array: List<TValue> | null | undefined,
predicate?: string
): TValue[];
/**
* @see _.dropWhile
*/
dropWhile<TWhere, TValue>(
array: List<TValue> | null | undefined,
predicate?: TWhere
): TValue[];
}
interface LoDashImplicitArrayWrapperBase<T, TArray extends T[] | null | undefined, TWrapper> {
/**
* @see _.dropWhile
*/
dropWhile(
predicate?: ListIterator<T, boolean>
): LoDashImplicitArrayWrapper<T>;
/**
* @see _.dropWhile
*/
dropWhile(
predicate?: string
): LoDashImplicitArrayWrapper<T>;
/**
* @see _.dropWhile
*/
dropWhile<TWhere>(
predicate?: TWhere
): LoDashImplicitArrayWrapper<T>;
}
interface LoDashImplicitObjectWrapperBase<T, TObject extends T | null | undefined, TWrapper> {
/**
* @see _.dropWhile
*/
dropWhile<TValue>(
predicate?: ListIterator<TValue, boolean>
): LoDashImplicitArrayWrapper<TValue>;
/**
* @see _.dropWhile
*/
dropWhile<TValue>(
predicate?: string
): LoDashImplicitArrayWrapper<TValue>;
/**
* @see _.dropWhile
*/
dropWhile<TWhere, TValue>(
predicate?: TWhere
): LoDashImplicitArrayWrapper<TValue>;
}
interface LoDashExplicitArrayWrapperBase<T, TArray extends T[] | null | undefined, TWrapper> {
/**
* @see _.dropWhile
*/
dropWhile(
predicate?: ListIterator<T, boolean>
): LoDashExplicitArrayWrapper<T>;
/**
* @see _.dropWhile
*/
dropWhile(
predicate?: string
): LoDashExplicitArrayWrapper<T>;
/**
* @see _.dropWhile
*/
dropWhile<TWhere>(
predicate?: TWhere
): LoDashExplicitArrayWrapper<T>;
}
interface LoDashExplicitObjectWrapperBase<T, TObject extends T | null | undefined, TWrapper> {
/**
* @see _.dropWhile
*/
dropWhile<TValue>(
predicate?: ListIterator<TValue, boolean>
): LoDashExplicitArrayWrapper<TValue>;
/**
* @see _.dropWhile
*/
dropWhile<TValue>(
predicate?: string
): LoDashExplicitArrayWrapper<TValue>;
/**
* @see _.dropWhile
*/
dropWhile<TWhere, TValue>(
predicate?: TWhere
): LoDashExplicitArrayWrapper<TValue>;
}
//_.fill
interface LoDashStatic {
/**
* Fills elements of array with value from start up to, but not including, end.
*
* Note: This method mutates array.
*
* @param array The array to fill.
* @param value The value to fill array with.
* @param start The start position.
* @param end The end position.
* @return Returns array.
*/
fill<T>(
array: any[] | null | undefined,
value: T,
start?: number,
end?: number
): T[];
/**
* @see _.fill
*/
fill<T>(
array: List<any> | null | undefined,
value: T,
start?: number,
end?: number
): List<T>;
}
interface LoDashImplicitArrayWrapperBase<T, TArray extends T[] | null | undefined, TWrapper> {
/**
* @see _.fill
*/
fill<T>(
value: T,
start?: number,
end?: number
): LoDashImplicitArrayWrapper<T>;
}
interface LoDashImplicitObjectWrapperBase<T, TObject extends T | null | undefined, TWrapper> {
/**
* @see _.fill
*/
fill<T>(
value: T,
start?: number,
end?: number
): LoDashImplicitObjectWrapper<List<T>>;
}
interface LoDashExplicitArrayWrapperBase<T, TArray extends T[] | null | undefined, TWrapper> {
/**
* @see _.fill
*/
fill<T>(
value: T,
start?: number,
end?: number
): LoDashExplicitArrayWrapper<T>;
}
interface LoDashExplicitObjectWrapperBase<T, TObject extends T | null | undefined, TWrapper> {
/**
* @see _.fill
*/
fill<T>(
value: T,
start?: number,
end?: number
): LoDashExplicitObjectWrapper<List<T>>;
}
//_.findIndex
interface LoDashStatic {
/**
* This method is like _.find except that it returns the index of the first element predicate returns truthy
* for instead of the element itself.
*
* If a property name is provided for predicate the created _.property style callback returns the property
* value of the given element.
*
* If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
* elements that have a matching property value, else false.
*
* If an object is provided for predicate the created _.matches style callback returns true for elements that
* have the properties of the given object, else false.
*
* @param array The array to search.
* @param predicate The function invoked per iteration.
* @param fromIndex The index to search from.