|
@@ -1,5 +1,5 @@
|
1
|
|
-// flow-typed signature: a9b75804169260d49cda34b56dcfabe1
|
2
|
|
-// flow-typed version: e9dac1347c/lodash_v4.x.x/flow_>=v0.63.x
|
|
1
|
+// flow-typed signature: 96e97db746b98786dbff6de500b4b862
|
|
2
|
+// flow-typed version: 5fe02f287a/lodash_v4.x.x/flow_>=v0.63.x <=v0.103.x
|
3
|
3
|
|
4
|
4
|
declare module "lodash" {
|
5
|
5
|
declare type Path = $ReadOnlyArray<string | number> | string | number;
|
|
@@ -149,6 +149,11 @@ declare module "lodash" {
|
149
|
149
|
separator?: RegExp | string
|
150
|
150
|
};
|
151
|
151
|
|
|
152
|
+ declare type Cancelable = {
|
|
153
|
+ cancel: () => void,
|
|
154
|
+ flush: () => mixed
|
|
155
|
+ };
|
|
156
|
+
|
152
|
157
|
declare type DebounceOptions = {
|
153
|
158
|
leading?: boolean,
|
154
|
159
|
maxWait?: number,
|
|
@@ -265,14 +270,14 @@ declare module "lodash" {
|
265
|
270
|
): -1;
|
266
|
271
|
// alias of _.head
|
267
|
272
|
first<T>(array: ?$ReadOnlyArray<T>): T;
|
268
|
|
- flatten<T, X>(array?: ?Array<Array<T> | X>): Array<T | X>;
|
|
273
|
+ flatten<T, X>(array?: ?$ReadOnlyArray<$ReadOnlyArray<T> | X>): Array<T | X>;
|
269
|
274
|
flattenDeep<T>(array?: ?(any[])): Array<T>;
|
270
|
275
|
flattenDepth(array?: ?(any[]), depth?: ?number): any[];
|
271
|
276
|
fromPairs<A, B>(pairs?: ?Array<[A, B]>): { [key: A]: B };
|
272
|
277
|
head<T>(array: ?$ReadOnlyArray<T>): T;
|
273
|
|
- indexOf<T>(array: Array<T>, value: T, fromIndex?: number): number;
|
|
278
|
+ indexOf<T>(array: $ReadOnlyArray<T>, value: T, fromIndex?: number): number;
|
274
|
279
|
indexOf<T>(array: void | null, value?: ?T, fromIndex?: ?number): -1;
|
275
|
|
- initial<T>(array: ?Array<T>): Array<T>;
|
|
280
|
+ initial<T>(array: ?$ReadOnlyArray<T>): Array<T>;
|
276
|
281
|
intersection<T>(...arrays?: Array<$ReadOnlyArray<T>>): Array<T>;
|
277
|
282
|
//Workaround until (...parameter: T, parameter2: U) works
|
278
|
283
|
intersectionBy<T>(
|
|
@@ -320,10 +325,10 @@ declare module "lodash" {
|
320
|
325
|
a4?: ?$ReadOnlyArray<T>,
|
321
|
326
|
comparator?: ?Comparator<T>
|
322
|
327
|
): Array<T>;
|
323
|
|
- join<T>(array: Array<T>, separator?: ?string): string;
|
|
328
|
+ join<T>(array: $ReadOnlyArray<T>, separator?: ?string): string;
|
324
|
329
|
join<T>(array: void | null, separator?: ?string): "";
|
325
|
330
|
last<T>(array: ?$ReadOnlyArray<T>): T;
|
326
|
|
- lastIndexOf<T>(array: Array<T>, value?: ?T, fromIndex?: ?number): number;
|
|
331
|
+ lastIndexOf<T>(array: $ReadOnlyArray<T>, value?: ?T, fromIndex?: ?number): number;
|
327
|
332
|
lastIndexOf<T>(array: void | null, value?: ?T, fromIndex?: ?number): -1;
|
328
|
333
|
nth<T>(array: T[], n?: ?number): T;
|
329
|
334
|
nth(array: void | null, n?: ?number): void;
|
|
@@ -357,10 +362,10 @@ declare module "lodash" {
|
357
|
362
|
start?: ?number,
|
358
|
363
|
end?: ?number
|
359
|
364
|
): Array<T>;
|
360
|
|
- sortedIndex<T>(array: Array<T>, value: T): number;
|
|
365
|
+ sortedIndex<T>(array: $ReadOnlyArray<T>, value: T): number;
|
361
|
366
|
sortedIndex<T>(array: void | null, value: ?T): 0;
|
362
|
367
|
sortedIndexBy<T>(
|
363
|
|
- array: Array<T>,
|
|
368
|
+ array: $ReadOnlyArray<T>,
|
364
|
369
|
value?: ?T,
|
365
|
370
|
iteratee?: ?ValueOnlyIteratee<T>
|
366
|
371
|
): number;
|
|
@@ -369,12 +374,12 @@ declare module "lodash" {
|
369
|
374
|
value?: ?T,
|
370
|
375
|
iteratee?: ?ValueOnlyIteratee<T>
|
371
|
376
|
): 0;
|
372
|
|
- sortedIndexOf<T>(array: Array<T>, value: T): number;
|
|
377
|
+ sortedIndexOf<T>(array: $ReadOnlyArray<T>, value: T): number;
|
373
|
378
|
sortedIndexOf<T>(array: void | null, value?: ?T): -1;
|
374
|
|
- sortedLastIndex<T>(array: Array<T>, value: T): number;
|
|
379
|
+ sortedLastIndex<T>(array: $ReadOnlyArray<T>, value: T): number;
|
375
|
380
|
sortedLastIndex<T>(array: void | null, value?: ?T): 0;
|
376
|
381
|
sortedLastIndexBy<T>(
|
377
|
|
- array: Array<T>,
|
|
382
|
+ array: $ReadOnlyArray<T>,
|
378
|
383
|
value: T,
|
379
|
384
|
iteratee?: ValueOnlyIteratee<T>
|
380
|
385
|
): number;
|
|
@@ -383,16 +388,16 @@ declare module "lodash" {
|
383
|
388
|
value?: ?T,
|
384
|
389
|
iteratee?: ?ValueOnlyIteratee<T>
|
385
|
390
|
): 0;
|
386
|
|
- sortedLastIndexOf<T>(array: Array<T>, value: T): number;
|
|
391
|
+ sortedLastIndexOf<T>(array: $ReadOnlyArray<T>, value: T): number;
|
387
|
392
|
sortedLastIndexOf<T>(array: void | null, value?: ?T): -1;
|
388
|
|
- sortedUniq<T>(array?: ?Array<T>): Array<T>;
|
|
393
|
+ sortedUniq<T>(array?: ?$ReadOnlyArray<T>): Array<T>;
|
389
|
394
|
sortedUniqBy<T>(
|
390
|
|
- array?: ?Array<T>,
|
|
395
|
+ array?: ?$ReadOnlyArray<T>,
|
391
|
396
|
iteratee?: ?ValueOnlyIteratee<T>
|
392
|
397
|
): Array<T>;
|
393
|
|
- tail<T>(array?: ?Array<T>): Array<T>;
|
394
|
|
- take<T>(array?: ?Array<T>, n?: ?number): Array<T>;
|
395
|
|
- takeRight<T>(array?: ?Array<T>, n?: ?number): Array<T>;
|
|
398
|
+ tail<T>(array?: ?$ReadOnlyArray<T>): Array<T>;
|
|
399
|
+ take<T>(array?: ?$ReadOnlyArray<T>, n?: ?number): Array<T>;
|
|
400
|
+ takeRight<T>(array?: ?$ReadOnlyArray<T>, n?: ?number): Array<T>;
|
396
|
401
|
takeRightWhile<T>(array?: ?Array<T>, predicate?: ?Predicate<T>): Array<T>;
|
397
|
402
|
takeWhile<T>(array?: ?Array<T>, predicate?: ?Predicate<T>): Array<T>;
|
398
|
403
|
union<T>(...arrays?: Array<$ReadOnlyArray<T>>): Array<T>;
|
|
@@ -442,59 +447,59 @@ declare module "lodash" {
|
442
|
447
|
uniq<T>(array?: ?$ReadOnlyArray<T>): Array<T>;
|
443
|
448
|
uniqBy<T>(array?: ?$ReadOnlyArray<T>, iteratee?: ?ValueOnlyIteratee<T>): Array<T>;
|
444
|
449
|
uniqWith<T>(array?: ?$ReadOnlyArray<T>, comparator?: ?Comparator<T>): Array<T>;
|
445
|
|
- unzip<T>(array?: ?Array<T>): Array<T>;
|
|
450
|
+ unzip<T>(array?: ?$ReadOnlyArray<T>): Array<T>;
|
446
|
451
|
unzipWith<T>(array: ?Array<T>, iteratee?: ?Iteratee<T>): Array<T>;
|
447
|
452
|
without<T>(array?: ?$ReadOnlyArray<T>, ...values?: Array<?T>): Array<T>;
|
448
|
453
|
xor<T>(...array: Array<Array<T>>): Array<T>;
|
449
|
454
|
//Workaround until (...parameter: T, parameter2: U) works
|
450
|
|
- xorBy<T>(a1?: ?Array<T>, iteratee?: ?ValueOnlyIteratee<T>): Array<T>;
|
|
455
|
+ xorBy<T>(a1?: ?$ReadOnlyArray<T>, iteratee?: ?ValueOnlyIteratee<T>): Array<T>;
|
451
|
456
|
xorBy<T>(
|
452
|
|
- a1: Array<T>,
|
453
|
|
- a2: Array<T>,
|
|
457
|
+ a1: $ReadOnlyArray<T>,
|
|
458
|
+ a2: $ReadOnlyArray<T>,
|
454
|
459
|
iteratee?: ValueOnlyIteratee<T>
|
455
|
460
|
): Array<T>;
|
456
|
461
|
xorBy<T>(
|
457
|
|
- a1: Array<T>,
|
458
|
|
- a2: Array<T>,
|
459
|
|
- a3: Array<T>,
|
|
462
|
+ a1: $ReadOnlyArray<T>,
|
|
463
|
+ a2: $ReadOnlyArray<T>,
|
|
464
|
+ a3: $ReadOnlyArray<T>,
|
460
|
465
|
iteratee?: ValueOnlyIteratee<T>
|
461
|
466
|
): Array<T>;
|
462
|
467
|
xorBy<T>(
|
463
|
|
- a1: Array<T>,
|
464
|
|
- a2: Array<T>,
|
465
|
|
- a3: Array<T>,
|
466
|
|
- a4: Array<T>,
|
|
468
|
+ a1: $ReadOnlyArray<T>,
|
|
469
|
+ a2: $ReadOnlyArray<T>,
|
|
470
|
+ a3: $ReadOnlyArray<T>,
|
|
471
|
+ a4: $ReadOnlyArray<T>,
|
467
|
472
|
iteratee?: ValueOnlyIteratee<T>
|
468
|
473
|
): Array<T>;
|
469
|
474
|
//Workaround until (...parameter: T, parameter2: U) works
|
470
|
|
- xorWith<T>(a1?: ?Array<T>, comparator?: ?Comparator<T>): Array<T>;
|
|
475
|
+ xorWith<T>(a1?: ?$ReadOnlyArray<T>, comparator?: ?Comparator<T>): Array<T>;
|
471
|
476
|
xorWith<T>(
|
472
|
|
- a1: Array<T>,
|
473
|
|
- a2: Array<T>,
|
|
477
|
+ a1: $ReadOnlyArray<T>,
|
|
478
|
+ a2: $ReadOnlyArray<T>,
|
474
|
479
|
comparator?: Comparator<T>
|
475
|
480
|
): Array<T>;
|
476
|
481
|
xorWith<T>(
|
477
|
|
- a1: Array<T>,
|
478
|
|
- a2: Array<T>,
|
479
|
|
- a3: Array<T>,
|
|
482
|
+ a1: $ReadOnlyArray<T>,
|
|
483
|
+ a2: $ReadOnlyArray<T>,
|
|
484
|
+ a3: $ReadOnlyArray<T>,
|
480
|
485
|
comparator?: Comparator<T>
|
481
|
486
|
): Array<T>;
|
482
|
487
|
xorWith<T>(
|
483
|
|
- a1: Array<T>,
|
484
|
|
- a2: Array<T>,
|
485
|
|
- a3: Array<T>,
|
486
|
|
- a4: Array<T>,
|
|
488
|
+ a1: $ReadOnlyArray<T>,
|
|
489
|
+ a2: $ReadOnlyArray<T>,
|
|
490
|
+ a3: $ReadOnlyArray<T>,
|
|
491
|
+ a4: $ReadOnlyArray<T>,
|
487
|
492
|
comparator?: Comparator<T>
|
488
|
493
|
): Array<T>;
|
489
|
|
- zip<A, B>(a1?: ?(A[]), a2?: ?(B[])): Array<[A, B]>;
|
490
|
|
- zip<A, B, C>(a1: A[], a2: B[], a3: C[]): Array<[A, B, C]>;
|
491
|
|
- zip<A, B, C, D>(a1: A[], a2: B[], a3: C[], a4: D[]): Array<[A, B, C, D]>;
|
|
494
|
+ zip<A, B>(a1?: ?($ReadOnlyArray<A>), a2?: ?($ReadOnlyArray<B>)): Array<[A, B]>;
|
|
495
|
+ zip<A, B, C>(a1: $ReadOnlyArray<A>, a2: $ReadOnlyArray<B>, a3: $ReadOnlyArray<C>): Array<[A, B, C]>;
|
|
496
|
+ zip<A, B, C, D>(a1: $ReadOnlyArray<A>, a2: $ReadOnlyArray<B>, a3: $ReadOnlyArray<C>, a4: $ReadOnlyArray<D>): Array<[A, B, C, D]>;
|
492
|
497
|
zip<A, B, C, D, E>(
|
493
|
|
- a1: A[],
|
494
|
|
- a2: B[],
|
495
|
|
- a3: C[],
|
496
|
|
- a4: D[],
|
497
|
|
- a5: E[]
|
|
498
|
+ a1: $ReadOnlyArray<A>,
|
|
499
|
+ a2: $ReadOnlyArray<B>,
|
|
500
|
+ a3: $ReadOnlyArray<C>,
|
|
501
|
+ a4: $ReadOnlyArray<D>,
|
|
502
|
+ a5: $ReadOnlyArray<E>
|
498
|
503
|
): Array<[A, B, C, D, E]>;
|
499
|
504
|
|
500
|
505
|
zipObject<K, V>(props: Array<K>, values?: ?Array<V>): { [key: K]: V };
|
|
@@ -502,44 +507,44 @@ declare module "lodash" {
|
502
|
507
|
zipObjectDeep(props: any[], values?: ?any): Object;
|
503
|
508
|
zipObjectDeep(props: void | null, values?: ?any): {};
|
504
|
509
|
|
505
|
|
- zipWith<A>(a1?: ?Array<A>): Array<[A]>;
|
506
|
|
- zipWith<T, A>(a1: Array<A>, iteratee: (A) => T): Array<T>;
|
|
510
|
+ zipWith<A>(a1?: ?$ReadOnlyArray<A>): Array<[A]>;
|
|
511
|
+ zipWith<T, A>(a1: $ReadOnlyArray<A>, iteratee: (A) => T): Array<T>;
|
507
|
512
|
|
508
|
|
- zipWith<A, B>(a1: Array<A>, a2: Array<B>): Array<[A, B]>;
|
|
513
|
+ zipWith<A, B>(a1: $ReadOnlyArray<A>, a2: $ReadOnlyArray<B>): Array<[A, B]>;
|
509
|
514
|
zipWith<T, A, B>(
|
510
|
|
- a1: Array<A>,
|
511
|
|
- a2: Array<B>,
|
|
515
|
+ a1: $ReadOnlyArray<A>,
|
|
516
|
+ a2: $ReadOnlyArray<B>,
|
512
|
517
|
iteratee: (A, B) => T
|
513
|
|
- ): Array<T>;
|
|
518
|
+ ): $ReadOnlyArray<T>;
|
514
|
519
|
|
515
|
520
|
zipWith<A, B, C>(
|
516
|
|
- a1: Array<A>,
|
517
|
|
- a2: Array<B>,
|
518
|
|
- a3: Array<C>
|
|
521
|
+ a1: $ReadOnlyArray<A>,
|
|
522
|
+ a2: $ReadOnlyArray<B>,
|
|
523
|
+ a3: $ReadOnlyArray<C>
|
519
|
524
|
): Array<[A, B, C]>;
|
520
|
525
|
zipWith<T, A, B, C>(
|
521
|
|
- a1: Array<A>,
|
522
|
|
- a2: Array<B>,
|
523
|
|
- a3: Array<C>,
|
|
526
|
+ a1: $ReadOnlyArray<A>,
|
|
527
|
+ a2: $ReadOnlyArray<B>,
|
|
528
|
+ a3: $ReadOnlyArray<C>,
|
524
|
529
|
iteratee: (A, B, C) => T
|
525
|
530
|
): Array<T>;
|
526
|
531
|
|
527
|
532
|
zipWith<A, B, C, D>(
|
528
|
|
- a1: Array<A>,
|
529
|
|
- a2: Array<B>,
|
530
|
|
- a3: Array<C>,
|
531
|
|
- a4: Array<D>
|
|
533
|
+ a1: $ReadOnlyArray<A>,
|
|
534
|
+ a2: $ReadOnlyArray<B>,
|
|
535
|
+ a3: $ReadOnlyArray<C>,
|
|
536
|
+ a4: $ReadOnlyArray<D>
|
532
|
537
|
): Array<[A, B, C, D]>;
|
533
|
538
|
zipWith<T, A, B, C, D>(
|
534
|
|
- a1: Array<A>,
|
535
|
|
- a2: Array<B>,
|
536
|
|
- a3: Array<C>,
|
537
|
|
- a4: Array<D>,
|
|
539
|
+ a1: $ReadOnlyArray<A>,
|
|
540
|
+ a2: $ReadOnlyArray<B>,
|
|
541
|
+ a3: $ReadOnlyArray<C>,
|
|
542
|
+ a4: $ReadOnlyArray<D>,
|
538
|
543
|
iteratee: (A, B, C, D) => T
|
539
|
544
|
): Array<T>;
|
540
|
545
|
|
541
|
546
|
// Collection
|
542
|
|
- countBy<T>(array: Array<T>, iteratee?: ?ValueOnlyIteratee<T>): Object;
|
|
547
|
+ countBy<T>(array: $ReadOnlyArray<T>, iteratee?: ?ValueOnlyIteratee<T>): Object;
|
543
|
548
|
countBy<T>(array: void | null, iteratee?: ?ValueOnlyIteratee<T>): {};
|
544
|
549
|
countBy<T: Object>(object: T, iteratee?: ?ValueOnlyIteratee<T>): Object;
|
545
|
550
|
// alias of _.forEach
|
|
@@ -675,7 +680,7 @@ declare module "lodash" {
|
675
|
680
|
iteratees?: ?$ReadOnlyArray<Iteratee<T>> | ?string,
|
676
|
681
|
orders?: ?$ReadOnlyArray<"asc" | "desc"> | ?string
|
677
|
682
|
): Array<T>;
|
678
|
|
- orderBy<V, T: Object>(
|
|
683
|
+ orderBy<V, T: {}>(
|
679
|
684
|
object: T,
|
680
|
685
|
iteratees?: $ReadOnlyArray<OIteratee<*>> | string,
|
681
|
686
|
orders?: $ReadOnlyArray<"asc" | "desc"> | string
|
|
@@ -743,11 +748,11 @@ declare module "lodash" {
|
743
|
748
|
object?: ?T,
|
744
|
749
|
predicate?: ?OPredicate<A, T>
|
745
|
750
|
): Array<V>;
|
746
|
|
- sample<T>(array: ?Array<T>): T;
|
|
751
|
+ sample<T>(array: ?$ReadOnlyArray<T>): T;
|
747
|
752
|
sample<V, T: Object>(object: T): V;
|
748
|
|
- sampleSize<T>(array?: ?Array<T>, n?: ?number): Array<T>;
|
|
753
|
+ sampleSize<T>(array?: ?$ReadOnlyArray<T>, n?: ?number): Array<T>;
|
749
|
754
|
sampleSize<V, T: Object>(object: T, n?: number): Array<V>;
|
750
|
|
- shuffle<T>(array: ?Array<T>): Array<T>;
|
|
755
|
+ shuffle<T>(array: ?$ReadOnlyArray<T>): Array<T>;
|
751
|
756
|
shuffle<V, T: Object>(object: T): Array<V>;
|
752
|
757
|
size(collection: $ReadOnlyArray<any> | Object | string): number;
|
753
|
758
|
some<T>(array: void | null, predicate?: ?Predicate<T>): false;
|
|
@@ -785,7 +790,11 @@ declare module "lodash" {
|
785
|
790
|
curry: Curry;
|
786
|
791
|
curry(func: Function, arity?: number): Function;
|
787
|
792
|
curryRight(func: Function, arity?: number): Function;
|
788
|
|
- debounce<F: (...any[]) => any>(func: F, wait?: number, options?: DebounceOptions): F;
|
|
793
|
+ debounce<F: (...any[]) => any>(
|
|
794
|
+ func: F,
|
|
795
|
+ wait?: number,
|
|
796
|
+ options?: DebounceOptions
|
|
797
|
+ ): F & Cancelable;
|
789
|
798
|
defer(func: (...any[]) => any, ...args?: Array<any>): TimeoutID;
|
790
|
799
|
delay(func: Function, wait: number, ...args?: Array<any>): TimeoutID;
|
791
|
800
|
flip<R>(func: (...any[]) => R): (...any[]) => R;
|
|
@@ -805,7 +814,7 @@ declare module "lodash" {
|
805
|
814
|
func: F,
|
806
|
815
|
wait?: number,
|
807
|
816
|
options?: ThrottleOptions
|
808
|
|
- ): F;
|
|
817
|
+ ): F & Cancelable;
|
809
|
818
|
unary<F: (...any[]) => any>(func: F): F;
|
810
|
819
|
wrap(value?: any, wrapper?: ?Function): Function;
|
811
|
820
|
|
|
@@ -830,13 +839,13 @@ declare module "lodash" {
|
830
|
839
|
gte(value: any, other: any): boolean;
|
831
|
840
|
isArguments(value: void | null): false;
|
832
|
841
|
isArguments(value: any): boolean;
|
833
|
|
- isArray(value: Array<any>): true;
|
|
842
|
+ isArray(value: $ReadOnlyArray<any>): true;
|
834
|
843
|
isArray(value: any): false;
|
835
|
844
|
isArrayBuffer(value: ArrayBuffer): true;
|
836
|
845
|
isArrayBuffer(value: any): false;
|
837
|
|
- isArrayLike(value: Array<any> | string | { length: number }): true;
|
|
846
|
+ isArrayLike(value: $ReadOnlyArray<any> | string | { length: number }): true;
|
838
|
847
|
isArrayLike(value: any): false;
|
839
|
|
- isArrayLikeObject(value: { length: number } | Array<any>): true;
|
|
848
|
+ isArrayLikeObject(value: { length: number } | $ReadOnlyArray<any>): true;
|
840
|
849
|
isArrayLikeObject(value: any): false;
|
841
|
850
|
isBoolean(value: boolean): true;
|
842
|
851
|
isBoolean(value: any): false;
|
|
@@ -939,16 +948,16 @@ declare module "lodash" {
|
939
|
948
|
ceil(number: number, precision?: number): number;
|
940
|
949
|
divide(dividend: number, divisor: number): number;
|
941
|
950
|
floor(number: number, precision?: number): number;
|
942
|
|
- max<T>(array: ?Array<T>): T;
|
|
951
|
+ max<T>(array: ?$ReadOnlyArray<T>): T;
|
943
|
952
|
maxBy<T>(array: ?$ReadOnlyArray<T>, iteratee?: Iteratee<T>): T;
|
944
|
|
- mean(array: Array<*>): number;
|
|
953
|
+ mean(array: $ReadOnlyArray<*>): number;
|
945
|
954
|
meanBy<T>(array: Array<T>, iteratee?: Iteratee<T>): number;
|
946
|
|
- min<T>(array: ?Array<T>): T;
|
|
955
|
+ min<T>(array: ?$ReadOnlyArray<T>): T;
|
947
|
956
|
minBy<T>(array: ?$ReadOnlyArray<T>, iteratee?: Iteratee<T>): T;
|
948
|
957
|
multiply(multiplier: number, multiplicand: number): number;
|
949
|
958
|
round(number: number, precision?: number): number;
|
950
|
959
|
subtract(minuend: number, subtrahend: number): number;
|
951
|
|
- sum(array: Array<*>): number;
|
|
960
|
+ sum(array: $ReadOnlyArray<*>): number;
|
952
|
961
|
sumBy<T>(array: $ReadOnlyArray<T>, iteratee?: Iteratee<T>): number;
|
953
|
962
|
|
954
|
963
|
// number
|
|
@@ -1066,8 +1075,8 @@ declare module "lodash" {
|
1066
|
1075
|
source: A | B | C | D
|
1067
|
1076
|
) => any | void
|
1068
|
1077
|
): Object;
|
1069
|
|
- at(object?: ?Object, ...paths: Array<string>): Array<any>;
|
1070
|
|
- at(object?: ?Object, paths: Array<string>): Array<any>;
|
|
1078
|
+ at(object?: ?Object, ...paths: $ReadOnlyArray<string>): Array<any>;
|
|
1079
|
+ at(object?: ?Object, paths: $ReadOnlyArray<string>): Array<any>;
|
1071
|
1080
|
create(prototype: void | null, properties: void | null): {};
|
1072
|
1081
|
create<T>(prototype: T, properties: Object): T;
|
1073
|
1082
|
create(prototype: any, properties: void | null): {};
|
|
@@ -1237,15 +1246,15 @@ declare module "lodash" {
|
1237
|
1246
|
source: A | B | C | D
|
1238
|
1247
|
) => any | void
|
1239
|
1248
|
): Object;
|
1240
|
|
- omit(object?: ?Object, ...props: Array<string>): Object;
|
1241
|
|
- omit(object?: ?Object, props: Array<string>): Object;
|
|
1249
|
+ omit(object?: ?Object, ...props: $ReadOnlyArray<string>): Object;
|
|
1250
|
+ omit(object?: ?Object, props: $ReadOnlyArray<string>): Object;
|
1242
|
1251
|
omitBy<A, T: { [id: any]: A } | { [id: number]: A }>(
|
1243
|
1252
|
object: T,
|
1244
|
1253
|
predicate?: ?OPredicate<A, T>
|
1245
|
1254
|
): Object;
|
1246
|
1255
|
omitBy<A, T>(object: void | null, predicate?: ?OPredicate<A, T>): {};
|
1247
|
|
- pick(object?: ?Object, ...props: Array<string>): Object;
|
1248
|
|
- pick(object?: ?Object, props: Array<string>): Object;
|
|
1256
|
+ pick(object?: ?Object, ...props: $ReadOnlyArray<string>): Object;
|
|
1257
|
+ pick(object?: ?Object, props: $ReadOnlyArray<string>): Object;
|
1249
|
1258
|
pickBy<A, T: { [id: any]: A } | { [id: number]: A }>(
|
1250
|
1259
|
object: T,
|
1251
|
1260
|
predicate?: ?OPredicate<A, T>
|
|
@@ -1758,65 +1767,65 @@ declare module "lodash/fp" {
|
1758
|
1767
|
): number;
|
1759
|
1768
|
// alias of _.head
|
1760
|
1769
|
first<T>(array: $ReadOnlyArray<T>): T;
|
1761
|
|
- flatten<T, X>(array: Array<Array<T> | X>): Array<T | X>;
|
|
1770
|
+ flatten<T, X>(array: $ReadOnlyArray<$ReadOnlyArray<T> | X>): Array<T | X>;
|
1762
|
1771
|
unnest<T, X>(array: Array<Array<T> | X>): Array<T | X>;
|
1763
|
1772
|
flattenDeep<T>(array: any[]): Array<T>;
|
1764
|
1773
|
flattenDepth(depth: number): (array: any[]) => any[];
|
1765
|
1774
|
flattenDepth(depth: number, array: any[]): any[];
|
1766
|
1775
|
fromPairs<A, B>(pairs: Array<[A, B]>): { [key: A]: B };
|
1767
|
1776
|
head<T>(array: $ReadOnlyArray<T>): T;
|
1768
|
|
- indexOf<T>(value: T): (array: Array<T>) => number;
|
1769
|
|
- indexOf<T>(value: T, array: Array<T>): number;
|
|
1777
|
+ indexOf<T>(value: T): (array: $ReadOnlyArray<T>) => number;
|
|
1778
|
+ indexOf<T>(value: T, array: $ReadOnlyArray<T>): number;
|
1770
|
1779
|
indexOfFrom<T>(
|
1771
|
1780
|
value: T
|
1772
|
|
- ): ((fromIndex: number) => (array: Array<T>) => number) &
|
1773
|
|
- ((fromIndex: number, array: Array<T>) => number);
|
1774
|
|
- indexOfFrom<T>(value: T, fromIndex: number): (array: Array<T>) => number;
|
1775
|
|
- indexOfFrom<T>(value: T, fromIndex: number, array: Array<T>): number;
|
1776
|
|
- initial<T>(array: Array<T>): Array<T>;
|
|
1781
|
+ ): ((fromIndex: number) => (array: $ReadOnlyArray<T>) => number) &
|
|
1782
|
+ ((fromIndex: number, array: $ReadOnlyArray<T>) => number);
|
|
1783
|
+ indexOfFrom<T>(value: T, fromIndex: number): (array: $ReadOnlyArray<T>) => number;
|
|
1784
|
+ indexOfFrom<T>(value: T, fromIndex: number, array: $ReadOnlyArray<T>): number;
|
|
1785
|
+ initial<T>(array: $ReadOnlyArray<T>): Array<T>;
|
1777
|
1786
|
init<T>(array: Array<T>): Array<T>;
|
1778
|
|
- intersection<T>(a1: Array<T>): (a2: Array<T>) => Array<T>;
|
1779
|
|
- intersection<T>(a1: Array<T>, a2: Array<T>): Array<T>;
|
|
1787
|
+ intersection<T>(a1: $ReadOnlyArray<T>): (a2: $ReadOnlyArray<T>) => Array<T>;
|
|
1788
|
+ intersection<T>(a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>): Array<T>;
|
1780
|
1789
|
intersectionBy<T>(
|
1781
|
1790
|
iteratee: ValueOnlyIteratee<T>
|
1782
|
|
- ): ((a1: Array<T>) => (a2: Array<T>) => Array<T>) &
|
1783
|
|
- ((a1: Array<T>, a2: Array<T>) => Array<T>);
|
|
1791
|
+ ): ((a1: $ReadOnlyArray<T>) => (a2: $ReadOnlyArray<T>) => Array<T>) &
|
|
1792
|
+ ((a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>);
|
1784
|
1793
|
intersectionBy<T>(
|
1785
|
1794
|
iteratee: ValueOnlyIteratee<T>,
|
1786
|
|
- a1: Array<T>
|
|
1795
|
+ a1: $ReadOnlyArray<T>
|
1787
|
1796
|
): (a2: Array<T>) => Array<T>;
|
1788
|
1797
|
intersectionBy<T>(
|
1789
|
1798
|
iteratee: ValueOnlyIteratee<T>,
|
1790
|
|
- a1: Array<T>,
|
1791
|
|
- a2: Array<T>
|
|
1799
|
+ a1: $ReadOnlyArray<T>,
|
|
1800
|
+ a2: $ReadOnlyArray<T>
|
1792
|
1801
|
): Array<T>;
|
1793
|
1802
|
intersectionWith<T>(
|
1794
|
1803
|
comparator: Comparator<T>
|
1795
|
|
- ): ((a1: Array<T>) => (a2: Array<T>) => Array<T>) &
|
1796
|
|
- ((a1: Array<T>, a2: Array<T>) => Array<T>);
|
|
1804
|
+ ): ((a1: $ReadOnlyArray<T>) => (a2: $ReadOnlyArray<T>) => Array<T>) &
|
|
1805
|
+ ((a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>);
|
1797
|
1806
|
intersectionWith<T>(
|
1798
|
1807
|
comparator: Comparator<T>,
|
1799
|
|
- a1: Array<T>
|
1800
|
|
- ): (a2: Array<T>) => Array<T>;
|
|
1808
|
+ a1: $ReadOnlyArray<T>
|
|
1809
|
+ ): (a2: $ReadOnlyArray<T>) => Array<T>;
|
1801
|
1810
|
intersectionWith<T>(
|
1802
|
1811
|
comparator: Comparator<T>,
|
1803
|
|
- a1: Array<T>,
|
1804
|
|
- a2: Array<T>
|
|
1812
|
+ a1: $ReadOnlyArray<T>,
|
|
1813
|
+ a2: $ReadOnlyArray<T>
|
1805
|
1814
|
): Array<T>;
|
1806
|
|
- join<T>(separator: string): (array: Array<T>) => string;
|
1807
|
|
- join<T>(separator: string, array: Array<T>): string;
|
1808
|
|
- last<T>(array: Array<T>): T;
|
1809
|
|
- lastIndexOf<T>(value: T): (array: Array<T>) => number;
|
1810
|
|
- lastIndexOf<T>(value: T, array: Array<T>): number;
|
|
1815
|
+ join<T>(separator: string): (array: $ReadOnlyArray<T>) => string;
|
|
1816
|
+ join<T>(separator: string, array: $ReadOnlyArray<T>): string;
|
|
1817
|
+ last<T>(array: $ReadOnlyArray<T>): T;
|
|
1818
|
+ lastIndexOf<T>(value: T): (array: $ReadOnlyArray<T>) => number;
|
|
1819
|
+ lastIndexOf<T>(value: T, array: $ReadOnlyArray<T>): number;
|
1811
|
1820
|
lastIndexOfFrom<T>(
|
1812
|
1821
|
value: T
|
1813
|
|
- ): ((fromIndex: number) => (array: Array<T>) => number) &
|
1814
|
|
- ((fromIndex: number, array: Array<T>) => number);
|
|
1822
|
+ ): ((fromIndex: number) => (array: $ReadOnlyArray<T>) => number) &
|
|
1823
|
+ ((fromIndex: number, array: $ReadOnlyArray<T>) => number);
|
1815
|
1824
|
lastIndexOfFrom<T>(
|
1816
|
1825
|
value: T,
|
1817
|
1826
|
fromIndex: number
|
1818
|
|
- ): (array: Array<T>) => number;
|
1819
|
|
- lastIndexOfFrom<T>(value: T, fromIndex: number, array: Array<T>): number;
|
|
1827
|
+ ): (array: $ReadOnlyArray<T>) => number;
|
|
1828
|
+ lastIndexOfFrom<T>(value: T, fromIndex: number, array: $ReadOnlyArray<T>): number;
|
1820
|
1829
|
nth<T>(n: number): (array: T[]) => T;
|
1821
|
1830
|
nth<T>(n: number, array: T[]): T;
|
1822
|
1831
|
pull<T>(value: T): (array: Array<T>) => Array<T>;
|
|
@@ -1849,154 +1858,154 @@ declare module "lodash/fp" {
|
1849
|
1858
|
reverse<T>(array: Array<T>): Array<T>;
|
1850
|
1859
|
slice<T>(
|
1851
|
1860
|
start: number
|
1852
|
|
- ): ((end: number) => (array: Array<T>) => Array<T>) &
|
1853
|
|
- ((end: number, array: Array<T>) => Array<T>);
|
1854
|
|
- slice<T>(start: number, end: number): (array: Array<T>) => Array<T>;
|
1855
|
|
- slice<T>(start: number, end: number, array: Array<T>): Array<T>;
|
1856
|
|
- sortedIndex<T>(value: T): (array: Array<T>) => number;
|
1857
|
|
- sortedIndex<T>(value: T, array: Array<T>): number;
|
|
1861
|
+ ): ((end: number) => (array: $ReadOnlyArray<T>) => Array<T>) &
|
|
1862
|
+ ((end: number, array: $ReadOnlyArray<T>) => Array<T>);
|
|
1863
|
+ slice<T>(start: number, end: number): (array: $ReadOnlyArray<T>) => Array<T>;
|
|
1864
|
+ slice<T>(start: number, end: number, array: $ReadOnlyArray<T>): Array<T>;
|
|
1865
|
+ sortedIndex<T>(value: T): (array: $ReadOnlyArray<T>) => number;
|
|
1866
|
+ sortedIndex<T>(value: T, array: $ReadOnlyArray<T>): number;
|
1858
|
1867
|
sortedIndexBy<T>(
|
1859
|
1868
|
iteratee: ValueOnlyIteratee<T>
|
1860
|
|
- ): ((value: T) => (array: Array<T>) => number) &
|
|
1869
|
+ ): ((value: T) => (array: $ReadOnlyArray<T>) => number) &
|
1861
|
1870
|
((value: T, array: Array<T>) => number);
|
1862
|
1871
|
sortedIndexBy<T>(
|
1863
|
1872
|
iteratee: ValueOnlyIteratee<T>,
|
1864
|
1873
|
value: T
|
1865
|
|
- ): (array: Array<T>) => number;
|
|
1874
|
+ ): (array: $ReadOnlyArray<T>) => number;
|
1866
|
1875
|
sortedIndexBy<T>(
|
1867
|
1876
|
iteratee: ValueOnlyIteratee<T>,
|
1868
|
1877
|
value: T,
|
1869
|
|
- array: Array<T>
|
|
1878
|
+ array: $ReadOnlyArray<T>
|
1870
|
1879
|
): number;
|
1871
|
|
- sortedIndexOf<T>(value: T): (array: Array<T>) => number;
|
1872
|
|
- sortedIndexOf<T>(value: T, array: Array<T>): number;
|
1873
|
|
- sortedLastIndex<T>(value: T): (array: Array<T>) => number;
|
1874
|
|
- sortedLastIndex<T>(value: T, array: Array<T>): number;
|
|
1880
|
+ sortedIndexOf<T>(value: T): (array: $ReadOnlyArray<T>) => number;
|
|
1881
|
+ sortedIndexOf<T>(value: T, array: $ReadOnlyArray<T>): number;
|
|
1882
|
+ sortedLastIndex<T>(value: T): (array: $ReadOnlyArray<T>) => number;
|
|
1883
|
+ sortedLastIndex<T>(value: T, array: $ReadOnlyArray<T>): number;
|
1875
|
1884
|
sortedLastIndexBy<T>(
|
1876
|
1885
|
iteratee: ValueOnlyIteratee<T>
|
1877
|
|
- ): ((value: T) => (array: Array<T>) => number) &
|
|
1886
|
+ ): ((value: T) => (array: $ReadOnlyArray<T>) => number) &
|
1878
|
1887
|
((value: T, array: Array<T>) => number);
|
1879
|
1888
|
sortedLastIndexBy<T>(
|
1880
|
1889
|
iteratee: ValueOnlyIteratee<T>,
|
1881
|
1890
|
value: T
|
1882
|
|
- ): (array: Array<T>) => number;
|
|
1891
|
+ ): (array: $ReadOnlyArray<T>) => number;
|
1883
|
1892
|
sortedLastIndexBy<T>(
|
1884
|
1893
|
iteratee: ValueOnlyIteratee<T>,
|
1885
|
1894
|
value: T,
|
1886
|
|
- array: Array<T>
|
|
1895
|
+ array: $ReadOnlyArray<T>
|
1887
|
1896
|
): number;
|
1888
|
|
- sortedLastIndexOf<T>(value: T): (array: Array<T>) => number;
|
1889
|
|
- sortedLastIndexOf<T>(value: T, array: Array<T>): number;
|
1890
|
|
- sortedUniq<T>(array: Array<T>): Array<T>;
|
1891
|
|
- sortedUniqBy<T>(iteratee: ValueOnlyIteratee<T>, array: Array<T>): Array<T>;
|
1892
|
|
- tail<T>(array: Array<T>): Array<T>;
|
1893
|
|
- take<T>(n: number): (array: Array<T>) => Array<T>;
|
1894
|
|
- take<T>(n: number, array: Array<T>): Array<T>;
|
1895
|
|
- takeRight<T>(n: number): (array: Array<T>) => Array<T>;
|
1896
|
|
- takeRight<T>(n: number, array: Array<T>): Array<T>;
|
1897
|
|
- takeLast<T>(n: number): (array: Array<T>) => Array<T>;
|
1898
|
|
- takeLast<T>(n: number, array: Array<T>): Array<T>;
|
|
1897
|
+ sortedLastIndexOf<T>(value: T): (array: $ReadOnlyArray<T>) => number;
|
|
1898
|
+ sortedLastIndexOf<T>(value: T, array: $ReadOnlyArray<T>): number;
|
|
1899
|
+ sortedUniq<T>(array: $ReadOnlyArray<T>): Array<T>;
|
|
1900
|
+ sortedUniqBy<T>(iteratee: ValueOnlyIteratee<T>, array: $ReadOnlyArray<T>): Array<T>;
|
|
1901
|
+ tail<T>(array: $ReadOnlyArray<T>): Array<T>;
|
|
1902
|
+ take<T>(n: number): (array: $ReadOnlyArray<T>) => Array<T>;
|
|
1903
|
+ take<T>(n: number, array: $ReadOnlyArray<T>): Array<T>;
|
|
1904
|
+ takeRight<T>(n: number): (array: $ReadOnlyArray<T>) => Array<T>;
|
|
1905
|
+ takeRight<T>(n: number, array: $ReadOnlyArray<T>): Array<T>;
|
|
1906
|
+ takeLast<T>(n: number): (array: $ReadOnlyArray<T>) => Array<T>;
|
|
1907
|
+ takeLast<T>(n: number, array: $ReadOnlyArray<T>): Array<T>;
|
1899
|
1908
|
takeRightWhile<T>(predicate: Predicate<T>): (array: Array<T>) => Array<T>;
|
1900
|
1909
|
takeRightWhile<T>(predicate: Predicate<T>, array: Array<T>): Array<T>;
|
1901
|
1910
|
takeLastWhile<T>(predicate: Predicate<T>): (array: Array<T>) => Array<T>;
|
1902
|
1911
|
takeLastWhile<T>(predicate: Predicate<T>, array: Array<T>): Array<T>;
|
1903
|
1912
|
takeWhile<T>(predicate: Predicate<T>): (array: Array<T>) => Array<T>;
|
1904
|
1913
|
takeWhile<T>(predicate: Predicate<T>, array: Array<T>): Array<T>;
|
1905
|
|
- union<T>(a1: Array<T>): (a2: Array<T>) => Array<T>;
|
1906
|
|
- union<T>(a1: Array<T>, a2: Array<T>): Array<T>;
|
|
1914
|
+ union<T>(a1: $ReadOnlyArray<T>): (a2: Array<T>) => Array<T>;
|
|
1915
|
+ union<T>(a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>): Array<T>;
|
1907
|
1916
|
unionBy<T>(
|
1908
|
1917
|
iteratee: ValueOnlyIteratee<T>
|
1909
|
|
- ): ((a1: Array<T>) => (a2: Array<T>) => Array<T>) &
|
1910
|
|
- ((a1: Array<T>, a2: Array<T>) => Array<T>);
|
|
1918
|
+ ): ((a1: $ReadOnlyArray<T>) => (a2: $ReadOnlyArray<T>) => Array<T>) &
|
|
1919
|
+ ((a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>);
|
1911
|
1920
|
unionBy<T>(
|
1912
|
1921
|
iteratee: ValueOnlyIteratee<T>,
|
1913
|
|
- a1: Array<T>
|
1914
|
|
- ): (a2: Array<T>) => Array<T>;
|
|
1922
|
+ a1: $ReadOnlyArray<T>
|
|
1923
|
+ ): (a2: $ReadOnlyArray<T>) => Array<T>;
|
1915
|
1924
|
unionBy<T>(
|
1916
|
1925
|
iteratee: ValueOnlyIteratee<T>,
|
1917
|
|
- a1: Array<T>,
|
1918
|
|
- a2: Array<T>
|
|
1926
|
+ a1: $ReadOnlyArray<T>,
|
|
1927
|
+ a2: $ReadOnlyArray<T>
|
1919
|
1928
|
): Array<T>;
|
1920
|
1929
|
unionWith<T>(
|
1921
|
1930
|
comparator: Comparator<T>
|
1922
|
|
- ): ((a1: Array<T>) => (a2: Array<T>) => Array<T>) &
|
1923
|
|
- ((a1: Array<T>, a2: Array<T>) => Array<T>);
|
|
1931
|
+ ): ((a1: $ReadOnlyArray<T>) => (a2: $ReadOnlyArray<T>) => Array<T>) &
|
|
1932
|
+ ((a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>);
|
1924
|
1933
|
unionWith<T>(
|
1925
|
1934
|
comparator: Comparator<T>,
|
1926
|
|
- a1: Array<T>
|
1927
|
|
- ): (a2: Array<T>) => Array<T>;
|
|
1935
|
+ a1: $ReadOnlyArray<T>
|
|
1936
|
+ ): (a2: $ReadOnlyArray<T>) => Array<T>;
|
1928
|
1937
|
unionWith<T>(
|
1929
|
1938
|
comparator: Comparator<T>,
|
1930
|
|
- a1: Array<T>,
|
1931
|
|
- a2: Array<T>
|
|
1939
|
+ a1: $ReadOnlyArray<T>,
|
|
1940
|
+ a2: $ReadOnlyArray<T>
|
1932
|
1941
|
): Array<T>;
|
1933
|
|
- uniq<T>(array: Array<T>): Array<T>;
|
1934
|
|
- uniqBy<T>(iteratee: ValueOnlyIteratee<T>): (array: Array<T>) => Array<T>;
|
1935
|
|
- uniqBy<T>(iteratee: ValueOnlyIteratee<T>, array: Array<T>): Array<T>;
|
1936
|
|
- uniqWith<T>(comparator: Comparator<T>): (array: Array<T>) => Array<T>;
|
1937
|
|
- uniqWith<T>(comparator: Comparator<T>, array: Array<T>): Array<T>;
|
1938
|
|
- unzip<T>(array: Array<T>): Array<T>;
|
|
1942
|
+ uniq<T>(array: $ReadOnlyArray<T>): Array<T>;
|
|
1943
|
+ uniqBy<T>(iteratee: ValueOnlyIteratee<T>): (array: $ReadOnlyArray<T>) => Array<T>;
|
|
1944
|
+ uniqBy<T>(iteratee: ValueOnlyIteratee<T>, array: $ReadOnlyArray<T>): Array<T>;
|
|
1945
|
+ uniqWith<T>(comparator: Comparator<T>): (array: $ReadOnlyArray<T>) => Array<T>;
|
|
1946
|
+ uniqWith<T>(comparator: Comparator<T>, array: $ReadOnlyArray<T>): Array<T>;
|
|
1947
|
+ unzip<T>(array: $ReadOnlyArray<T>): Array<T>;
|
1939
|
1948
|
unzipWith<T>(iteratee: Iteratee<T>): (array: Array<T>) => Array<T>;
|
1940
|
1949
|
unzipWith<T>(iteratee: Iteratee<T>, array: Array<T>): Array<T>;
|
1941
|
|
- without<T>(values: Array<T>): (array: Array<T>) => Array<T>;
|
1942
|
|
- without<T>(values: Array<T>, array: Array<T>): Array<T>;
|
1943
|
|
- xor<T>(a1: Array<T>): (a2: Array<T>) => Array<T>;
|
1944
|
|
- xor<T>(a1: Array<T>, a2: Array<T>): Array<T>;
|
1945
|
|
- symmetricDifference<T>(a1: Array<T>): (a2: Array<T>) => Array<T>;
|
1946
|
|
- symmetricDifference<T>(a1: Array<T>, a2: Array<T>): Array<T>;
|
|
1950
|
+ without<T>(values: $ReadOnlyArray<T>): (array: $ReadOnlyArray<T>) => Array<T>;
|
|
1951
|
+ without<T>(values: $ReadOnlyArray<T>, array: $ReadOnlyArray<T>): Array<T>;
|
|
1952
|
+ xor<T>(a1: $ReadOnlyArray<T>): (a2: $ReadOnlyArray<T>) => Array<T>;
|
|
1953
|
+ xor<T>(a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>): Array<T>;
|
|
1954
|
+ symmetricDifference<T>(a1: $ReadOnlyArray<T>): (a2: $ReadOnlyArray<T>) => Array<T>;
|
|
1955
|
+ symmetricDifference<T>(a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>): Array<T>;
|
1947
|
1956
|
xorBy<T>(
|
1948
|
1957
|
iteratee: ValueOnlyIteratee<T>
|
1949
|
|
- ): ((a1: Array<T>) => (a2: Array<T>) => Array<T>) &
|
1950
|
|
- ((a1: Array<T>, a2: Array<T>) => Array<T>);
|
|
1958
|
+ ): ((a1: $ReadOnlyArray<T>) => (a2: $ReadOnlyArray<T>) => Array<T>) &
|
|
1959
|
+ ((a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>);
|
1951
|
1960
|
xorBy<T>(
|
1952
|
1961
|
iteratee: ValueOnlyIteratee<T>,
|
1953
|
|
- a1: Array<T>
|
1954
|
|
- ): (a2: Array<T>) => Array<T>;
|
|
1962
|
+ a1: $ReadOnlyArray<T>
|
|
1963
|
+ ): (a2: $ReadOnlyArray<T>) => Array<T>;
|
1955
|
1964
|
xorBy<T>(
|
1956
|
1965
|
iteratee: ValueOnlyIteratee<T>,
|
1957
|
|
- a1: Array<T>,
|
1958
|
|
- a2: Array<T>
|
|
1966
|
+ a1: $ReadOnlyArray<T>,
|
|
1967
|
+ a2: $ReadOnlyArray<T>
|
1959
|
1968
|
): Array<T>;
|
1960
|
1969
|
symmetricDifferenceBy<T>(
|
1961
|
1970
|
iteratee: ValueOnlyIteratee<T>
|
1962
|
|
- ): ((a1: Array<T>) => (a2: Array<T>) => Array<T>) &
|
1963
|
|
- ((a1: Array<T>, a2: Array<T>) => Array<T>);
|
|
1971
|
+ ): ((a1: $ReadOnlyArray<T>) => (a2: $ReadOnlyArray<T>) => Array<T>) &
|
|
1972
|
+ ((a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>);
|
1964
|
1973
|
symmetricDifferenceBy<T>(
|
1965
|
1974
|
iteratee: ValueOnlyIteratee<T>,
|
1966
|
|
- a1: Array<T>
|
|
1975
|
+ a1: $ReadOnlyArray<T>
|
1967
|
1976
|
): (a2: Array<T>) => Array<T>;
|
1968
|
1977
|
symmetricDifferenceBy<T>(
|
1969
|
1978
|
iteratee: ValueOnlyIteratee<T>,
|
1970
|
|
- a1: Array<T>,
|
1971
|
|
- a2: Array<T>
|
|
1979
|
+ a1: $ReadOnlyArray<T>,
|
|
1980
|
+ a2: $ReadOnlyArray<T>
|
1972
|
1981
|
): Array<T>;
|
1973
|
1982
|
xorWith<T>(
|
1974
|
1983
|
comparator: Comparator<T>
|
1975
|
|
- ): ((a1: Array<T>) => (a2: Array<T>) => Array<T>) &
|
1976
|
|
- ((a1: Array<T>, a2: Array<T>) => Array<T>);
|
|
1984
|
+ ): ((a1: $ReadOnlyArray<T>) => (a2: $ReadOnlyArray<T>) => Array<T>) &
|
|
1985
|
+ ((a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>);
|
1977
|
1986
|
xorWith<T>(
|
1978
|
1987
|
comparator: Comparator<T>,
|
1979
|
|
- a1: Array<T>
|
1980
|
|
- ): (a2: Array<T>) => Array<T>;
|
1981
|
|
- xorWith<T>(comparator: Comparator<T>, a1: Array<T>, a2: Array<T>): Array<T>;
|
|
1988
|
+ a1: $ReadOnlyArray<T>
|
|
1989
|
+ ): (a2: $ReadOnlyArray<T>) => Array<T>;
|
|
1990
|
+ xorWith<T>(comparator: Comparator<T>, a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>): Array<T>;
|
1982
|
1991
|
symmetricDifferenceWith<T>(
|
1983
|
1992
|
comparator: Comparator<T>
|
1984
|
|
- ): ((a1: Array<T>) => (a2: Array<T>) => Array<T>) &
|
1985
|
|
- ((a1: Array<T>, a2: Array<T>) => Array<T>);
|
|
1993
|
+ ): ((a1: $ReadOnlyArray<T>) => (a2: $ReadOnlyArray<T>) => Array<T>) &
|
|
1994
|
+ ((a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>);
|
1986
|
1995
|
symmetricDifferenceWith<T>(
|
1987
|
1996
|
comparator: Comparator<T>,
|
1988
|
|
- a1: Array<T>
|
1989
|
|
- ): (a2: Array<T>) => Array<T>;
|
|
1997
|
+ a1: $ReadOnlyArray<T>
|
|
1998
|
+ ): (a2: $ReadOnlyArray<T>) => Array<T>;
|
1990
|
1999
|
symmetricDifferenceWith<T>(
|
1991
|
2000
|
comparator: Comparator<T>,
|
1992
|
|
- a1: Array<T>,
|
1993
|
|
- a2: Array<T>
|
|
2001
|
+ a1: $ReadOnlyArray<T>,
|
|
2002
|
+ a2: $ReadOnlyArray<T>
|
1994
|
2003
|
): Array<T>;
|
1995
|
|
- zip<A, B>(a1: A[]): (a2: B[]) => Array<[A, B]>;
|
1996
|
|
- zip<A, B>(a1: A[], a2: B[]): Array<[A, B]>;
|
1997
|
|
- zipAll(arrays: Array<Array<any>>): Array<any>;
|
1998
|
|
- zipObject<K, V>(props?: Array<K>): (values?: Array<V>) => { [key: K]: V };
|
1999
|
|
- zipObject<K, V>(props?: Array<K>, values?: Array<V>): { [key: K]: V };
|
|
2004
|
+ zip<A, B>(a1: $ReadOnlyArray<A>): (a2: $ReadOnlyArray<B>) => Array<[A, B]>;
|
|
2005
|
+ zip<A, B>(a1: $ReadOnlyArray<A>, a2: $ReadOnlyArray<B>): Array<[A, B]>;
|
|
2006
|
+ zipAll(arrays: $ReadOnlyArray<$ReadOnlyArray<any>>): Array<any>;
|
|
2007
|
+ zipObject<K, V>(props?: $ReadOnlyArray<K>): (values?: $ReadOnlyArray<V>) => { [key: K]: V };
|
|
2008
|
+ zipObject<K, V>(props?: $ReadOnlyArray<K>, values?: $ReadOnlyArray<V>): { [key: K]: V };
|
2000
|
2009
|
zipObj(props: Array<any>): (values: Array<any>) => Object;
|
2001
|
2010
|
zipObj(props: Array<any>, values: Array<any>): Object;
|
2002
|
2011
|
zipObjectDeep(props: any[]): (values: any) => Object;
|
|
@@ -2017,10 +2026,10 @@ declare module "lodash/fp" {
|
2017
|
2026
|
// Collection
|
2018
|
2027
|
countBy<T>(
|
2019
|
2028
|
iteratee: ValueOnlyIteratee<T>
|
2020
|
|
- ): (collection: Array<T> | { [id: any]: T }) => { [string]: number };
|
|
2029
|
+ ): (collection: $ReadOnlyArray<T> | { [id: any]: T }) => { [string]: number };
|
2021
|
2030
|
countBy<T>(
|
2022
|
2031
|
iteratee: ValueOnlyIteratee<T>,
|
2023
|
|
- collection: Array<T> | { [id: any]: T }
|
|
2032
|
+ collection: $ReadOnlyArray<T> | { [id: any]: T }
|
2024
|
2033
|
): { [string]: number };
|
2025
|
2034
|
// alias of _.forEach
|
2026
|
2035
|
each<T>(
|
|
@@ -2946,8 +2955,10 @@ declare module "lodash/fp" {
|
2946
|
2955
|
predicate: OPredicate<A>
|
2947
|
2956
|
): (object: T) => Object;
|
2948
|
2957
|
omitBy<A, T: { [id: any]: A }>(predicate: OPredicate<A>, object: T): Object;
|
2949
|
|
- pick(props: Array<string>): (object: Object) => Object;
|
2950
|
|
- pick(props: Array<string>, object: Object): Object;
|
|
2958
|
+ pick(...props: Array<string | {}>): Object;
|
|
2959
|
+ pick(props: $ReadOnlyArray<string>, object: Object): Object;
|
|
2960
|
+ pick(...props: Array<string>): (object: Object) => Object;
|
|
2961
|
+ pick(props: $ReadOnlyArray<string>): (object: Object) => Object;
|
2951
|
2962
|
pickAll(props: Array<string>): (object: Object) => Object;
|
2952
|
2963
|
pickAll(props: Array<string>, object: Object): Object;
|
2953
|
2964
|
pickBy<A, T: { [id: any]: A }>(
|