flip/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/FlipsideCrypto/DefinitelyTyped.git synced 2026-02-06 19:07:08 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Make ts3.1 the default for lodash (#46959)

Browse Source 
* Make ts3.1 the default

* trim/reorder tsconfig.json
This commit is contained in:
Nathan Shively-Sanders 2020-08-24 10:15:46 -07:00 committed by GitHub
parent 15da950801
commit dbc59a84fb
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
733 changed files with 6576 additions and 39905 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2642
types/lodash/common/array.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

2929
types/lodash/common/collection.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

134
types/lodash/common/common.d.ts vendored
View File

@ -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 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 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;
}
type NotVoid = {} | null | undefined;
type IterateeShorthand<T> = PropertyName | [PropertyName, any] | PartialDeep<T>;
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 PrimitiveChain<T> extends LoDashExplicitWrapper<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>;

8
types/lodash/common/date.d.ts vendored
View File

@ -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>;
}
}

1630
types/lodash/common/function.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

733
types/lodash/common/lang.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

255
types/lodash/common/math.d.ts vendored
View File

@ -1,7 +1,5 @@
import _ = require("../index");
declare module "../index" {
// add
interface LoDashStatic {
/**
* Adds two numbers.
@ -10,28 +8,21 @@ declare module "../index" {
* @param addend The second number to add.
* @return Returns the sum.
*/
add(
augend: number,
addend: number
): number;
add(augend: number, addend: number): number;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.add
*/
add(addend: number): number;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.add
*/
add(addend: number): LoDashExplicitWrapper<number>;
add(addend: number): PrimitiveChain<number>;
}
// ceil
interface LoDashStatic {
/**
* Calculates n rounded up to precision.
@ -40,58 +31,44 @@ declare module "../index" {
* @param precision The precision to round up to.
* @return Returns the rounded up number.
*/
ceil(
n: number,
precision?: number
): number;
ceil(n: number, precision?: number): number;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.ceil
*/
ceil(precision?: number): number;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.ceil
*/
ceil(precision?: number): LoDashExplicitWrapper<number>;
ceil(precision?: number): PrimitiveChain<number>;
}
// divide
interface LoDashStatic {
/**
/**
* Divide two numbers.
*
* @param dividend The first number in a division.
* @param divisor The second number in a division.
* @returns Returns the quotient.
*/
divide(
dividend: number,
divisor: number
): number;
*/
divide(dividend: number, divisor: number): number;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.divide
*/
divide(divisor: number): number;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.divide
*/
divide(divisor: number): LoDashExplicitWrapper<number>;
divide(divisor: number): PrimitiveChain<number>;
}
// floor
interface LoDashStatic {
/**
* Calculates n rounded down to precision.
@ -100,58 +77,45 @@ declare module "../index" {
* @param precision The precision to round down to.
* @return Returns the rounded down number.
*/
floor(
n: number,
precision?: number
): number;
floor(n: number, precision?: number): number;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.floor
*/
floor(precision?: number): number;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.floor
*/
floor(precision?: number): LoDashExplicitWrapper<number>;
floor(precision?: number): PrimitiveChain<number>;
}
// max
interface LoDashStatic {
/**
/**
* Computes the maximum value of `array`. If `array` is empty or falsey
* `undefined` is returned.
*
* @category Math
* @param array The array to iterate over.
* @returns Returns the maximum value.
*/
max<T>(
collection: List<T> | null | undefined
): T | undefined;
*/
max<T>(collection: List<T> | null | undefined): T | undefined;
}
interface LoDashImplicitWrapper<TValue> {
interface Collection<T> {
/**
* @see _.max
*/
max<T>(this: LoDashImplicitWrapper<List<T> | null | undefined>): T | undefined;
max(): T | undefined;
}
interface LoDashExplicitWrapper<TValue> {
interface CollectionChain<T> {
/**
* @see _.max
*/
max<T>(this: LoDashExplicitWrapper<List<T> | null | undefined>): LoDashExplicitWrapper<T | undefined>;
max(): ExpChain<T | undefined>;
}
// maxBy
interface LoDashStatic {
/**
* This method is like `_.max` except that it accepts `iteratee` which is
@ -173,34 +137,21 @@ declare module "../index" {
* _.maxBy(objects, 'n');
* // => { 'n': 2 }
*/
maxBy<T>(
collection: List<T> | null | undefined,
iteratee?: ValueIteratee<T>
): T | undefined;
maxBy<T>(collection: List<T> | null | undefined, iteratee?: ValueIteratee<T>): T | undefined;
}
interface LoDashImplicitWrapper<TValue> {
interface Collection<T> {
/**
* @see _.maxBy
*/
maxBy<T>(
this: LoDashImplicitWrapper<List<T> | null | undefined>,
iteratee?: ValueIteratee<T>
): T | undefined;
maxBy(iteratee?: ValueIteratee<T>): T | undefined;
}
interface LoDashExplicitWrapper<TValue> {
interface CollectionChain<T> {
/**
* @see _.maxBy
*/
maxBy<T>(
this: LoDashExplicitWrapper<List<T> | null | undefined>,
iteratee?: ValueIteratee<T>
): LoDashExplicitWrapper<T | undefined>;
maxBy(iteratee?: ValueIteratee<T>): ExpChain<T | undefined>;
}
// mean
interface LoDashStatic {
/**
* Computes the mean of the values in `array`.
@ -213,68 +164,49 @@ declare module "../index" {
* _.mean([4, 2, 8, 6]);
* // => 5
*/
mean(
collection: List<any> | null | undefined
): number;
mean(collection: List<any> | null | undefined): number;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.mean
*/
mean(): number;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.mean
*/
mean(): LoDashExplicitWrapper<number>;
mean(): PrimitiveChain<number>;
}
// meanBy
interface LoDashStatic {
/**
* Computes the mean of the provided propties of the objects in the `array`
*
* @category Math
* @param array The array to iterate over.
* @param iteratee The iteratee invoked per element.
* @returns Returns the mean.
* @example
*
* _.mean([{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }], 'n');
* // => 5
*/
meanBy<T>(
collection: List<T> | null | undefined,
iteratee?: ValueIteratee<T>
): number;
/**
* Computes the mean of the provided propties of the objects in the `array`
*
* @category Math
* @param array The array to iterate over.
* @param iteratee The iteratee invoked per element.
* @returns Returns the mean.
* @example
*
* _.mean([{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }], 'n');
* // => 5
*/
meanBy<T>(collection: List<T> | null | undefined, iteratee?: ValueIteratee<T>): number;
}
interface LoDashImplicitWrapper<TValue> {
interface Collection<T> {
/**
* @see _.meanBy
*/
meanBy<T>(
this: LoDashImplicitWrapper<List<T> | null | undefined>,
iteratee?: ValueIteratee<T>
): number;
meanBy(iteratee?: ValueIteratee<T>): number;
}
interface LoDashExplicitWrapper<TValue> {
interface CollectionChain<T> {
/**
* @see _.meanBy
*/
meanBy<T>(
this: LoDashExplicitWrapper<List<T> | null | undefined>,
iteratee?: ValueIteratee<T>
): LoDashExplicitWrapper<number>;
meanBy(iteratee?: ValueIteratee<T>): PrimitiveChain<number>;
}
// min
interface LoDashStatic {
/**
* Computes the minimum value of `array`. If `array` is empty or falsey
@ -284,27 +216,21 @@ declare module "../index" {
* @param array The array to iterate over.
* @returns Returns the minimum value.
*/
min<T>(
collection: List<T> | null | undefined
): T | undefined;
min<T>(collection: List<T> | null | undefined): T | undefined;
}
interface LoDashImplicitWrapper<TValue> {
interface Collection<T> {
/**
* @see _.min
*/
min<T>(this: LoDashImplicitWrapper<List<T> | null | undefined>): T | undefined;
min(): T | undefined;
}
interface LoDashExplicitWrapper<TValue> {
interface CollectionChain<T> {
/**
* @see _.min
*/
min<T>(this: LoDashExplicitWrapper<List<T> | null | undefined>): LoDashExplicitWrapper<T | undefined>;
min(): ExpChain<T | undefined>;
}
// minBy
interface LoDashStatic {
/**
* This method is like `_.min` except that it accepts `iteratee` which is
@ -326,34 +252,21 @@ declare module "../index" {
* _.minBy(objects, 'n');
* // => { 'n': 1 }
*/
minBy<T>(
collection: List<T> | null | undefined,
iteratee?: ValueIteratee<T>
): T | undefined;
minBy<T>(collection: List<T> | null | undefined, iteratee?: ValueIteratee<T>): T | undefined;
}
interface LoDashImplicitWrapper<TValue> {
interface Collection<T> {
/**
* @see _.minBy
*/
minBy<T>(
this: LoDashImplicitWrapper<List<T> | null | undefined>,
iteratee?: ValueIteratee<T>
): T | undefined;
minBy(iteratee?: ValueIteratee<T>): T | undefined;
}
interface LoDashExplicitWrapper<TValue> {
interface CollectionChain<T> {
/**
* @see _.minBy
*/
minBy<T>(
this: LoDashExplicitWrapper<List<T> | null | undefined>,
iteratee?: ValueIteratee<T>
): LoDashExplicitWrapper<T | undefined>;
minBy(iteratee?: ValueIteratee<T>): ExpChain<T | undefined>;
}
// multiply
interface LoDashStatic {
/**
* Multiply two numbers.
@ -361,28 +274,21 @@ declare module "../index" {
* @param multiplicand The second number in a multiplication.
* @returns Returns the product.
*/
multiply(
multiplier: number,
multiplicand: number
): number;
multiply(multiplier: number, multiplicand: number): number;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.multiply
*/
multiply(multiplicand: number): number;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.multiply
*/
multiply(multiplicand: number): LoDashExplicitWrapper<number>;
multiply(multiplicand: number): PrimitiveChain<number>;
}
// round
interface LoDashStatic {
/**
* Calculates n rounded to precision.
@ -391,28 +297,21 @@ declare module "../index" {
* @param precision The precision to round to.
* @return Returns the rounded number.
*/
round(
n: number,
precision?: number
): number;
round(n: number, precision?: number): number;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.round
*/
round(precision?: number): number;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.round
*/
round(precision?: number): LoDashExplicitWrapper<number>;
round(precision?: number): PrimitiveChain<number>;
}
// subtract
interface LoDashStatic {
/**
* Subtract two numbers.
@ -426,32 +325,21 @@ declare module "../index" {
* _.subtract(6, 4);
* // => 2
*/
subtract(
minuend: number,
subtrahend: number
): number;
subtract(minuend: number, subtrahend: number): number;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.subtract
*/
subtract(
subtrahend: number
): number;
subtract(subtrahend: number): number;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.subtract
*/
subtract(
subtrahend: number
): LoDashExplicitWrapper<number>;
subtract(subtrahend: number): PrimitiveChain<number>;
}
// sum
interface LoDashStatic {
/**
* Computes the sum of the values in `array`.
@ -466,23 +354,19 @@ declare module "../index" {
*/
sum(collection: List<any> | null | undefined): number;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.sum
*/
sum(): number;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.sum
*/
sum(): LoDashExplicitWrapper<number>;
sum(): PrimitiveChain<number>;
}
// sumBy
interface LoDashStatic {
/**
* This method is like `_.sum` except that it accepts `iteratee` which is
@ -504,29 +388,18 @@ declare module "../index" {
* _.sumBy(objects, 'n');
* // => 20
*/
sumBy<T>(
collection: List<T> | null | undefined,
iteratee?: ((value: T) => number) | string
): number;
sumBy<T>(collection: List<T> | null | undefined, iteratee?: ((value: T) => number) | string): number;
}
interface LoDashImplicitWrapper<TValue> {
interface Collection<T> {
/**
* @see _.sumBy
*/
sumBy<T>(
this: LoDashImplicitWrapper<List<T> | null | undefined>,
iteratee?: ((value: T) => number) | string
): number;
sumBy(iteratee?: ((value: T) => number) | string): number;
}
interface LoDashExplicitWrapper<TValue> {
interface CollectionChain<T> {
/**
* @see _.sumBy
*/
sumBy<T>(
this: LoDashExplicitWrapper<List<T> | null | undefined>,
iteratee?: ((value: T) => number) | string
): LoDashExplicitWrapper<number>;
sumBy(iteratee?: ((value: T) => number) | string): PrimitiveChain<number>;
}
}

125
types/lodash/common/number.d.ts vendored
View File

@ -1,7 +1,6 @@
import _ = require("../index");
declare module "../index" {
// clamp
interface LoDashStatic {
/**
* Clamps `number` within the inclusive `lower` and `upper` bounds.
@ -18,46 +17,47 @@ declare module "../index" {
*
* _.clamp(10, -5, 5);
* // => 5
* Clamps `number` within the inclusive `lower` and `upper` bounds.
*
* @category Number
* @param number The number to clamp.
* @param [lower] The lower bound.
* @param upper The upper bound.
* @returns Returns the clamped number.
* @example
*
* _.clamp(-10, -5, 5);
* // => -5
*
* _.clamp(10, -5, 5);
*/
clamp(
number: number,
lower: number,
upper: number
): number;
clamp(
number: number,
upper: number
): number;
clamp(number: number, lower: number, upper: number): number;
/**
* @see _.clamp
*/
clamp(number: number, upper: number): number;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.clamp
*/
clamp(
lower: number,
upper: number
): number;
clamp(
upper: number
): number;
clamp(lower: number, upper: number): number;
/**
* @see _.clamp
*/
clamp(upper: number): number;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.clamp
*/
clamp(
lower: number,
upper: number
): LoDashExplicitWrapper<number>;
clamp(
upper: number
): LoDashExplicitWrapper<number>;
clamp(lower: number, upper: number): PrimitiveChain<number>;
/**
* @see _.clamp
*/
clamp(upper: number): PrimitiveChain<number>;
}
// inRange
interface LoDashStatic {
/**
* Checks if n is between start and up to but not including, end. If end is not specified it’s set to start
@ -68,35 +68,21 @@ declare module "../index" {
* @param end The end of the range.
* @return Returns true if n is in the range, else false.
*/
inRange(
n: number,
start: number,
end?: number
): boolean;
inRange(n: number, start: number, end?: number): boolean;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.inRange
*/
inRange(
start: number,
end?: number
): boolean;
inRange(start: number, end?: number): boolean;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.inRange
*/
inRange(
start: number,
end?: number
): LoDashExplicitWrapper<boolean>;
inRange(start: number, end?: number): PrimitiveChain<boolean>;
}
// random
interface LoDashStatic {
/**
* Produces a random number between min and max (inclusive). If only one argument is provided a number between
@ -108,71 +94,38 @@ declare module "../index" {
* @param floating Specify returning a floating-point number.
* @return Returns the random number.
*/
random(
floating?: boolean
): number;
random(floating?: boolean): number;
/**
* @see _.random
*/
random(
max: number,
floating?: boolean
): number;
random(max: number, floating?: boolean): number;
/**
* @see _.random
*/
random(
min: number,
max: number,
floating?: boolean
): number;
random(min: number, max: number, floating?: boolean): number;
/**
* Produces a random number between min and max (inclusive). If only one argument is provided a number between
* 0 and the given number is returned. If floating is true, or either min or max are floats, a floating-point
* number is returned instead of an integer.
*
* @param min The minimum possible value.
* @param index Not used in this overload.
* @param guard Enables use as an iteratee for methods like _.map. You should not pass this parameter directly in your code.
* @return Returns the random number.
* @see _.random
*/
random(
min: number,
index: string | number,
guard: object
): number;
random(min: number, index: string | number, guard: object): number;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.random
*/
random(floating?: boolean): number;
/**
* @see _.random
*/
random(
max: number,
floating?: boolean
): number;
random(max: number, floating?: boolean): number;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.random
*/
random(floating?: boolean): LoDashExplicitWrapper<number>;
random(floating?: boolean): PrimitiveChain<number>;
/**
* @see _.random
*/
random(
max: number,
floating?: boolean
): LoDashExplicitWrapper<number>;
random(max: number, floating?: boolean): PrimitiveChain<number>;
}
}

3338
types/lodash/common/object.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

222
types/lodash/common/seq.d.ts vendored
View File

@ -1,7 +1,6 @@
import _ = require("../index");
declare module "../index" {
// chain
interface LoDashStatic {
/**
* Creates a lodash object that wraps value with explicit method chaining enabled.
@ -9,136 +8,158 @@ declare module "../index" {
* @param value The value to wrap.
* @return Returns the new lodash wrapper instance.
*/
chain<T>(value: T): LoDashExplicitWrapper<T>;
}
interface LoDashImplicitWrapper<TValue> {
chain<TrapAny extends { __lodashAnyHack: any }>(value: TrapAny): CollectionChain<any> & FunctionChain<any> & ObjectChain<any> & PrimitiveChain<any> & StringChain;
/**
* @see _.chain
*/
chain(): LoDashExplicitWrapper<TValue>;
chain<T extends null | undefined>(value: T): PrimitiveChain<T>;
/**
* @see _.chain
*/
chain(value: string): StringChain;
/**
* @see _.chain
*/
chain(value: string | null | undefined): StringNullableChain;
/**
* @see _.chain
*/
chain<T extends (...args: any[]) => any>(value: T): FunctionChain<T>;
/**
* @see _.chain
*/
chain<T = any>(value: List<T> | null | undefined): CollectionChain<T>;
/**
* @see _.chain
*/
chain<T extends object>(value: T | null | undefined): ObjectChain<T>;
/**
* @see _.chain
*/
chain<T>(value: T): PrimitiveChain<T>;
}
interface Collection<T> {
/**
* @see _.chain
*/
chain(): CollectionChain<T>;
}
interface String {
/**
* @see _.chain
*/
chain(): StringChain;
}
interface Object<T> {
/**
* @see _.chain
*/
chain(): ObjectChain<T>;
}
interface Primitive<T> {
/**
* @see _.chain
*/
chain(): PrimitiveChain<T>;
}
interface Function<T extends (...args: any) => any> {
/**
* @see _.chain
*/
chain(): FunctionChain<T>;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.chain
*/
chain(): this;
}
// prototype.chain
interface LoDashStatic {
/**
* Creates a lodash object that wraps value with explicit method chaining enabled.
*
* @param value The value to wrap.
* @return Returns the new lodash wrapper instance.
*/
chain<T>(value: T): LoDashExplicitWrapper<T>;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.chain
*/
chain(): LoDashExplicitWrapper<TValue>;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.chain
*/
chain(): this;
}
// prototype.commit
interface LoDashWrapper<TValue> {
interface LoDashImplicitWrapper<TValue> {
/**
* Executes the chained sequence and returns the wrapped result.
*
* @return Returns the new lodash wrapper instance.
* @see _.commit
*/
commit(): this;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.commit
*/
commit(): this;
}
// prototype.plant
interface LoDashImplicitWrapper<TValue> {
/**
* Creates a clone of the chained sequence planting value as the wrapped value.
* @param value The value to plant as the wrapped value.
* @return Returns the new lodash wrapper instance.
* @see _.plant
*/
plant<T>(value: T): LoDashImplicitWrapper<T>;
plant(value: unknown): this;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.plant
*/
plant<T>(value: T): LoDashExplicitWrapper<T>;
plant(value: unknown): this;
}
// prototype.reverse
interface LoDashWrapper<TValue> {
interface LoDashImplicitWrapper<TValue> {
/**
* Reverses the wrapped array so the first element becomes the last, the second element becomes the second to
* last, and so on.
*
* Note: This method mutates the wrapped array.
*
* @return Returns the new reversed lodash wrapper instance.
* @see _.reverse
*/
reverse(): this;
}
// prototype.toJSON
interface LoDashWrapper<TValue> {
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.value
* @see _.reverse
*/
reverse(): this;
}
// prototype.toJSON
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.toJSON
*/
toJSON(): TValue;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.toJSON
*/
toJSON(): TValue;
}
// prototype.toString
interface LoDashWrapper<TValue> {
/**
* Produces the result of coercing the unwrapped value to a string.
*
* @return Returns the coerced string value.
* @see _.toString
*/
toString(): string;
}
// prototype.value
interface LoDashWrapper<TValue> {
/**
* Executes the chained sequence to extract the unwrapped value.
*
* @alias _.toJSON, _.valueOf
*
* @return Returns the resolved unwrapped value.
*/
value(): TValue;
}
// prototype.valueOf
interface LoDashWrapper<TValue> {
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.value
*/
value(): TValue;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.value
*/
value(): TValue;
}
// prototype.valueOf
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.valueOf
*/
valueOf(): TValue;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.valueOf
*/
valueOf(): TValue;
}
// tap
interface LoDashStatic {
/**
* This method invokes interceptor and returns value. The interceptor is invoked with one
@ -148,24 +169,22 @@ declare module "../index" {
* @param value The value to provide to interceptor.
* @param interceptor The function to invoke.
* @return Returns value.
**/
tap<T>(
value: T,
interceptor: (value: T) => void
): T;
*/
tap<T>(value: T, interceptor: (value: T) => void): T;
}
interface LoDashWrapper<TValue> {
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.tap
*/
tap(
interceptor: (value: TValue) => void
): this;
tap(interceptor: (value: TValue) => void): this;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.tap
*/
tap(interceptor: (value: TValue) => void): this;
}
// thru
interface LoDashStatic {
/**
* This method is like _.tap except that it returns the result of interceptor.
@ -174,23 +193,18 @@ declare module "../index" {
* @param interceptor The function to invoke.
* @return Returns the result of interceptor.
*/
thru<T, TResult>(
value: T,
interceptor: (value: T) => TResult
): TResult;
thru<T, TResult>(value: T, interceptor: (value: T) => TResult): TResult;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.thru
*/
thru<TResult>(interceptor: (value: TValue) => TResult): LoDashImplicitWrapper<TResult>;
thru<TResult>(interceptor: (value: TValue) => TResult): ImpChain<TResult>;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.thru
*/
thru<TResult>(interceptor: (value: TValue) => TResult): LoDashExplicitWrapper<TResult>;
thru<TResult>(interceptor: (value: TValue) => TResult): ExpChain<TResult>;
}
}

431
types/lodash/common/string.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

990
types/lodash/common/util.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

1397
types/lodash/fp.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

1
types/lodash/index.d.ts vendored
View File

@ -10,7 +10,6 @@
// Dominique Rau <https://github.com/DomiR>
// William Chelman <https://github.com/WilliamChelman>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.8
/// <reference path="./common/common.d.ts" />
/// <reference path="./common/array.d.ts" />

3218
types/lodash/lodash-tests.ts
View File

File diff suppressed because it is too large Load Diff

2
types/lodash/multiply.d.ts vendored
View File

@ -1,2 +1,2 @@
import { multiply } from "./index";
import { multiply } from './index';
export = multiply;

11
types/lodash/package.json
View File

@ -1,11 +0,0 @@
{
"private": true,
"types": "index",
"typesVersions": {
">=3.1.0-0": {
"*": [
"ts3.1/*"
]
}
}
}

0
types/lodash/ts3.1/scripts/generate-all.sh → types/lodash/scripts/generate-all.sh
View File

42
types/lodash/scripts/generate-fp.ts
View File

@ -96,14 +96,10 @@ async function main() {
}
}
}
// Check whether or not an interface is an overload or the main lodash function
const isExportedInterface = (interfaceDef: Interface) => !!interfaceGroups.find(g => g.interfaces[0].name === interfaceDef.name);
const interfaces = _.uniqBy(_.flatMap(interfaceGroups, g => g.interfaces), i => i.name);
const commonTypeSearch = new RegExp(`\\b(${commonTypes.join("|")})\\b`, "g");
const interfaceStrings = _(interfaces)
.map(i => tab(interfaceToString(i, isExportedInterface(i)), 1))
.map(i => tab(interfaceToString(i), 1))
.join(lineBreak)
.replace(commonTypeSearch, match => `lodash.${match}`);
const fpFile = [
@ -117,10 +113,6 @@ async function main() {
"",
"declare const _: _.LoDashFp;",
"declare namespace _ {",
// Add LodashConvertible to allow `.convert` method on each lodash/fp function
" interface LodashConvertible {",
" convert(options: lodash.ConvertOptions): (...args: any[]) => any;",
" }",
interfaceStrings,
"",
" interface LoDashFp {",
@ -135,6 +127,24 @@ async function main() {
if (err)
console.error("Failed to write fp.d.ts: ", err);
});
// Make sure the generated files are listed in tsconfig.json, so they are included in the lint checks
const tsconfigPath = path.join("..", "tsconfig.json");
const tsconfigFile = await readFile(tsconfigPath);
const tsconfig = tsconfigFile.split(lineBreak).filter(row => !row.includes("fp/") || row.includes("fp/convert.d.ts"));
const newRows = interfaceGroups.map(g => ` "fp/${g.functionName}.d.ts",`)
.concat(["__", "placeholder"].map(p => ` "fp/${p}.d.ts",`));
newRows[newRows.length - 1] = newRows[newRows.length - 1].replace(",", "");
const insertIndex = _.findLastIndex(tsconfig, row => row.trim() === "]"); // Assume "files" is the last array
if (!tsconfig[insertIndex - 1].endsWith(","))
tsconfig[insertIndex - 1] += ",";
tsconfig.splice(insertIndex, 0, ...newRows);
fs.writeFile(tsconfigPath, tsconfig.join(lineBreak), (err) => {
if (err)
console.error(`Failed to write ${tsconfigPath}: `, err);
});
}
async function processDefinitions(filePaths: string[], commonTypes: string[]): Promise<InterfaceGroup[]> {
@ -737,7 +747,9 @@ function curryParams(
};
// Remove the `extends` constraint from interface type parameters, because sometimes they extend things that aren't passed to the interface.
for (const typeParam of interfaceDef.typeParams) {
if (!_.startsWith(typeParam.extends, "keyof ")) // We need to keep `extends keyof` constraints, because they're needed for TObject[TKey] to work.
// 1. retain `extends keyof X` constraints so that TObject[TKey] still works.
// 2. retain `any[]` constraints so that variadic generics work.
if (!_.startsWith(typeParam.extends, "keyof ") && typeParam.extends !== "any[]")
delete typeParam.extends;
}
return interfaceDef;
@ -836,13 +848,7 @@ function getInterfaceName(baseName: string, overloadId: number, index: number, t
return interfaceName;
}
function interfaceToString(interfaceDef: Interface, exportedInterface: boolean): string {
// Exported interface extends LodashConvertible to allow
// calling `.convert({})` on each lodash/fp functions
const interfaceExtendsStatement = exportedInterface
? " extends LodashConvertible"
: "";
function interfaceToString(interfaceDef: Interface): string {
if (_.isEmpty(interfaceDef.overloads)) {
// No point in creating an empty interface
return "";
@ -859,7 +865,7 @@ function interfaceToString(interfaceDef: Interface, exportedInterface: boolean):
} else {
const overloadStrings = interfaceDef.overloads.map(o => lineBreak + tab(overloadToString(o), 1)).join("")
+ interfaceDef.constants.map(c => `${lineBreak}${tab(c, 1)};`).join("");
return `interface ${interfaceDef.name}${typeParamsToString(interfaceDef.typeParams)}${interfaceExtendsStatement} {${overloadStrings}${lineBreak}}`;
return `interface ${interfaceDef.name}${typeParamsToString(interfaceDef.typeParams)} {${overloadStrings}${lineBreak}}`;
}
}

8
types/lodash/scripts/generate-modules.ts
View File

@ -19,7 +19,7 @@ async function main(): Promise<void> {
}
// Generate lodash/tsconfig.json
fs.writeFileSync(path.join("..", "tsconfig.json"), lodashTsconfig());
fs.writeFileSync(path.join("..", "tsconfig.json"), lodashTsconfig(all));
for (const module of all) {
console.log(module);
@ -53,7 +53,7 @@ async function globalDefinitionText(moduleName: string): Promise<string> {
return `
// Type definitions for ${fullName} ${majorMinor}
// Project: https://lodash.com
// Project: http://lodash.com/
// Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.8
@ -85,12 +85,13 @@ function compilerOptions(): object {
};
}
function lodashTsconfig(): string {
function lodashTsconfig(moduleNames: ReadonlyArray<string>): string {
return JSON.stringify({
compilerOptions: compilerOptions(),
files: [
"index.d.ts",
"lodash-tests.ts",
...moduleNames.map(m => `${m}.d.ts`),
]
}, undefined, 4);
}
@ -309,7 +310,6 @@ function allModuleNames(): string[] {
"min",
"minBy",
"mixin",
"multiply",
"negate",
"noConflict",
"noop",

12
types/lodash/scripts/package.json
View File

@ -1,14 +1,18 @@
{
"private": true,
"name": "lodash-scripts",
"version": "0.1.0",
"version": "0.0.1",
"scripts": {
"generate": "ts-node generate-modules && ts-node generate-fp"
"generate": "ts-node generate-fp",
"fp": "ts-node generate-fp"
},
"devDependencies": {
"lodash": "^4.17.4",
"lodash": "^4.17.11",
"ts-node": "^4.1.0",
"typescript": "^2.7.1"
},
"dependencies": {}
"dependencies": {
"@types/lodash": "^4.14.123",
"@types/node": "^11.13.9"
}
}

2
types/lodash/scripts/tsconfig.json
View File

@ -11,7 +11,7 @@
"../../"
],
"types": [
"lodash"
"node"
]
}
}

687
types/lodash/ts3.1/OTHER_FILES.txt
View File

@ -1,687 +0,0 @@
add.d.ts
after.d.ts
ary.d.ts
assign.d.ts
assignIn.d.ts
assignInWith.d.ts
assignWith.d.ts
at.d.ts
attempt.d.ts
before.d.ts
bind.d.ts
bindAll.d.ts
bindKey.d.ts
camelCase.d.ts
capitalize.d.ts
castArray.d.ts
ceil.d.ts
chain.d.ts
chunk.d.ts
clamp.d.ts
clone.d.ts
cloneDeep.d.ts
cloneDeepWith.d.ts
cloneWith.d.ts
compact.d.ts
concat.d.ts
cond.d.ts
conformsTo.d.ts
constant.d.ts
countBy.d.ts
create.d.ts
curry.d.ts
curryRight.d.ts
debounce.d.ts
deburr.d.ts
defaultTo.d.ts
defaults.d.ts
defaultsDeep.d.ts
defer.d.ts
delay.d.ts
difference.d.ts
differenceBy.d.ts
differenceWith.d.ts
divide.d.ts
drop.d.ts
dropRight.d.ts
dropRightWhile.d.ts
dropWhile.d.ts
each.d.ts
eachRight.d.ts
endsWith.d.ts
entries.d.ts
entriesIn.d.ts
eq.d.ts
escape.d.ts
escapeRegExp.d.ts
every.d.ts
extend.d.ts
extendWith.d.ts
fill.d.ts
filter.d.ts
find.d.ts
findIndex.d.ts
findKey.d.ts
findLast.d.ts
findLastIndex.d.ts
findLastKey.d.ts
first.d.ts
flatMap.d.ts
flatMapDeep.d.ts
flatMapDepth.d.ts
flatten.d.ts
flattenDeep.d.ts
flattenDepth.d.ts
flip.d.ts
floor.d.ts
flow.d.ts
flowRight.d.ts
forEach.d.ts
forEachRight.d.ts
forIn.d.ts
forInRight.d.ts
forOwn.d.ts
forOwnRight.d.ts
fp/F.d.ts
fp/T.d.ts
fp/__.d.ts
fp/add.d.ts
fp/after.d.ts
fp/all.d.ts
fp/allPass.d.ts
fp/always.d.ts
fp/any.d.ts
fp/anyPass.d.ts
fp/apply.d.ts
fp/ary.d.ts
fp/assign.d.ts
fp/assignAll.d.ts
fp/assignAllWith.d.ts
fp/assignIn.d.ts
fp/assignInAll.d.ts
fp/assignInAllWith.d.ts
fp/assignInWith.d.ts
fp/assignWith.d.ts
fp/assoc.d.ts
fp/assocPath.d.ts
fp/at.d.ts
fp/attempt.d.ts
fp/before.d.ts
fp/bind.d.ts
fp/bindAll.d.ts
fp/bindKey.d.ts
fp/camelCase.d.ts
fp/capitalize.d.ts
fp/castArray.d.ts
fp/ceil.d.ts
fp/chunk.d.ts
fp/clamp.d.ts
fp/clone.d.ts
fp/cloneDeep.d.ts
fp/cloneDeepWith.d.ts
fp/cloneWith.d.ts
fp/compact.d.ts
fp/complement.d.ts
fp/compose.d.ts
fp/concat.d.ts
fp/cond.d.ts
fp/conforms.d.ts
fp/conformsTo.d.ts
fp/constant.d.ts
fp/contains.d.ts
fp/convert.d.ts
fp/countBy.d.ts
fp/create.d.ts
fp/curry.d.ts
fp/curryN.d.ts
fp/curryRight.d.ts
fp/curryRightN.d.ts
fp/debounce.d.ts
fp/deburr.d.ts
fp/defaultTo.d.ts
fp/defaults.d.ts
fp/defaultsAll.d.ts
fp/defaultsDeep.d.ts
fp/defaultsDeepAll.d.ts
fp/defer.d.ts
fp/delay.d.ts
fp/difference.d.ts
fp/differenceBy.d.ts
fp/differenceWith.d.ts
fp/dissoc.d.ts
fp/dissocPath.d.ts
fp/divide.d.ts
fp/drop.d.ts
fp/dropLast.d.ts
fp/dropLastWhile.d.ts
fp/dropRight.d.ts
fp/dropRightWhile.d.ts
fp/dropWhile.d.ts
fp/each.d.ts
fp/eachRight.d.ts
fp/endsWith.d.ts
fp/entries.d.ts
fp/entriesIn.d.ts
fp/eq.d.ts
fp/equals.d.ts
fp/escape.d.ts
fp/escapeRegExp.d.ts
fp/every.d.ts
fp/extend.d.ts
fp/extendAll.d.ts
fp/extendAllWith.d.ts
fp/extendWith.d.ts
fp/fill.d.ts
fp/filter.d.ts
fp/find.d.ts
fp/findFrom.d.ts
fp/findIndex.d.ts
fp/findIndexFrom.d.ts
fp/findKey.d.ts
fp/findLast.d.ts
fp/findLastFrom.d.ts
fp/findLastIndex.d.ts
fp/findLastIndexFrom.d.ts
fp/findLastKey.d.ts
fp/first.d.ts
fp/flatMap.d.ts
fp/flatMapDeep.d.ts
fp/flatMapDepth.d.ts
fp/flatten.d.ts
fp/flattenDeep.d.ts
fp/flattenDepth.d.ts
fp/flip.d.ts
fp/floor.d.ts
fp/flow.d.ts
fp/flowRight.d.ts
fp/forEach.d.ts
fp/forEachRight.d.ts
fp/forIn.d.ts
fp/forInRight.d.ts
fp/forOwn.d.ts
fp/forOwnRight.d.ts
fp/fromPairs.d.ts
fp/functions.d.ts
fp/functionsIn.d.ts
fp/get.d.ts
fp/getOr.d.ts
fp/groupBy.d.ts
fp/gt.d.ts
fp/gte.d.ts
fp/has.d.ts
fp/hasIn.d.ts
fp/head.d.ts
fp/identical.d.ts
fp/identity.d.ts
fp/inRange.d.ts
fp/includes.d.ts
fp/includesFrom.d.ts
fp/indexBy.d.ts
fp/indexOf.d.ts
fp/indexOfFrom.d.ts
fp/init.d.ts
fp/initial.d.ts
fp/intersection.d.ts
fp/intersectionBy.d.ts
fp/intersectionWith.d.ts
fp/invert.d.ts
fp/invertBy.d.ts
fp/invertObj.d.ts
fp/invoke.d.ts
fp/invokeArgs.d.ts
fp/invokeArgsMap.d.ts
fp/invokeMap.d.ts
fp/isArguments.d.ts
fp/isArray.d.ts
fp/isArrayBuffer.d.ts
fp/isArrayLike.d.ts
fp/isArrayLikeObject.d.ts
fp/isBoolean.d.ts
fp/isBuffer.d.ts
fp/isDate.d.ts
fp/isElement.d.ts
fp/isEmpty.d.ts
fp/isEqual.d.ts
fp/isEqualWith.d.ts
fp/isError.d.ts
fp/isFinite.d.ts
fp/isFunction.d.ts
fp/isInteger.d.ts
fp/isLength.d.ts
fp/isMap.d.ts
fp/isMatch.d.ts
fp/isMatchWith.d.ts
fp/isNaN.d.ts
fp/isNative.d.ts
fp/isNil.d.ts
fp/isNull.d.ts
fp/isNumber.d.ts
fp/isObject.d.ts
fp/isObjectLike.d.ts
fp/isPlainObject.d.ts
fp/isRegExp.d.ts
fp/isSafeInteger.d.ts
fp/isSet.d.ts
fp/isString.d.ts
fp/isSymbol.d.ts
fp/isTypedArray.d.ts
fp/isUndefined.d.ts
fp/isWeakMap.d.ts
fp/isWeakSet.d.ts
fp/iteratee.d.ts
fp/join.d.ts
fp/juxt.d.ts
fp/kebabCase.d.ts
fp/keyBy.d.ts
fp/keys.d.ts
fp/keysIn.d.ts
fp/last.d.ts
fp/lastIndexOf.d.ts
fp/lastIndexOfFrom.d.ts
fp/lowerCase.d.ts
fp/lowerFirst.d.ts
fp/lt.d.ts
fp/lte.d.ts
fp/map.d.ts
fp/mapKeys.d.ts
fp/mapValues.d.ts
fp/matches.d.ts
fp/matchesProperty.d.ts
fp/max.d.ts
fp/maxBy.d.ts
fp/mean.d.ts
fp/meanBy.d.ts
fp/memoize.d.ts
fp/merge.d.ts
fp/mergeAll.d.ts
fp/mergeAllWith.d.ts
fp/mergeWith.d.ts
fp/method.d.ts
fp/methodOf.d.ts
fp/min.d.ts
fp/minBy.d.ts
fp/multiply.d.ts
fp/nAry.d.ts
fp/negate.d.ts
fp/noConflict.d.ts
fp/noop.d.ts
fp/now.d.ts
fp/nth.d.ts
fp/nthArg.d.ts
fp/omit.d.ts
fp/omitAll.d.ts
fp/omitBy.d.ts
fp/once.d.ts
fp/orderBy.d.ts
fp/over.d.ts
fp/overArgs.d.ts
fp/overEvery.d.ts
fp/overSome.d.ts
fp/pad.d.ts
fp/padChars.d.ts
fp/padCharsEnd.d.ts
fp/padCharsStart.d.ts
fp/padEnd.d.ts
fp/padStart.d.ts
fp/parseInt.d.ts
fp/partial.d.ts
fp/partialRight.d.ts
fp/partition.d.ts
fp/path.d.ts
fp/pathEq.d.ts
fp/pathOr.d.ts
fp/paths.d.ts
fp/pick.d.ts
fp/pickAll.d.ts
fp/pickBy.d.ts
fp/pipe.d.ts
fp/placeholder.d.ts
fp/pluck.d.ts
fp/prop.d.ts
fp/propEq.d.ts
fp/propOr.d.ts
fp/property.d.ts
fp/propertyOf.d.ts
fp/props.d.ts
fp/pull.d.ts
fp/pullAll.d.ts
fp/pullAllBy.d.ts
fp/pullAllWith.d.ts
fp/pullAt.d.ts
fp/random.d.ts
fp/range.d.ts
fp/rangeRight.d.ts
fp/rangeStep.d.ts
fp/rangeStepRight.d.ts
fp/rearg.d.ts
fp/reduce.d.ts
fp/reduceRight.d.ts
fp/reject.d.ts
fp/remove.d.ts
fp/repeat.d.ts
fp/replace.d.ts
fp/rest.d.ts
fp/restFrom.d.ts
fp/result.d.ts
fp/reverse.d.ts
fp/round.d.ts
fp/runInContext.d.ts
fp/sample.d.ts
fp/sampleSize.d.ts
fp/set.d.ts
fp/setWith.d.ts
fp/shuffle.d.ts
fp/size.d.ts
fp/slice.d.ts
fp/snakeCase.d.ts
fp/some.d.ts
fp/sortBy.d.ts
fp/sortedIndex.d.ts
fp/sortedIndexBy.d.ts
fp/sortedIndexOf.d.ts
fp/sortedLastIndex.d.ts
fp/sortedLastIndexBy.d.ts
fp/sortedLastIndexOf.d.ts
fp/sortedUniq.d.ts
fp/sortedUniqBy.d.ts
fp/split.d.ts
fp/spread.d.ts
fp/spreadFrom.d.ts
fp/startCase.d.ts
fp/startsWith.d.ts
fp/stubArray.d.ts
fp/stubFalse.d.ts
fp/stubObject.d.ts
fp/stubString.d.ts
fp/stubTrue.d.ts
fp/subtract.d.ts
fp/sum.d.ts
fp/sumBy.d.ts
fp/symmetricDifference.d.ts
fp/symmetricDifferenceBy.d.ts
fp/symmetricDifferenceWith.d.ts
fp/tail.d.ts
fp/take.d.ts
fp/takeLast.d.ts
fp/takeLastWhile.d.ts
fp/takeRight.d.ts
fp/takeRightWhile.d.ts
fp/takeWhile.d.ts
fp/tap.d.ts
fp/template.d.ts
fp/throttle.d.ts
fp/thru.d.ts
fp/times.d.ts
fp/toArray.d.ts
fp/toFinite.d.ts
fp/toInteger.d.ts
fp/toLength.d.ts
fp/toLower.d.ts
fp/toNumber.d.ts
fp/toPairs.d.ts
fp/toPairsIn.d.ts
fp/toPath.d.ts
fp/toPlainObject.d.ts
fp/toSafeInteger.d.ts
fp/toString.d.ts
fp/toUpper.d.ts
fp/transform.d.ts
fp/trim.d.ts
fp/trimChars.d.ts
fp/trimCharsEnd.d.ts
fp/trimCharsStart.d.ts
fp/trimEnd.d.ts
fp/trimStart.d.ts
fp/truncate.d.ts
fp/unapply.d.ts
fp/unary.d.ts
fp/unescape.d.ts
fp/union.d.ts
fp/unionBy.d.ts
fp/unionWith.d.ts
fp/uniq.d.ts
fp/uniqBy.d.ts
fp/uniqWith.d.ts
fp/uniqueId.d.ts
fp/unnest.d.ts
fp/unset.d.ts
fp/unzip.d.ts
fp/unzipWith.d.ts
fp/update.d.ts
fp/updateWith.d.ts
fp/upperCase.d.ts
fp/upperFirst.d.ts
fp/useWith.d.ts
fp/values.d.ts
fp/valuesIn.d.ts
fp/where.d.ts
fp/whereEq.d.ts
fp/without.d.ts
fp/words.d.ts
fp/wrap.d.ts
fp/xor.d.ts
fp/xorBy.d.ts
fp/xorWith.d.ts
fp/zip.d.ts
fp/zipAll.d.ts
fp/zipObj.d.ts
fp/zipObject.d.ts
fp/zipObjectDeep.d.ts
fp/zipWith.d.ts
fromPairs.d.ts
functions.d.ts
functionsIn.d.ts
get.d.ts
groupBy.d.ts
gt.d.ts
gte.d.ts
has.d.ts
hasIn.d.ts
head.d.ts
identity.d.ts
inRange.d.ts
includes.d.ts
indexOf.d.ts
initial.d.ts
intersection.d.ts
intersectionBy.d.ts
intersectionWith.d.ts
invert.d.ts
invertBy.d.ts
invoke.d.ts
invokeMap.d.ts
isArguments.d.ts
isArray.d.ts
isArrayBuffer.d.ts
isArrayLike.d.ts
isArrayLikeObject.d.ts
isBoolean.d.ts
isBuffer.d.ts
isDate.d.ts
isElement.d.ts
isEmpty.d.ts
isEqual.d.ts
isEqualWith.d.ts
isError.d.ts
isFinite.d.ts
isFunction.d.ts
isInteger.d.ts
isLength.d.ts
isMap.d.ts
isMatch.d.ts
isMatchWith.d.ts
isNaN.d.ts
isNative.d.ts
isNil.d.ts
isNull.d.ts
isNumber.d.ts
isObject.d.ts
isObjectLike.d.ts
isPlainObject.d.ts
isRegExp.d.ts
isSafeInteger.d.ts
isSet.d.ts
isString.d.ts
isSymbol.d.ts
isTypedArray.d.ts
isUndefined.d.ts
isWeakMap.d.ts
isWeakSet.d.ts
iteratee.d.ts
join.d.ts
kebabCase.d.ts
keyBy.d.ts
keys.d.ts
keysIn.d.ts
last.d.ts
lastIndexOf.d.ts
lowerCase.d.ts
lowerFirst.d.ts
lt.d.ts
lte.d.ts
map.d.ts
mapKeys.d.ts
mapValues.d.ts
matches.d.ts
matchesProperty.d.ts
max.d.ts
maxBy.d.ts
mean.d.ts
meanBy.d.ts
memoize.d.ts
merge.d.ts
mergeWith.d.ts
method.d.ts
methodOf.d.ts
min.d.ts
minBy.d.ts
mixin.d.ts
multiply.d.ts
negate.d.ts
noConflict.d.ts
noop.d.ts
now.d.ts
nth.d.ts
nthArg.d.ts
omit.d.ts
omitBy.d.ts
once.d.ts
orderBy.d.ts
over.d.ts
overArgs.d.ts
overEvery.d.ts
overSome.d.ts
pad.d.ts
padEnd.d.ts
padStart.d.ts
parseInt.d.ts
partial.d.ts
partialRight.d.ts
partition.d.ts
pick.d.ts
pickBy.d.ts
property.d.ts
propertyOf.d.ts
pull.d.ts
pullAll.d.ts
pullAllBy.d.ts
pullAllWith.d.ts
pullAt.d.ts
random.d.ts
range.d.ts
rangeRight.d.ts
rearg.d.ts
reduce.d.ts
reduceRight.d.ts
reject.d.ts
remove.d.ts
repeat.d.ts
replace.d.ts
rest.d.ts
result.d.ts
reverse.d.ts
round.d.ts
runInContext.d.ts
sample.d.ts
sampleSize.d.ts
set.d.ts
setWith.d.ts
shuffle.d.ts
size.d.ts
slice.d.ts
snakeCase.d.ts
some.d.ts
sortBy.d.ts
sortedIndex.d.ts
sortedIndexBy.d.ts
sortedIndexOf.d.ts
sortedLastIndex.d.ts
sortedLastIndexBy.d.ts
sortedLastIndexOf.d.ts
sortedUniq.d.ts
sortedUniqBy.d.ts
split.d.ts
spread.d.ts
startCase.d.ts
startsWith.d.ts
stubFalse.d.ts
stubTrue.d.ts
subtract.d.ts
sum.d.ts
sumBy.d.ts
tail.d.ts
take.d.ts
takeRight.d.ts
takeRightWhile.d.ts
takeWhile.d.ts
tap.d.ts
template.d.ts
throttle.d.ts
thru.d.ts
times.d.ts
toArray.d.ts
toFinite.d.ts
toInteger.d.ts
toLength.d.ts
toLower.d.ts
toNumber.d.ts
toPairs.d.ts
toPairsIn.d.ts
toPath.d.ts
toPlainObject.d.ts
toSafeInteger.d.ts
toString.d.ts
toUpper.d.ts
transform.d.ts
trim.d.ts
trimEnd.d.ts
trimStart.d.ts
truncate.d.ts
unary.d.ts
unescape.d.ts
union.d.ts
unionBy.d.ts
unionWith.d.ts
uniq.d.ts
uniqBy.d.ts
uniqWith.d.ts
uniqueId.d.ts
unset.d.ts
unzip.d.ts
unzipWith.d.ts
update.d.ts
updateWith.d.ts
upperCase.d.ts
upperFirst.d.ts
values.d.ts
valuesIn.d.ts
without.d.ts
words.d.ts
wrap.d.ts
xor.d.ts
xorBy.d.ts
xorWith.d.ts
zip.d.ts
zipObject.d.ts
zipObjectDeep.d.ts
zipWith.d.ts

2
types/lodash/ts3.1/add.d.ts vendored
View File

@ -1,2 +0,0 @@
import { add } from "./index";
export = add;

2
types/lodash/ts3.1/after.d.ts vendored
View File

@ -1,2 +0,0 @@
import { after } from "./index";
export = after;

2
types/lodash/ts3.1/ary.d.ts vendored
View File

@ -1,2 +0,0 @@
import { ary } from "./index";
export = ary;

2
types/lodash/ts3.1/assign.d.ts vendored
View File

@ -1,2 +0,0 @@
import { assign } from "./index";
export = assign;

2
types/lodash/ts3.1/assignIn.d.ts vendored
View File

@ -1,2 +0,0 @@
import { assignIn } from "./index";
export = assignIn;

2
types/lodash/ts3.1/assignInWith.d.ts vendored
View File

@ -1,2 +0,0 @@
import { assignInWith } from "./index";
export = assignInWith;

2
types/lodash/ts3.1/assignWith.d.ts vendored
View File

@ -1,2 +0,0 @@
import { assignWith } from "./index";
export = assignWith;

2
types/lodash/ts3.1/at.d.ts vendored
View File

@ -1,2 +0,0 @@
import { at } from "./index";
export = at;

2
types/lodash/ts3.1/attempt.d.ts vendored
View File

@ -1,2 +0,0 @@
import { attempt } from "./index";
export = attempt;

2
types/lodash/ts3.1/before.d.ts vendored
View File

@ -1,2 +0,0 @@
import { before } from "./index";
export = before;

2
types/lodash/ts3.1/bind.d.ts vendored
View File

@ -1,2 +0,0 @@
import { bind } from "./index";
export = bind;

2
types/lodash/ts3.1/bindAll.d.ts vendored
View File

@ -1,2 +0,0 @@
import { bindAll } from "./index";
export = bindAll;

2
types/lodash/ts3.1/bindKey.d.ts vendored
View File

@ -1,2 +0,0 @@
import { bindKey } from "./index";
export = bindKey;

2
types/lodash/ts3.1/camelCase.d.ts vendored
View File

@ -1,2 +0,0 @@
import { camelCase } from "./index";
export = camelCase;

2
types/lodash/ts3.1/capitalize.d.ts vendored
View File

@ -1,2 +0,0 @@
import { capitalize } from "./index";
export = capitalize;

2
types/lodash/ts3.1/castArray.d.ts vendored
View File

@ -1,2 +0,0 @@
import { castArray } from "./index";
export = castArray;

2
types/lodash/ts3.1/ceil.d.ts vendored
View File

@ -1,2 +0,0 @@
import { ceil } from "./index";
export = ceil;

2
types/lodash/ts3.1/chain.d.ts vendored
View File

@ -1,2 +0,0 @@
import { chain } from "./index";
export = chain;

2
types/lodash/ts3.1/chunk.d.ts vendored
View File

@ -1,2 +0,0 @@
import { chunk } from "./index";
export = chunk;

2
types/lodash/ts3.1/clamp.d.ts vendored
View File

@ -1,2 +0,0 @@
import { clamp } from "./index";
export = clamp;

2
types/lodash/ts3.1/clone.d.ts vendored
View File

@ -1,2 +0,0 @@
import { clone } from "./index";
export = clone;

2
types/lodash/ts3.1/cloneDeep.d.ts vendored
View File

@ -1,2 +0,0 @@
import { cloneDeep } from "./index";
export = cloneDeep;

2
types/lodash/ts3.1/cloneDeepWith.d.ts vendored
View File

@ -1,2 +0,0 @@
import { cloneDeepWith } from "./index";
export = cloneDeepWith;

2
types/lodash/ts3.1/cloneWith.d.ts vendored
View File

@ -1,2 +0,0 @@
import { cloneWith } from "./index";
export = cloneWith;

2127
types/lodash/ts3.1/common/array.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

1930
types/lodash/ts3.1/common/collection.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

284
types/lodash/ts3.1/common/common.d.ts vendored
View File

@ -1,284 +0,0 @@
import _ = require("../index");
// tslint:disable-next-line:strict-export-declare-modifiers
type GlobalPartial<T> = Partial<T>;
declare module "../index" {
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.
* Methods that operate on and return arrays, collections, and functions can be chained together.
* Methods that retrieve a single value or may return a primitive value will automatically end the
* chain sequence and return the unwrapped value. Otherwise, the value must be unwrapped with value().
*
* Explicit chain sequences, which must be unwrapped with value(), may be enabled using _.chain.
*
* The execution of chained methods is lazy, that is, it's deferred until value() is
* implicitly or explicitly called.
*
* Lazy evaluation allows several methods to support shortcut fusion. Shortcut fusion
* is an optimization to merge iteratee calls; this avoids the creation of intermediate
* arrays and can greatly reduce the number of iteratee executions. Sections of a chain
* sequence qualify for shortcut fusion if the section is applied to an array and iteratees
* accept only one argument. The heuristic for whether a section qualifies for shortcut
* fusion is subject to change.
*
* Chaining is supported in custom builds as long as the value() method is directly or
* indirectly included in the build.
*
* In addition to lodash methods, wrappers have Array and String methods.
* The wrapper Array methods are:
* concat, join, pop, push, shift, sort, splice, and unshift.
* The wrapper String methods are:
* replace and split.
*
* The wrapper methods that support shortcut fusion are:
* at, compact, drop, dropRight, dropWhile, filter, find, findLast, head, initial, last,
* map, reject, reverse, slice, tail, take, takeRight, takeRightWhile, takeWhile, and toArray
*
* The chainable wrapper methods are:
* after, ary, assign, assignIn, assignInWith, assignWith, at, before, bind, bindAll, bindKey,
* castArray, chain, chunk, commit, compact, concat, conforms, constant, countBy, create,
* curry, debounce, defaults, defaultsDeep, defer, delay, difference, differenceBy, differenceWith,
* drop, dropRight, dropRightWhile, dropWhile, extend, extendWith, fill, filter, flatMap,
* flatMapDeep, flatMapDepth, flatten, flattenDeep, flattenDepth, flip, flow, flowRight,
* fromPairs, functions, functionsIn, groupBy, initial, intersection, intersectionBy, intersectionWith,
* invert, invertBy, invokeMap, iteratee, keyBy, keys, keysIn, map, mapKeys, mapValues,
* matches, matchesProperty, memoize, merge, mergeWith, method, methodOf, mixin, negate,
* nthArg, omit, omitBy, once, orderBy, over, overArgs, overEvery, overSome, partial, partialRight,
* partition, pick, pickBy, plant, property, propertyOf, pull, pullAll, pullAllBy, pullAllWith, pullAt,
* push, range, rangeRight, rearg, reject, remove, rest, reverse, sampleSize, set, setWith,
* shuffle, slice, sort, sortBy, sortedUniq, sortedUniqBy, splice, spread, tail, take,
* takeRight, takeRightWhile, takeWhile, tap, throttle, thru, toArray, toPairs, toPairsIn,
* toPath, toPlainObject, transform, unary, union, unionBy, unionWith, uniq, uniqBy, uniqWith,
* unset, unshift, unzip, unzipWith, update, updateWith, values, valuesIn, without, wrap,
* xor, xorBy, xorWith, zip, zipObject, zipObjectDeep, and zipWith.
*
* The wrapper methods that are not chainable by default are:
* add, attempt, camelCase, capitalize, ceil, clamp, clone, cloneDeep, cloneDeepWith, cloneWith,
* conformsTo, deburr, defaultTo, divide, each, eachRight, endsWith, eq, escape, escapeRegExp,
* every, find, findIndex, findKey, findLast, findLastIndex, findLastKey, first, floor, forEach,
* forEachRight, forIn, forInRight, forOwn, forOwnRight, get, gt, gte, has, hasIn, head,
* identity, includes, indexOf, inRange, invoke, isArguments, isArray, isArrayBuffer,
* isArrayLike, isArrayLikeObject, isBoolean, isBuffer, isDate, isElement, isEmpty, isEqual, isEqualWith,
* isError, isFinite, isFunction, isInteger, isLength, isMap, isMatch, isMatchWith, isNaN,
* isNative, isNil, isNull, isNumber, isObject, isObjectLike, isPlainObject, isRegExp,
* isSafeInteger, isSet, isString, isUndefined, isTypedArray, isWeakMap, isWeakSet, join,
* kebabCase, last, lastIndexOf, lowerCase, lowerFirst, lt, lte, max, maxBy, mean, meanBy,
* min, minBy, multiply, noConflict, noop, now, nth, pad, padEnd, padStart, parseInt, pop,
* random, reduce, reduceRight, repeat, result, round, runInContext, sample, shift, size,
* snakeCase, some, sortedIndex, sortedIndexBy, sortedLastIndex, sortedLastIndexBy, startCase,
* startsWith, stubArray, stubFalse, stubObject, stubString, stubTrue, subtract, sum, sumBy,
* template, times, toFinite, toInteger, toJSON, toLength, toLower, toNumber, toSafeInteger,
* toString, toUpper, trim, trimEnd, trimStart, truncate, unescape, uniqueId, upperCase,
* upperFirst, value, and words.
**/
<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.
**/
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: 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.
* @param value The value to cache.
* @return Returns the cache object.
*/
set(key: any, value: any): this;
/**
* Removes all key-value entries from the map.
*/
clear?: () => void;
}
interface MapCacheConstructor {
new (): MapCache;
}
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 PrimitiveChain<T> extends LoDashExplicitWrapper<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;
type ValueKeyIteratee<T> = ((value: T, key: string) => NotVoid) | IterateeShorthand<T>;
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>;
/** 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<unknown>
| NumericDictionary<unknown>;
interface Cancelable {
cancel(): void;
flush(): void;
}
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>;
type LoDashImplicitObjectWrapper<T> = LoDashImplicitWrapper<T>;
type LoDashImplicitNillableObjectWrapper<T> = LoDashImplicitWrapper<T | null | undefined>;
type LoDashImplicitNumberArrayWrapper = LoDashImplicitWrapper<number[]>;
type LoDashImplicitStringWrapper = LoDashImplicitWrapper<string>;
type LoDashExplicitArrayWrapper<T> = LoDashExplicitWrapper<T[]>;
type LoDashExplicitNillableArrayWrapper<T> = LoDashExplicitWrapper<T[] | null | undefined>;
type LoDashExplicitObjectWrapper<T> = LoDashExplicitWrapper<T>;
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>;
// NOTE: keys of objects at run time are always strings, even when a NumericDictionary is being iterated.
type NumericDictionaryIterator<T, TResult> = (value: T, key: string, collection: NumericDictionary<T>) => TResult;
type NumericDictionaryIteratee<T> = NumericDictionaryIterator<T, NotVoid> | IterateeShorthand<T>;
type NumericDictionaryIterateeCustom<T, TResult> = NumericDictionaryIterator<T, TResult> | IterateeShorthand<T>;
}

23
types/lodash/ts3.1/common/date.d.ts vendored
View File

@ -1,23 +0,0 @@
import _ = require("../index");
declare module "../index" {
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(): PrimitiveChain<number>;
}
}

1392
types/lodash/ts3.1/common/function.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

1693
types/lodash/ts3.1/common/lang.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

405
types/lodash/ts3.1/common/math.d.ts vendored
View File

@ -1,405 +0,0 @@
import _ = require("../index");
declare module "../index" {
interface LoDashStatic {
/**
* Adds two numbers.
*
* @param augend The first number to add.
* @param addend The second number to add.
* @return Returns the sum.
*/
add(augend: number, addend: number): number;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.add
*/
add(addend: number): number;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.add
*/
add(addend: number): PrimitiveChain<number>;
}
interface LoDashStatic {
/**
* Calculates n rounded up to precision.
*
* @param n The number to round up.
* @param precision The precision to round up to.
* @return Returns the rounded up number.
*/
ceil(n: number, precision?: number): number;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.ceil
*/
ceil(precision?: number): number;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.ceil
*/
ceil(precision?: number): PrimitiveChain<number>;
}
interface LoDashStatic {
/**
* Divide two numbers.
*
* @param dividend The first number in a division.
* @param divisor The second number in a division.
* @returns Returns the quotient.
*/
divide(dividend: number, divisor: number): number;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.divide
*/
divide(divisor: number): number;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.divide
*/
divide(divisor: number): PrimitiveChain<number>;
}
interface LoDashStatic {
/**
* Calculates n rounded down to precision.
*
* @param n The number to round down.
* @param precision The precision to round down to.
* @return Returns the rounded down number.
*/
floor(n: number, precision?: number): number;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.floor
*/
floor(precision?: number): number;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.floor
*/
floor(precision?: number): PrimitiveChain<number>;
}
interface LoDashStatic {
/**
* Computes the maximum value of `array`. If `array` is empty or falsey
* `undefined` is returned.
*
* @category Math
* @param array The array to iterate over.
* @returns Returns the maximum value.
*/
max<T>(collection: List<T> | null | undefined): T | undefined;
}
interface Collection<T> {
/**
* @see _.max
*/
max(): T | undefined;
}
interface CollectionChain<T> {
/**
* @see _.max
*/
max(): ExpChain<T | undefined>;
}
interface LoDashStatic {
/**
* This method is like `_.max` except that it accepts `iteratee` which is
* invoked for each element in `array` to generate the criterion by which
* the value is ranked. The iteratee is invoked with one argument: (value).
*
* @category Math
* @param array The array to iterate over.
* @param iteratee The iteratee invoked per element.
* @returns Returns the maximum value.
* @example
*
* var objects = [{ 'n': 1 }, { 'n': 2 }];
*
* _.maxBy(objects, function(o) { return o.a; });
* // => { 'n': 2 }
*
* // using the `_.property` iteratee shorthand
* _.maxBy(objects, 'n');
* // => { 'n': 2 }
*/
maxBy<T>(collection: List<T> | null | undefined, iteratee?: ValueIteratee<T>): T | undefined;
}
interface Collection<T> {
/**
* @see _.maxBy
*/
maxBy(iteratee?: ValueIteratee<T>): T | undefined;
}
interface CollectionChain<T> {
/**
* @see _.maxBy
*/
maxBy(iteratee?: ValueIteratee<T>): ExpChain<T | undefined>;
}
interface LoDashStatic {
/**
* Computes the mean of the values in `array`.
*
* @category Math
* @param array The array to iterate over.
* @returns Returns the mean.
* @example
*
* _.mean([4, 2, 8, 6]);
* // => 5
*/
mean(collection: List<any> | null | undefined): number;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.mean
*/
mean(): number;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.mean
*/
mean(): PrimitiveChain<number>;
}
interface LoDashStatic {
/**
* Computes the mean of the provided propties of the objects in the `array`
*
* @category Math
* @param array The array to iterate over.
* @param iteratee The iteratee invoked per element.
* @returns Returns the mean.
* @example
*
* _.mean([{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }], 'n');
* // => 5
*/
meanBy<T>(collection: List<T> | null | undefined, iteratee?: ValueIteratee<T>): number;
}
interface Collection<T> {
/**
* @see _.meanBy
*/
meanBy(iteratee?: ValueIteratee<T>): number;
}
interface CollectionChain<T> {
/**
* @see _.meanBy
*/
meanBy(iteratee?: ValueIteratee<T>): PrimitiveChain<number>;
}
interface LoDashStatic {
/**
* Computes the minimum value of `array`. If `array` is empty or falsey
* `undefined` is returned.
*
* @category Math
* @param array The array to iterate over.
* @returns Returns the minimum value.
*/
min<T>(collection: List<T> | null | undefined): T | undefined;
}
interface Collection<T> {
/**
* @see _.min
*/
min(): T | undefined;
}
interface CollectionChain<T> {
/**
* @see _.min
*/
min(): ExpChain<T | undefined>;
}
interface LoDashStatic {
/**
* This method is like `_.min` except that it accepts `iteratee` which is
* invoked for each element in `array` to generate the criterion by which
* the value is ranked. The iteratee is invoked with one argument: (value).
*
* @category Math
* @param array The array to iterate over.
* @param iteratee The iteratee invoked per element.
* @returns Returns the minimum value.
* @example
*
* var objects = [{ 'n': 1 }, { 'n': 2 }];
*
* _.minBy(objects, function(o) { return o.a; });
* // => { 'n': 1 }
*
* // using the `_.property` iteratee shorthand
* _.minBy(objects, 'n');
* // => { 'n': 1 }
*/
minBy<T>(collection: List<T> | null | undefined, iteratee?: ValueIteratee<T>): T | undefined;
}
interface Collection<T> {
/**
* @see _.minBy
*/
minBy(iteratee?: ValueIteratee<T>): T | undefined;
}
interface CollectionChain<T> {
/**
* @see _.minBy
*/
minBy(iteratee?: ValueIteratee<T>): ExpChain<T | undefined>;
}
interface LoDashStatic {
/**
* Multiply two numbers.
* @param multiplier The first number in a multiplication.
* @param multiplicand The second number in a multiplication.
* @returns Returns the product.
*/
multiply(multiplier: number, multiplicand: number): number;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.multiply
*/
multiply(multiplicand: number): number;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.multiply
*/
multiply(multiplicand: number): PrimitiveChain<number>;
}
interface LoDashStatic {
/**
* Calculates n rounded to precision.
*
* @param n The number to round.
* @param precision The precision to round to.
* @return Returns the rounded number.
*/
round(n: number, precision?: number): number;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.round
*/
round(precision?: number): number;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.round
*/
round(precision?: number): PrimitiveChain<number>;
}
interface LoDashStatic {
/**
* Subtract two numbers.
*
* @category Math
* @param minuend The first number in a subtraction.
* @param subtrahend The second number in a subtraction.
* @returns Returns the difference.
* @example
*
* _.subtract(6, 4);
* // => 2
*/
subtract(minuend: number, subtrahend: number): number;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.subtract
*/
subtract(subtrahend: number): number;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.subtract
*/
subtract(subtrahend: number): PrimitiveChain<number>;
}
interface LoDashStatic {
/**
* Computes the sum of the values in `array`.
*
* @category Math
* @param array The array to iterate over.
* @returns Returns the sum.
* @example
*
* _.sum([4, 2, 8, 6]);
* // => 20
*/
sum(collection: List<any> | null | undefined): number;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.sum
*/
sum(): number;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.sum
*/
sum(): PrimitiveChain<number>;
}
interface LoDashStatic {
/**
* This method is like `_.sum` except that it accepts `iteratee` which is
* invoked for each element in `array` to generate the value to be summed.
* The iteratee is invoked with one argument: (value).
*
* @category Math
* @param array The array to iterate over.
* @param [iteratee=_.identity] The iteratee invoked per element.
* @returns Returns the sum.
* @example
*
* var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
*
* _.sumBy(objects, function(o) { return o.n; });
* // => 20
*
* // using the `_.property` iteratee shorthand
* _.sumBy(objects, 'n');
* // => 20
*/
sumBy<T>(collection: List<T> | null | undefined, iteratee?: ((value: T) => number) | string): number;
}
interface Collection<T> {
/**
* @see _.sumBy
*/
sumBy(iteratee?: ((value: T) => number) | string): number;
}
interface CollectionChain<T> {
/**
* @see _.sumBy
*/
sumBy(iteratee?: ((value: T) => number) | string): PrimitiveChain<number>;
}
}

131
types/lodash/ts3.1/common/number.d.ts vendored
View File

@ -1,131 +0,0 @@
import _ = require("../index");
declare module "../index" {
// clamp
interface LoDashStatic {
/**
* Clamps `number` within the inclusive `lower` and `upper` bounds.
*
* @category Number
* @param number The number to clamp.
* @param [lower] The lower bound.
* @param upper The upper bound.
* @returns Returns the clamped number.
* @example
*
* _.clamp(-10, -5, 5);
* // => -5
*
* _.clamp(10, -5, 5);
* // => 5
* Clamps `number` within the inclusive `lower` and `upper` bounds.
*
* @category Number
* @param number The number to clamp.
* @param [lower] The lower bound.
* @param upper The upper bound.
* @returns Returns the clamped number.
* @example
*
* _.clamp(-10, -5, 5);
* // => -5
*
* _.clamp(10, -5, 5);
*/
clamp(number: number, lower: number, upper: number): number;
/**
* @see _.clamp
*/
clamp(number: number, upper: number): number;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.clamp
*/
clamp(lower: number, upper: number): number;
/**
* @see _.clamp
*/
clamp(upper: number): number;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.clamp
*/
clamp(lower: number, upper: number): PrimitiveChain<number>;
/**
* @see _.clamp
*/
clamp(upper: number): PrimitiveChain<number>;
}
// inRange
interface LoDashStatic {
/**
* Checks if n is between start and up to but not including, end. If end is not specified it’s set to start
* with start then set to 0.
*
* @param n The number to check.
* @param start The start of the range.
* @param end The end of the range.
* @return Returns true if n is in the range, else false.
*/
inRange(n: number, start: number, end?: number): boolean;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.inRange
*/
inRange(start: number, end?: number): boolean;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.inRange
*/
inRange(start: number, end?: number): PrimitiveChain<boolean>;
}
// random
interface LoDashStatic {
/**
* Produces a random number between min and max (inclusive). If only one argument is provided a number between
* 0 and the given number is returned. If floating is true, or either min or max are floats, a floating-point
* number is returned instead of an integer.
*
* @param min The minimum possible value.
* @param max The maximum possible value.
* @param floating Specify returning a floating-point number.
* @return Returns the random number.
*/
random(floating?: boolean): number;
/**
* @see _.random
*/
random(max: number, floating?: boolean): number;
/**
* @see _.random
*/
random(min: number, max: number, floating?: boolean): number;
/**
* @see _.random
*/
random(min: number, index: string | number, guard: object): number;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.random
*/
random(floating?: boolean): number;
/**
* @see _.random
*/
random(max: number, floating?: boolean): number;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.random
*/
random(floating?: boolean): PrimitiveChain<number>;
/**
* @see _.random
*/
random(max: number, floating?: boolean): PrimitiveChain<number>;
}
}

2507
types/lodash/ts3.1/common/object.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

210
types/lodash/ts3.1/common/seq.d.ts vendored
View File

@ -1,210 +0,0 @@
import _ = require("../index");
declare module "../index" {
// chain
interface LoDashStatic {
/**
* Creates a lodash object that wraps value with explicit method chaining enabled.
*
* @param value The value to wrap.
* @return Returns the new lodash wrapper instance.
*/
chain<TrapAny extends { __lodashAnyHack: any }>(value: TrapAny): CollectionChain<any> & FunctionChain<any> & ObjectChain<any> & PrimitiveChain<any> & StringChain;
/**
* @see _.chain
*/
chain<T extends null | undefined>(value: T): PrimitiveChain<T>;
/**
* @see _.chain
*/
chain(value: string): StringChain;
/**
* @see _.chain
*/
chain(value: string | null | undefined): StringNullableChain;
/**
* @see _.chain
*/
chain<T extends (...args: any[]) => any>(value: T): FunctionChain<T>;
/**
* @see _.chain
*/
chain<T = any>(value: List<T> | null | undefined): CollectionChain<T>;
/**
* @see _.chain
*/
chain<T extends object>(value: T | null | undefined): ObjectChain<T>;
/**
* @see _.chain
*/
chain<T>(value: T): PrimitiveChain<T>;
}
interface Collection<T> {
/**
* @see _.chain
*/
chain(): CollectionChain<T>;
}
interface String {
/**
* @see _.chain
*/
chain(): StringChain;
}
interface Object<T> {
/**
* @see _.chain
*/
chain(): ObjectChain<T>;
}
interface Primitive<T> {
/**
* @see _.chain
*/
chain(): PrimitiveChain<T>;
}
interface Function<T extends (...args: any) => any> {
/**
* @see _.chain
*/
chain(): FunctionChain<T>;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.chain
*/
chain(): this;
}
// prototype.commit
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.commit
*/
commit(): this;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.commit
*/
commit(): this;
}
// prototype.plant
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.plant
*/
plant(value: unknown): this;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.plant
*/
plant(value: unknown): this;
}
// prototype.reverse
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.reverse
*/
reverse(): this;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.reverse
*/
reverse(): this;
}
// prototype.toJSON
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.toJSON
*/
toJSON(): TValue;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.toJSON
*/
toJSON(): TValue;
}
// prototype.toString
interface LoDashWrapper<TValue> {
/**
* @see _.toString
*/
toString(): string;
}
// prototype.value
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.value
*/
value(): TValue;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.value
*/
value(): TValue;
}
// prototype.valueOf
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.valueOf
*/
valueOf(): TValue;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.valueOf
*/
valueOf(): TValue;
}
// tap
interface LoDashStatic {
/**
* This method invokes interceptor and returns value. The interceptor is invoked with one
* argument; (value). The purpose of this method is to "tap into" a method chain in order to perform operations
* on intermediate results within the chain.
*
* @param value The value to provide to interceptor.
* @param interceptor The function to invoke.
* @return Returns value.
*/
tap<T>(value: T, interceptor: (value: T) => void): T;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.tap
*/
tap(interceptor: (value: TValue) => void): this;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.tap
*/
tap(interceptor: (value: TValue) => void): this;
}
// thru
interface LoDashStatic {
/**
* This method is like _.tap except that it returns the result of interceptor.
*
* @param value The value to provide to interceptor.
* @param interceptor The function to invoke.
* @return Returns the result of interceptor.
*/
thru<T, TResult>(value: T, interceptor: (value: T) => TResult): TResult;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.thru
*/
thru<TResult>(interceptor: (value: TValue) => TResult): ImpChain<TResult>;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.thru
*/
thru<TResult>(interceptor: (value: TValue) => TResult): ExpChain<TResult>;
}
}

788
types/lodash/ts3.1/common/string.d.ts vendored
View File

@ -1,788 +0,0 @@
import _ = require("../index");
declare module "../index" {
interface LoDashStatic {
/**
* Converts string to camel case.
*
* @param string The string to convert.
* @return Returns the camel cased string.
*/
camelCase(string?: string): string;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.camelCase
*/
camelCase(): string;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.camelCase
*/
camelCase(): StringChain;
}
interface LoDashStatic {
/**
* Converts the first character of string to upper case and the remaining to lower case.
*
* @param string The string to capitalize.
* @return Returns the capitalized string.
*/
capitalize(string?: string): string;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.capitalize
*/
capitalize(): string;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.capitalize
*/
capitalize(): StringChain;
}
interface LoDashStatic {
/**
* Deburrs string by converting latin-1 supplementary letters to basic latin letters and removing combining
* diacritical marks.
*
* @param string The string to deburr.
* @return Returns the deburred string.
*/
deburr(string?: string): string;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.deburr
*/
deburr(): string;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.deburr
*/
deburr(): StringChain;
}
interface LoDashStatic {
/**
* Checks if string ends with the given target string.
*
* @param string The string to search.
* @param target The string to search for.
* @param position The position to search from.
* @return Returns true if string ends with target, else false.
*/
endsWith(string?: string, target?: string, position?: number): boolean;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.endsWith
*/
endsWith(target?: string, position?: number): boolean;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.endsWith
*/
endsWith(target?: string, position?: number): PrimitiveChain<boolean>;
}
interface LoDashStatic {
/**
* Converts the characters "&", "<", ">", '"', "'", and "`" in string to their corresponding HTML entities.
*
* Note: No other characters are escaped. To escape additional characters use a third-party library like he.
*
* hough the ">" character is escaped for symmetry, characters like ">" and "/" don’t need escaping in HTML
* and have no special meaning unless they're part of a tag or unquoted attribute value. See Mathias Bynens’s
* article (under "semi-related fun fact") for more details.
*
* Backticks are escaped because in IE < 9, they can break out of attribute values or HTML comments. See #59,
* #102, #108, and #133 of the HTML5 Security Cheatsheet for more details.
*
* When working with HTML you should always quote attribute values to reduce XSS vectors.
*
* @param string The string to escape.
* @return Returns the escaped string.
*/
escape(string?: string): string;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.escape
*/
escape(): string;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.escape
*/
escape(): StringChain;
}
interface LoDashStatic {
/**
* Escapes the RegExp special characters "^", "$", "\", ".", "*", "+", "?", "(", ")", "[", "]",
* "{", "}", and "|" in string.
*
* @param string The string to escape.
* @return Returns the escaped string.
*/
escapeRegExp(string?: string): string;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.escapeRegExp
*/
escapeRegExp(): string;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.escapeRegExp
*/
escapeRegExp(): StringChain;
}
interface LoDashStatic {
/**
* Converts string to kebab case.
*
* @param string The string to convert.
* @return Returns the kebab cased string.
*/
kebabCase(string?: string): string;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.kebabCase
*/
kebabCase(): string;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.kebabCase
*/
kebabCase(): StringChain;
}
interface LoDashStatic {
/**
* Converts `string`, as space separated words, to lower case.
*
* @param string The string to convert.
* @return Returns the lower cased string.
*/
lowerCase(string?: string): string;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.lowerCase
*/
lowerCase(): string;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.lowerCase
*/
lowerCase(): StringChain;
}
interface LoDashStatic {
/**
* Converts the first character of `string` to lower case.
*
* @param string The string to convert.
* @return Returns the converted string.
*/
lowerFirst(string?: string): string;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.lowerFirst
*/
lowerFirst(): string;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.lowerFirst
*/
lowerFirst(): StringChain;
}
interface LoDashStatic {
/**
* Pads string on the left and right sides if it’s shorter than length. Padding characters are truncated if
* they can’t be evenly divided by length.
*
* @param string The string to pad.
* @param length The padding length.
* @param chars The string used as padding.
* @return Returns the padded string.
*/
pad(string?: string, length?: number, chars?: string): string;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.pad
*/
pad(length?: number, chars?: string): string;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.pad
*/
pad(length?: number, chars?: string): StringChain;
}
interface LoDashStatic {
/**
* Pads string on the right side if it’s shorter than length. Padding characters are truncated if they exceed
* length.
*
* @param string The string to pad.
* @param length The padding length.
* @param chars The string used as padding.
* @return Returns the padded string.
*/
padEnd(string?: string, length?: number, chars?: string): string;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.padEnd
*/
padEnd(length?: number, chars?: string): string;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.padEnd
*/
padEnd(length?: number, chars?: string): StringChain;
}
interface LoDashStatic {
/**
* Pads string on the left side if it’s shorter than length. Padding characters are truncated if they exceed
* length.
*
* @param string The string to pad.
* @param length The padding length.
* @param chars The string used as padding.
* @return Returns the padded string.
*/
padStart(string?: string, length?: number, chars?: string): string;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.padStart
*/
padStart(length?: number, chars?: string): string;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.padStart
*/
padStart(length?: number, chars?: string): StringChain;
}
interface LoDashStatic {
/**
* Converts string to an integer of the specified radix. If radix is undefined or 0, a radix of 10 is used
* unless value is a hexadecimal, in which case a radix of 16 is used.
*
* Note: This method aligns with the ES5 implementation of parseInt.
*
* @param string The string to convert.
* @param radix The radix to interpret value by.
* @return Returns the converted integer.
*/
parseInt(string: string, radix?: number): number;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.parseInt
*/
parseInt(radix?: number): number;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.parseInt
*/
parseInt(radix?: number): PrimitiveChain<number>;
}
interface LoDashStatic {
/**
* Repeats the given string n times.
*
* @param string The string to repeat.
* @param n The number of times to repeat the string.
* @return Returns the repeated string.
*/
repeat(string?: string, n?: number): string;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.repeat
*/
repeat(n?: number): string;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.repeat
*/
repeat(n?: number): StringChain;
}
type ReplaceFunction = (match: string, ...args: any[]) => string;
interface LoDashStatic {
/**
* Replaces matches for pattern in string with replacement.
*
* Note: This method is based on String#replace.
*
* @return Returns the modified string.
*/
replace(string: string, pattern: RegExp | string, replacement: ReplaceFunction | string): string;
/**
* @see _.replace
*/
replace(pattern: RegExp | string, replacement: ReplaceFunction | string): string;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.replace
*/
replace(pattern: RegExp | string, replacement: ReplaceFunction | string): string;
/**
* @see _.replace
*/
replace(replacement: ReplaceFunction | string): string;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.replace
*/
replace(pattern: RegExp | string, replacement: ReplaceFunction | string): StringChain;
/**
* @see _.replace
*/
replace(replacement: ReplaceFunction | string): StringChain;
}
interface LoDashStatic {
/**
* Converts string to snake case.
*
* @param string The string to convert.
* @return Returns the snake cased string.
*/
snakeCase(string?: string): string;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.snakeCase
*/
snakeCase(): string;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.snakeCase
*/
snakeCase(): StringChain;
}
interface LoDashStatic {
/**
* Splits string by separator.
*
* Note: This method is based on String#split.
*
* @param string The string to split.
* @param separator The separator pattern to split by.
* @param limit The length to truncate results to.
* @return Returns the new array of string segments.
*/
split(string: string | null | undefined, separator?: RegExp | string, limit?: number): string[];
/**
* @see _.split
*/
split(string: string | null | undefined, index: string | number, guard: object): string[];
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.split
*/
split(separator?: RegExp | string, limit?: number): Collection<string>;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.split
*/
split(separator?: RegExp | string, limit?: number): CollectionChain<string>;
}
interface LoDashStatic {
/**
* Converts string to start case.
*
* @param string The string to convert.
* @return Returns the start cased string.
*/
startCase(string?: string): string;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.startCase
*/
startCase(): string;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.startCase
*/
startCase(): StringChain;
}
interface LoDashStatic {
/**
* Checks if string starts with the given target string.
*
* @param string The string to search.
* @param target The string to search for.
* @param position The position to search from.
* @return Returns true if string starts with target, else false.
*/
startsWith(string?: string, target?: string, position?: number): boolean;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.startsWith
*/
startsWith(target?: string, position?: number): boolean;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.startsWith
*/
startsWith(target?: string, position?: number): PrimitiveChain<boolean>;
}
interface TemplateOptions extends TemplateSettings {
/**
* @see _.sourceURL
*/
sourceURL?: string;
}
interface TemplateExecutor {
(data?: object): string;
/**
* @see _.source
*/
source: string;
}
interface LoDashStatic {
/**
* Creates a compiled template function that can interpolate data properties in "interpolate" delimiters,
* HTML-escape interpolated data properties in "escape" delimiters, and execute JavaScript in "evaluate"
* delimiters. Data properties may be accessed as free variables in the template. If a setting object is
* provided it takes precedence over _.templateSettings values.
*
* Note: In the development build _.template utilizes
* [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl) for easier
* debugging.
*
* For more information on precompiling templates see
* [lodash's custom builds documentation](https://lodash.com/custom-builds).
*
* For more information on Chrome extension sandboxes see
* [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval).
*
* @param string The template string.
* @param options The options object.
* @param options.escape The HTML "escape" delimiter.
* @param options.evaluate The "evaluate" delimiter.
* @param options.imports An object to import into the template as free variables.
* @param options.interpolate The "interpolate" delimiter.
* @param options.sourceURL The sourceURL of the template's compiled source.
* @param options.variable The data object variable name.
* @return Returns the compiled template function.
*/
template(string?: string, options?: TemplateOptions): TemplateExecutor;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.template
*/
template(options?: TemplateOptions): TemplateExecutor;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.template
*/
template(options?: TemplateOptions): FunctionChain<TemplateExecutor>;
}
interface LoDashStatic {
/**
* Converts `string`, as a whole, to lower case.
*
* @param string The string to convert.
* @return Returns the lower cased string.
*/
toLower(string?: string): string;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.toLower
*/
toLower(): string;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.toLower
*/
toLower(): StringChain;
}
interface LoDashStatic {
/**
* Converts `string`, as a whole, to upper case.
*
* @param string The string to convert.
* @return Returns the upper cased string.
*/
toUpper(string?: string): string;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.toUpper
*/
toUpper(): string;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.toUpper
*/
toUpper(): StringChain;
}
interface LoDashStatic {
/**
* Removes leading and trailing whitespace or specified characters from string.
*
* @param string The string to trim.
* @param chars The characters to trim.
* @return Returns the trimmed string.
*/
trim(string?: string, chars?: string): string;
/**
* @see _.trim
*/
trim(string: string, index: string | number, guard: object): string;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.trim
*/
trim(chars?: string): string;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.trim
*/
trim(chars?: string): StringChain;
}
interface LoDashStatic {
/**
* Removes trailing whitespace or specified characters from string.
*
* @param string The string to trim.
* @param chars The characters to trim.
* @return Returns the trimmed string.
*/
trimEnd(string?: string, chars?: string): string;
/**
* @see _.trimEnd
*/
trimEnd(string: string, index: string | number, guard: object): string;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.trimEnd
*/
trimEnd(chars?: string): string;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.trimEnd
*/
trimEnd(chars?: string): StringChain;
}
interface LoDashStatic {
/**
* Removes leading whitespace or specified characters from string.
*
* @param string The string to trim.
* @param chars The characters to trim.
* @return Returns the trimmed string.
*/
trimStart(string?: string, chars?: string): string;
/**
* @see _.trimStart
*/
trimStart(string: string, index: string | number, guard: object): string;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.trimStart
*/
trimStart(chars?: string): string;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.trimStart
*/
trimStart(chars?: string): StringChain;
}
interface TruncateOptions {
/**
* @see _.length
*/
length?: number;
/**
* @see _.omission
*/
omission?: string;
/**
* @see _.separator
*/
separator?: string | RegExp;
}
interface LoDashStatic {
/**
* Truncates string if it’s longer than the given maximum string length. The last characters of the truncated
* string are replaced with the omission string which defaults to "…".
*
* @param string The string to truncate.
* @param options The options object or maximum string length.
* @return Returns the truncated string.
*/
truncate(string?: string, options?: TruncateOptions): string;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.truncate
*/
truncate(options?: TruncateOptions): string;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.truncate
*/
truncate(options?: TruncateOptions): StringChain;
}
interface LoDashStatic {
/**
* The inverse of _.escape; this method converts the HTML entities &amp;, &lt;, &gt;, &quot;, &#39;, and &#96;
* in string to their corresponding characters.
*
* Note: No other HTML entities are unescaped. To unescape additional HTML entities use a third-party library
* like he.
*
* @param string The string to unescape.
* @return Returns the unescaped string.
*/
unescape(string?: string): string;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.unescape
*/
unescape(): string;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.unescape
*/
unescape(): StringChain;
}
interface LoDashStatic {
/**
* Converts `string`, as space separated words, to upper case.
*
* @param string The string to convert.
* @return Returns the upper cased string.
*/
upperCase(string?: string): string;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.upperCase
*/
upperCase(): string;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.upperCase
*/
upperCase(): StringChain;
}
interface LoDashStatic {
/**
* Converts the first character of `string` to upper case.
*
* @param string The string to convert.
* @return Returns the converted string.
*/
upperFirst(string?: string): string;
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.upperFirst
*/
upperFirst(): string;
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.upperFirst
*/
upperFirst(): StringChain;
}
interface LoDashStatic {
/**
* Splits `string` into an array of its words.
*
* @param string The string to inspect.
* @param pattern The pattern to match words.
* @return Returns the words of `string`.
*/
words(string?: string, pattern?: string | RegExp): string[];
/**
* @see _.words
*/
words(string: string, index: string | number, guard: object): string[];
}
interface LoDashImplicitWrapper<TValue> {
/**
* @see _.words
*/
words(pattern?: string | RegExp): string[];
}
interface LoDashExplicitWrapper<TValue> {
/**
* @see _.words
*/
words(pattern?: string | RegExp): CollectionChain<string>;
}
}

1219
types/lodash/ts3.1/common/util.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

2
types/lodash/ts3.1/compact.d.ts vendored
View File

@ -1,2 +0,0 @@
import { compact } from "./index";
export = compact;

2
types/lodash/ts3.1/concat.d.ts vendored
View File

@ -1,2 +0,0 @@
import { concat } from "./index";
export = concat;

2
types/lodash/ts3.1/cond.d.ts vendored
View File

@ -1,2 +0,0 @@
import { cond } from "./index";
export = cond;

2
types/lodash/ts3.1/conformsTo.d.ts vendored
View File

@ -1,2 +0,0 @@
import { conformsTo } from "./index";
export = conformsTo;

2
types/lodash/ts3.1/constant.d.ts vendored
View File

@ -1,2 +0,0 @@
import { constant } from "./index";
export = constant;

2
types/lodash/ts3.1/countBy.d.ts vendored
View File

@ -1,2 +0,0 @@
import { countBy } from "./index";
export = countBy;

2
types/lodash/ts3.1/create.d.ts vendored
View File

@ -1,2 +0,0 @@
import { create } from "./index";
export = create;

2
types/lodash/ts3.1/curry.d.ts vendored
View File

@ -1,2 +0,0 @@
import { curry } from "./index";
export = curry;

2
types/lodash/ts3.1/curryRight.d.ts vendored
View File

@ -1,2 +0,0 @@
import { curryRight } from "./index";
export = curryRight;

2
types/lodash/ts3.1/debounce.d.ts vendored
View File

@ -1,2 +0,0 @@
import { debounce } from "./index";
export = debounce;

2
types/lodash/ts3.1/deburr.d.ts vendored
View File

@ -1,2 +0,0 @@
import { deburr } from "./index";
export = deburr;

2
types/lodash/ts3.1/defaultTo.d.ts vendored
View File

@ -1,2 +0,0 @@
import { defaultTo } from "./index";
export = defaultTo;

2
types/lodash/ts3.1/defaults.d.ts vendored
View File

@ -1,2 +0,0 @@
import { defaults } from "./index";
export = defaults;

2
types/lodash/ts3.1/defaultsDeep.d.ts vendored
View File

@ -1,2 +0,0 @@
import { defaultsDeep } from "./index";
export = defaultsDeep;

2
types/lodash/ts3.1/defer.d.ts vendored
View File

@ -1,2 +0,0 @@
import { defer } from "./index";
export = defer;

2
types/lodash/ts3.1/delay.d.ts vendored
View File

@ -1,2 +0,0 @@
import { delay } from "./index";
export = delay;

2
types/lodash/ts3.1/difference.d.ts vendored
View File

@ -1,2 +0,0 @@
import { difference } from "./index";
export = difference;

2
types/lodash/ts3.1/differenceBy.d.ts vendored
View File

@ -1,2 +0,0 @@
import { differenceBy } from "./index";
export = differenceBy;

2
types/lodash/ts3.1/differenceWith.d.ts vendored
View File

@ -1,2 +0,0 @@
import { differenceWith } from "./index";
export = differenceWith;

2
types/lodash/ts3.1/divide.d.ts vendored
View File

@ -1,2 +0,0 @@
import { divide } from "./index";
export = divide;

2
types/lodash/ts3.1/drop.d.ts vendored
View File

@ -1,2 +0,0 @@
import { drop } from "./index";
export = drop;

2
types/lodash/ts3.1/dropRight.d.ts vendored
View File

@ -1,2 +0,0 @@
import { dropRight } from "./index";
export = dropRight;

2
types/lodash/ts3.1/dropRightWhile.d.ts vendored
View File

@ -1,2 +0,0 @@
import { dropRightWhile } from "./index";
export = dropRightWhile;

2
types/lodash/ts3.1/dropWhile.d.ts vendored
View File

@ -1,2 +0,0 @@
import { dropWhile } from "./index";
export = dropWhile;

2
types/lodash/ts3.1/each.d.ts vendored
View File

@ -1,2 +0,0 @@
import { each } from "./index";
export = each;

2
types/lodash/ts3.1/eachRight.d.ts vendored
View File

@ -1,2 +0,0 @@
import { eachRight } from "./index";
export = eachRight;

2
types/lodash/ts3.1/endsWith.d.ts vendored
View File

@ -1,2 +0,0 @@
import { endsWith } from "./index";
export = endsWith;

2
types/lodash/ts3.1/entries.d.ts vendored
View File

@ -1,2 +0,0 @@
import { entries } from "./index";
export = entries;

2
types/lodash/ts3.1/entriesIn.d.ts vendored
View File

@ -1,2 +0,0 @@
import { entriesIn } from "./index";
export = entriesIn;

2
types/lodash/ts3.1/eq.d.ts vendored
View File

@ -1,2 +0,0 @@
import { eq } from "./index";
export = eq;

2
types/lodash/ts3.1/escape.d.ts vendored
View File

@ -1,2 +0,0 @@
import { escape } from "./index";
export = escape;

2
types/lodash/ts3.1/escapeRegExp.d.ts vendored
View File

@ -1,2 +0,0 @@
import { escapeRegExp } from "./index";
export = escapeRegExp;

2
types/lodash/ts3.1/every.d.ts vendored
View File

@ -1,2 +0,0 @@
import { every } from "./index";
export = every;

2
types/lodash/ts3.1/extend.d.ts vendored
View File

@ -1,2 +0,0 @@
import { extend } from "./index";
export = extend;

2
types/lodash/ts3.1/extendWith.d.ts vendored
View File

@ -1,2 +0,0 @@
import { extendWith } from "./index";
export = extendWith;

2
types/lodash/ts3.1/fill.d.ts vendored
View File

@ -1,2 +0,0 @@
import { fill } from "./index";
export = fill;

2
types/lodash/ts3.1/filter.d.ts vendored
View File

@ -1,2 +0,0 @@
import { filter } from "./index";
export = filter;

2
types/lodash/ts3.1/find.d.ts vendored
View File

@ -1,2 +0,0 @@
import { find } from "./index";
export = find;

2
types/lodash/ts3.1/findIndex.d.ts vendored
View File

@ -1,2 +0,0 @@
import { findIndex } from "./index";
export = findIndex;

2
types/lodash/ts3.1/findKey.d.ts vendored
View File

@ -1,2 +0,0 @@
import { findKey } from "./index";
export = findKey;

2
types/lodash/ts3.1/findLast.d.ts vendored
View File

@ -1,2 +0,0 @@
import { findLast } from "./index";
export = findLast;

Some files were not shown because too many files have changed in this diff Show More