@gooddata/util 11.68.0-alpha.8 → 11.68.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/NOTICE +3 -3
- package/esm/_/_baseClone.d.ts +17 -4
- package/esm/_/_baseClone.d.ts.map +1 -1
- package/esm/_/_baseClone.js +55 -23
- package/esm/_/_baseDifference.d.ts +7 -4
- package/esm/_/_baseDifference.d.ts.map +1 -1
- package/esm/_/_baseDifference.js +18 -7
- package/esm/_/_baseExtremum.d.ts +15 -0
- package/esm/_/_baseExtremum.d.ts.map +1 -0
- package/esm/_/_baseExtremum.js +64 -0
- package/esm/_/_baseIntersection.d.ts +19 -0
- package/esm/_/_baseIntersection.d.ts.map +1 -0
- package/esm/_/_baseIntersection.js +91 -0
- package/esm/_/_baseMerge.d.ts +7 -3
- package/esm/_/_baseMerge.d.ts.map +1 -1
- package/esm/_/_baseMerge.js +20 -11
- package/esm/_/_baseSet.d.ts +3 -1
- package/esm/_/_baseSet.d.ts.map +1 -1
- package/esm/_/_baseSet.js +9 -3
- package/esm/_/_baseSlice.d.ts +45 -0
- package/esm/_/_baseSlice.d.ts.map +1 -0
- package/esm/_/_baseSlice.js +30 -0
- package/esm/_/_baseSum.d.ts +42 -0
- package/esm/_/_baseSum.d.ts.map +1 -0
- package/esm/_/_baseSum.js +21 -0
- package/esm/_/_cloneTypedArray.d.ts +1 -1
- package/esm/_/_cloneTypedArray.d.ts.map +1 -1
- package/esm/_/_cloneTypedArray.js +3 -2
- package/esm/_/_flattenArrayLikeObjects.d.ts +11 -0
- package/esm/_/_flattenArrayLikeObjects.d.ts.map +1 -0
- package/esm/_/_flattenArrayLikeObjects.js +55 -0
- package/esm/_/assignIn.d.ts +35 -0
- package/esm/_/assignIn.d.ts.map +1 -0
- package/esm/_/assignIn.js +50 -0
- package/esm/_/bindAll.d.ts +16 -0
- package/esm/_/bindAll.d.ts.map +1 -0
- package/esm/_/bindAll.js +88 -0
- package/esm/_/chunk.d.ts +15 -0
- package/esm/_/chunk.d.ts.map +1 -0
- package/esm/_/chunk.js +61 -0
- package/esm/_/clone.d.ts +12 -0
- package/esm/_/clone.d.ts.map +1 -0
- package/esm/_/clone.js +45 -0
- package/esm/_/cloneDeep.js +1 -1
- package/esm/_/cloneDeepWith.d.ts +18 -0
- package/esm/_/cloneDeepWith.d.ts.map +1 -0
- package/esm/_/cloneDeepWith.js +36 -0
- package/esm/_/constant.d.ts +39 -0
- package/esm/_/constant.d.ts.map +1 -0
- package/esm/_/constant.js +43 -0
- package/esm/_/defaults.d.ts +36 -0
- package/esm/_/defaults.d.ts.map +1 -0
- package/esm/_/defaults.js +51 -0
- package/esm/_/differenceWith.d.ts +27 -0
- package/esm/_/differenceWith.d.ts.map +1 -0
- package/esm/_/differenceWith.js +39 -0
- package/esm/_/dropRightWhile.d.ts +13 -0
- package/esm/_/dropRightWhile.d.ts.map +1 -0
- package/esm/_/dropRightWhile.js +54 -0
- package/esm/_/escapeRegExp.d.ts +12 -0
- package/esm/_/escapeRegExp.d.ts.map +1 -0
- package/esm/_/escapeRegExp.js +47 -0
- package/esm/_/findKey.d.ts +14 -0
- package/esm/_/findKey.d.ts.map +1 -0
- package/esm/_/findKey.js +58 -0
- package/esm/_/findLastIndex.d.ts +16 -0
- package/esm/_/findLastIndex.d.ts.map +1 -0
- package/esm/_/findLastIndex.js +67 -0
- package/esm/_/get.d.ts +78 -0
- package/esm/_/get.d.ts.map +1 -0
- package/esm/_/get.js +36 -0
- package/esm/_/inRange.d.ts +14 -0
- package/esm/_/inRange.d.ts.map +1 -0
- package/esm/_/inRange.js +51 -0
- package/esm/_/initial.d.ts +11 -0
- package/esm/_/initial.d.ts.map +1 -0
- package/esm/_/initial.js +44 -0
- package/esm/_/intersection.d.ts +13 -0
- package/esm/_/intersection.d.ts.map +1 -0
- package/esm/_/intersection.js +45 -0
- package/esm/_/intersectionBy.d.ts +32 -0
- package/esm/_/intersectionBy.d.ts.map +1 -0
- package/esm/_/intersectionBy.js +41 -0
- package/esm/_/intersectionWith.d.ts +28 -0
- package/esm/_/intersectionWith.d.ts.map +1 -0
- package/esm/_/intersectionWith.js +38 -0
- package/esm/_/invert.d.ts +14 -0
- package/esm/_/invert.d.ts.map +1 -0
- package/esm/_/invert.js +55 -0
- package/esm/_/isError.d.ts +11 -0
- package/esm/_/isError.d.ts.map +1 -0
- package/esm/_/isError.js +57 -0
- package/esm/_/keys.d.ts +11 -0
- package/esm/_/keys.d.ts.map +1 -0
- package/esm/_/keys.js +60 -0
- package/esm/_/mapValues.d.ts +63 -0
- package/esm/_/mapValues.d.ts.map +1 -0
- package/esm/_/mapValues.js +47 -0
- package/esm/_/max.d.ts +16 -0
- package/esm/_/max.d.ts.map +1 -0
- package/esm/_/max.js +37 -0
- package/esm/_/mergeWith.d.ts +34 -0
- package/esm/_/mergeWith.d.ts.map +1 -0
- package/esm/_/mergeWith.js +50 -0
- package/esm/_/min.d.ts +16 -0
- package/esm/_/min.d.ts.map +1 -0
- package/esm/_/min.js +37 -0
- package/esm/_/negate.d.ts +41 -0
- package/esm/_/negate.d.ts.map +1 -0
- package/esm/_/negate.js +48 -0
- package/esm/_/reduce.d.ts +37 -0
- package/esm/_/reduce.d.ts.map +1 -0
- package/esm/_/reduce.js +48 -0
- package/esm/_/sumBy.d.ts +14 -0
- package/esm/_/sumBy.d.ts.map +1 -0
- package/esm/_/sumBy.js +47 -0
- package/esm/_/tail.d.ts +15 -0
- package/esm/_/tail.d.ts.map +1 -0
- package/esm/_/tail.js +36 -0
- package/esm/_/times.d.ts +17 -0
- package/esm/_/times.d.ts.map +1 -0
- package/esm/_/times.js +57 -0
- package/esm/_/toFinite.d.ts +0 -30
- package/esm/_/toFinite.d.ts.map +1 -1
- package/esm/_/toFinite.js +2 -2
- package/esm/_/toInteger.d.ts +11 -0
- package/esm/_/toInteger.d.ts.map +1 -0
- package/esm/_/toInteger.js +46 -0
- package/esm/_/types.d.ts +47 -0
- package/esm/_/types.d.ts.map +1 -1
- package/esm/_/unescape.d.ts +13 -0
- package/esm/_/unescape.d.ts.map +1 -0
- package/esm/_/unescape.js +56 -0
- package/esm/_/union.d.ts.map +1 -1
- package/esm/_/union.js +2 -13
- package/esm/_/unionBy.d.ts +34 -0
- package/esm/_/unionBy.d.ts.map +1 -0
- package/esm/_/unionBy.js +42 -0
- package/esm/_/updateWith.d.ts +23 -0
- package/esm/_/updateWith.d.ts.map +1 -0
- package/esm/_/updateWith.js +41 -0
- package/esm/_/without.d.ts +15 -0
- package/esm/_/without.d.ts.map +1 -0
- package/esm/_/without.js +47 -0
- package/esm/index.d.ts +37 -3
- package/esm/index.d.ts.map +1 -1
- package/esm/index.js +36 -2
- package/esm/util.d.ts +857 -18
- package/package.json +3 -3
package/esm/util.d.ts
CHANGED
|
@@ -7,6 +7,66 @@
|
|
|
7
7
|
* @packageDocumentation
|
|
8
8
|
*/
|
|
9
9
|
|
|
10
|
+
/**
|
|
11
|
+
* @internal
|
|
12
|
+
*/
|
|
13
|
+
export declare type _ArrayIterator<T, TResult> = (value: T, index: number, collection: T[]) => TResult;
|
|
14
|
+
|
|
15
|
+
/**
|
|
16
|
+
* This method is like `_assign` except that it iterates over own and inherited source properties: it
|
|
17
|
+
* assigns the own and inherited enumerable string keyed properties of the source objects to the destination
|
|
18
|
+
* object, left to right, so later sources overwrite earlier ones. Falsy sources are skipped, array-like
|
|
19
|
+
* sources are copied by index, and a nullish destination becomes a new object while a primitive one is boxed.
|
|
20
|
+
*
|
|
21
|
+
* **Note:** This method mutates `object`.
|
|
22
|
+
*
|
|
23
|
+
* @param object - The destination object.
|
|
24
|
+
* @param sources - The source objects.
|
|
25
|
+
* @returns Returns `object`.
|
|
26
|
+
* @internal
|
|
27
|
+
*/
|
|
28
|
+
export declare function _assignIn<TObject, TSource>(object: TObject, source: TSource): TObject & TSource;
|
|
29
|
+
|
|
30
|
+
/**
|
|
31
|
+
* @internal
|
|
32
|
+
*/
|
|
33
|
+
export declare function _assignIn<TObject, TSource1, TSource2>(object: TObject, source1: TSource1, source2: TSource2): TObject & TSource1 & TSource2;
|
|
34
|
+
|
|
35
|
+
/**
|
|
36
|
+
* @internal
|
|
37
|
+
*/
|
|
38
|
+
export declare function _assignIn<TObject, TSource1, TSource2, TSource3>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3): TObject & TSource1 & TSource2 & TSource3;
|
|
39
|
+
|
|
40
|
+
/**
|
|
41
|
+
* @internal
|
|
42
|
+
*/
|
|
43
|
+
export declare function _assignIn<TObject, TSource1, TSource2, TSource3, TSource4>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): TObject & TSource1 & TSource2 & TSource3 & TSource4;
|
|
44
|
+
|
|
45
|
+
/**
|
|
46
|
+
* @internal
|
|
47
|
+
*/
|
|
48
|
+
export declare function _assignIn<TObject>(object: TObject): TObject;
|
|
49
|
+
|
|
50
|
+
/**
|
|
51
|
+
* @internal
|
|
52
|
+
*/
|
|
53
|
+
export declare function _assignIn<TResult>(object: any, ...otherArgs: any[]): TResult;
|
|
54
|
+
|
|
55
|
+
/**
|
|
56
|
+
* Binds methods of an object to the object itself, overwriting the existing method. Method names may be
|
|
57
|
+
* specified as individual arguments or as arrays of method names, which are flattened one level; names are
|
|
58
|
+
* coerced to property keys the way lodash does it, so symbols and `-0` are kept.
|
|
59
|
+
*
|
|
60
|
+
* **Note:** This method doesn't set the "length" property of bound functions, and it mutates `object`.
|
|
61
|
+
*
|
|
62
|
+
* @param object - The object to bind and assign the bound methods to.
|
|
63
|
+
* @param methodNames - The object method names to bind.
|
|
64
|
+
* @returns Returns `object`.
|
|
65
|
+
* @throws TypeError when a named property is not a function.
|
|
66
|
+
* @internal
|
|
67
|
+
*/
|
|
68
|
+
export declare function _bindAll<T>(object: T, ...methodNames: _Many<string>[]): T;
|
|
69
|
+
|
|
10
70
|
/**
|
|
11
71
|
* Converts `string` to camel case: the words of the string, lower-cased, with every word but the first
|
|
12
72
|
* capitalised, joined together.
|
|
@@ -26,6 +86,20 @@ export declare const _camelCase: (string?: string) => string;
|
|
|
26
86
|
*/
|
|
27
87
|
export declare function _capitalize(string?: string): string;
|
|
28
88
|
|
|
89
|
+
/**
|
|
90
|
+
* Creates an array of elements split into groups the length of `size`. If `array` can't be split evenly, the
|
|
91
|
+
* final chunk will be the remaining elements. The size is coerced to an integer the way lodash does it, and
|
|
92
|
+
* a size below 1 yields an empty array.
|
|
93
|
+
*
|
|
94
|
+
* @param array - The array to process.
|
|
95
|
+
* @param size - The length of each chunk. Defaults to 1.
|
|
96
|
+
* @param guard - Enables use as an iteratee for methods like `map`: when it is the collection holding
|
|
97
|
+
* `array` at index `size`, the size is ignored.
|
|
98
|
+
* @returns Returns the new array of chunks.
|
|
99
|
+
* @internal
|
|
100
|
+
*/
|
|
101
|
+
export declare function _chunk<T>(array: _List<T> | null | undefined, size?: number, guard?: unknown): T[][];
|
|
102
|
+
|
|
29
103
|
/**
|
|
30
104
|
* Clamps `number` within the inclusive `lower` and `upper` bounds. With two arguments the second one is the
|
|
31
105
|
* upper bound. The upper bound is applied first, bounds that convert to `NaN` count as `0`, an `undefined`
|
|
@@ -44,6 +118,18 @@ export declare function _clamp(number: number, lower: number, upper: number): nu
|
|
|
44
118
|
*/
|
|
45
119
|
export declare function _clamp(number: number, upper: number): number;
|
|
46
120
|
|
|
121
|
+
/**
|
|
122
|
+
* Creates a shallow clone of `value`: arrays, plain objects, arguments objects, dates, regexps, maps, sets,
|
|
123
|
+
* typed arrays, array buffers, data views and boxed primitives are copied one level, with nested values
|
|
124
|
+
* kept by reference. An empty object is returned for uncloneable values such as functions, errors and
|
|
125
|
+
* weak collections.
|
|
126
|
+
*
|
|
127
|
+
* @param value - The value to clone.
|
|
128
|
+
* @returns Returns the cloned value.
|
|
129
|
+
* @internal
|
|
130
|
+
*/
|
|
131
|
+
export declare function _clone<T>(value: T): T;
|
|
132
|
+
|
|
47
133
|
/**
|
|
48
134
|
* Recursively clones `value`.
|
|
49
135
|
*
|
|
@@ -58,6 +144,33 @@ export declare function _clamp(number: number, upper: number): number;
|
|
|
58
144
|
*/
|
|
59
145
|
export declare function _cloneDeep<T>(value: T): T;
|
|
60
146
|
|
|
147
|
+
/**
|
|
148
|
+
* This method is like `_cloneDeep` except that it accepts `customizer` which is invoked to produce the
|
|
149
|
+
* cloned value. If `customizer` returns `undefined`, cloning is handled by the method instead. The
|
|
150
|
+
* `customizer` is invoked with up to four arguments: (value [, index|key, object, stack]). Anything but
|
|
151
|
+
* a function is ignored as a customizer.
|
|
152
|
+
*
|
|
153
|
+
* @param value - The value to recursively clone.
|
|
154
|
+
* @param customizer - The function to customize cloning.
|
|
155
|
+
* @returns Returns the deep cloned value.
|
|
156
|
+
* @internal
|
|
157
|
+
*/
|
|
158
|
+
export declare function _cloneDeepWith<T>(value: T, customizer: _CloneDeepWithCustomizer<T>): any;
|
|
159
|
+
|
|
160
|
+
/**
|
|
161
|
+
* @internal
|
|
162
|
+
*/
|
|
163
|
+
export declare function _cloneDeepWith<T>(value: T): T;
|
|
164
|
+
|
|
165
|
+
/**
|
|
166
|
+
* The customizer of `_cloneDeepWith`: invoked with the value alone at the top level and with the value,
|
|
167
|
+
* its key, the containing object and the stack of objects being cloned below. A result other than
|
|
168
|
+
* `undefined` is used as the cloned value.
|
|
169
|
+
*
|
|
170
|
+
* @internal
|
|
171
|
+
*/
|
|
172
|
+
export declare type _CloneDeepWithCustomizer<TObject> = (value: any, key: number | string | undefined, object: TObject | undefined, stack: any) => any;
|
|
173
|
+
|
|
61
174
|
/**
|
|
62
175
|
* Returns combine guard from input guards as a result type is union type of guarded types
|
|
63
176
|
* Its good for array filtering base on multiple guards and its return correct result union type
|
|
@@ -81,6 +194,11 @@ export declare function _compact<T>(array: _List<T | _Falsey> | null | undefined
|
|
|
81
194
|
*/
|
|
82
195
|
export declare type _Comparator<T> = (a: T, b: T) => boolean;
|
|
83
196
|
|
|
197
|
+
/**
|
|
198
|
+
* @internal
|
|
199
|
+
*/
|
|
200
|
+
export declare type _Comparator2<T1, T2> = (a: T1, b: T2) => boolean;
|
|
201
|
+
|
|
84
202
|
/**
|
|
85
203
|
* A console function, like log, warn or error
|
|
86
204
|
*
|
|
@@ -95,6 +213,15 @@ export declare type ConsoleFunction = (...data: any[]) => void;
|
|
|
95
213
|
*/
|
|
96
214
|
export declare type ConsoleType = "error" | "warn" | "log" | "debug" | "info";
|
|
97
215
|
|
|
216
|
+
/**
|
|
217
|
+
* Creates a function that returns `value`, by reference, on every call, ignoring its arguments and `this`.
|
|
218
|
+
*
|
|
219
|
+
* @param value - The value to return from the new function.
|
|
220
|
+
* @returns Returns the new constant function.
|
|
221
|
+
* @internal
|
|
222
|
+
*/
|
|
223
|
+
export declare function _constant<T>(value: T): () => T;
|
|
224
|
+
|
|
98
225
|
/**
|
|
99
226
|
* Wraps a testing-library waitFor so it polls every millisecond instead of the default 50ms.
|
|
100
227
|
*
|
|
@@ -183,6 +310,57 @@ export declare type _DebounceSettingsLeading = _DebounceSettings & {
|
|
|
183
310
|
leading: true;
|
|
184
311
|
};
|
|
185
312
|
|
|
313
|
+
/**
|
|
314
|
+
* Deburrs `string` by converting Latin-1 Supplement and Latin Extended-A letters to basic Latin letters and
|
|
315
|
+
* removing combining diacritical marks.
|
|
316
|
+
*
|
|
317
|
+
* @param string - The string to deburr.
|
|
318
|
+
* @returns Returns the deburred string.
|
|
319
|
+
* @internal
|
|
320
|
+
*/
|
|
321
|
+
export declare function _deburr(string?: string): string;
|
|
322
|
+
|
|
323
|
+
/**
|
|
324
|
+
* Assigns own and inherited enumerable string keyed properties of source objects to the destination object
|
|
325
|
+
* for all destination properties that resolve to `undefined`. Source objects are applied from left to
|
|
326
|
+
* right, so once a property is set, additional values of the same property are ignored. A value inherited
|
|
327
|
+
* from `Object.prototype`, such as `toString`, counts as missing too. Sources are copied by plain
|
|
328
|
+
* assignment, a nullish destination becomes a new object and a primitive one is boxed.
|
|
329
|
+
*
|
|
330
|
+
* **Note:** This method mutates `object`.
|
|
331
|
+
*
|
|
332
|
+
* @param object - The destination object.
|
|
333
|
+
* @param sources - The source objects.
|
|
334
|
+
* @returns Returns `object`.
|
|
335
|
+
* @internal
|
|
336
|
+
*/
|
|
337
|
+
export declare function _defaults<TObject, TSource>(object: TObject, source: TSource): NonNullable<TSource & TObject>;
|
|
338
|
+
|
|
339
|
+
/**
|
|
340
|
+
* @internal
|
|
341
|
+
*/
|
|
342
|
+
export declare function _defaults<TObject, TSource1, TSource2>(object: TObject, source1: TSource1, source2: TSource2): NonNullable<TSource2 & TSource1 & TObject>;
|
|
343
|
+
|
|
344
|
+
/**
|
|
345
|
+
* @internal
|
|
346
|
+
*/
|
|
347
|
+
export declare function _defaults<TObject, TSource1, TSource2, TSource3>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3): NonNullable<TSource3 & TSource2 & TSource1 & TObject>;
|
|
348
|
+
|
|
349
|
+
/**
|
|
350
|
+
* @internal
|
|
351
|
+
*/
|
|
352
|
+
export declare function _defaults<TObject, TSource1, TSource2, TSource3, TSource4>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): NonNullable<TSource4 & TSource3 & TSource2 & TSource1 & TObject>;
|
|
353
|
+
|
|
354
|
+
/**
|
|
355
|
+
* @internal
|
|
356
|
+
*/
|
|
357
|
+
export declare function _defaults<TObject>(object: TObject): NonNullable<TObject>;
|
|
358
|
+
|
|
359
|
+
/**
|
|
360
|
+
* @internal
|
|
361
|
+
*/
|
|
362
|
+
export declare function _defaults(object: any, ...sources: any[]): any;
|
|
363
|
+
|
|
186
364
|
/**
|
|
187
365
|
* Returns a promise which will resolve after the provided number of milliseconds.
|
|
188
366
|
*
|
|
@@ -255,6 +433,47 @@ export declare function _differenceBy<T1, T2, T3, T4, T5, T6, T7>(array: _List<T
|
|
|
255
433
|
*/
|
|
256
434
|
export declare function _differenceBy<T>(array: _List<T> | null | undefined, ...values: _List<T>[]): T[];
|
|
257
435
|
|
|
436
|
+
/**
|
|
437
|
+
* This method is like `_difference` except that it accepts `comparator` which is invoked to compare elements
|
|
438
|
+
* of `array` to `values`. The order and references of result values are determined by the first array. The
|
|
439
|
+
* comparator is invoked with two arguments: (arrVal, othVal). As in lodash, the last argument is taken as
|
|
440
|
+
* the comparator unless it is an array-like object, and `-0` is not normalised when a comparator is used.
|
|
441
|
+
*
|
|
442
|
+
* @param array - The array to inspect.
|
|
443
|
+
* @param values - The values to exclude.
|
|
444
|
+
* @param comparator - The comparator invoked per element.
|
|
445
|
+
* @returns Returns the new array of filtered values.
|
|
446
|
+
* @internal
|
|
447
|
+
*/
|
|
448
|
+
export declare function _differenceWith<T1, T2>(array: _List<T1> | null | undefined, values: _List<T2>, comparator: _Comparator2<T1, T2>): T1[];
|
|
449
|
+
|
|
450
|
+
/**
|
|
451
|
+
* @internal
|
|
452
|
+
*/
|
|
453
|
+
export declare function _differenceWith<T1, T2, T3>(array: _List<T1> | null | undefined, values1: _List<T2>, values2: _List<T3>, comparator: _Comparator2<T1, T2 | T3>): T1[];
|
|
454
|
+
|
|
455
|
+
/**
|
|
456
|
+
* @internal
|
|
457
|
+
*/
|
|
458
|
+
export declare function _differenceWith<T1, T2, T3, T4>(array: _List<T1> | null | undefined, values1: _List<T2>, values2: _List<T3>, ...values: (_List<T4> | _Comparator2<T1, T2 | T3 | T4>)[]): T1[];
|
|
459
|
+
|
|
460
|
+
/**
|
|
461
|
+
* @internal
|
|
462
|
+
*/
|
|
463
|
+
export declare function _differenceWith<T>(array: _List<T> | null | undefined, ...values: _List<T>[]): T[];
|
|
464
|
+
|
|
465
|
+
/**
|
|
466
|
+
* Creates a slice of `array` excluding elements dropped from the end. Elements are dropped until
|
|
467
|
+
* `predicate` returns falsey. The predicate is invoked with three arguments: (value, index, array), and may
|
|
468
|
+
* be an iteratee shorthand; it defaults to the identity. The result is a new dense array.
|
|
469
|
+
*
|
|
470
|
+
* @param array - The array to query.
|
|
471
|
+
* @param predicate - The function invoked per iteration.
|
|
472
|
+
* @returns Returns the slice of `array`.
|
|
473
|
+
* @internal
|
|
474
|
+
*/
|
|
475
|
+
export declare function _dropRightWhile<T>(array: _List<T> | null | undefined, predicate?: _ListIteratee<T>): T[];
|
|
476
|
+
|
|
258
477
|
/**
|
|
259
478
|
* @internal
|
|
260
479
|
*/
|
|
@@ -295,12 +514,52 @@ export declare function _escape(string?: string): string;
|
|
|
295
514
|
*/
|
|
296
515
|
export declare function escapeRegExp(value: string): string;
|
|
297
516
|
|
|
517
|
+
/**
|
|
518
|
+
* Escapes the `RegExp` special characters `^`, `$`, `\`, `.`, `*`, `+`, `?`, `(`, `)`, `[`, `]`, `{`, `}`
|
|
519
|
+
* and `|` in `string`, so the result matches the input literally when used in a pattern.
|
|
520
|
+
*
|
|
521
|
+
* **Note:** Unlike the `escapeRegExp` in `stringUtils`, `/` is not escaped, matching lodash.
|
|
522
|
+
*
|
|
523
|
+
* @param string - The string to escape.
|
|
524
|
+
* @returns Returns the escaped string.
|
|
525
|
+
* @internal
|
|
526
|
+
*/
|
|
527
|
+
export declare function _escapeRegExp(string?: string): string;
|
|
528
|
+
|
|
298
529
|
/** Common interface between Arrays and jQuery objects */
|
|
299
530
|
/**
|
|
300
531
|
* @internal
|
|
301
532
|
*/
|
|
302
533
|
export declare type _Falsey = null | undefined | false | "" | 0 | 0n;
|
|
303
534
|
|
|
535
|
+
/**
|
|
536
|
+
* This method is like `_find` except that it returns the key of the first element `predicate` returns
|
|
537
|
+
* truthy for instead of the element itself. Own enumerable string keys are inspected in order, array-likes
|
|
538
|
+
* and strings by index; the predicate is invoked with three arguments: (value, key, object), may be an
|
|
539
|
+
* iteratee shorthand and defaults to the identity.
|
|
540
|
+
*
|
|
541
|
+
* @param object - The object to inspect.
|
|
542
|
+
* @param predicate - The function invoked per iteration.
|
|
543
|
+
* @returns Returns the key of the matched element, else `undefined`.
|
|
544
|
+
* @internal
|
|
545
|
+
*/
|
|
546
|
+
export declare function _findKey<T>(object: T | null | undefined, predicate?: _ObjectIteratee<T>): string | undefined;
|
|
547
|
+
|
|
548
|
+
/**
|
|
549
|
+
* This method is like `_findIndex` except that it iterates over elements of `array` from right to left,
|
|
550
|
+
* returning the index of the first element `predicate` returns truthy for, else `-1`. The predicate is
|
|
551
|
+
* invoked with three arguments: (value, index, array), may be an iteratee shorthand and defaults to the
|
|
552
|
+
* identity. The search starts at `fromIndex`, which is coerced to an integer the way lodash does it, counted
|
|
553
|
+
* from the end when negative and clamped into the array.
|
|
554
|
+
*
|
|
555
|
+
* @param array - The array to inspect.
|
|
556
|
+
* @param predicate - The function invoked per iteration.
|
|
557
|
+
* @param fromIndex - The index to search from. Defaults to the last index.
|
|
558
|
+
* @returns Returns the index of the found element, else `-1`.
|
|
559
|
+
* @internal
|
|
560
|
+
*/
|
|
561
|
+
export declare function _findLastIndex<T>(array: _List<T> | null | undefined, predicate?: _ListIterateeCustom<T, boolean>, fromIndex?: number): number;
|
|
562
|
+
|
|
304
563
|
/**
|
|
305
564
|
* @internal
|
|
306
565
|
*/
|
|
@@ -326,6 +585,97 @@ export declare type _Function3<T1, T2, T3, R> = (t1: T1, t2: T2, t3: T3) => R;
|
|
|
326
585
|
*/
|
|
327
586
|
export declare type _Function4<T1, T2, T3, T4, R> = (t1: T1, t2: T2, t3: T3, t4: T4) => R;
|
|
328
587
|
|
|
588
|
+
/**
|
|
589
|
+
* Gets the value at `path` of `object`. If the resolved value is `undefined`, the `defaultValue` is returned
|
|
590
|
+
* in its place; `null` and other values are returned as they are. Paths may be dotted or bracketed strings,
|
|
591
|
+
* arrays of keys, symbols or numbers, and a key that exists on `object` is read directly instead of being
|
|
592
|
+
* parsed as a path, as in lodash.
|
|
593
|
+
*
|
|
594
|
+
* Unlike the lodash typings, string paths are not typed by their segments; they resolve to `any`.
|
|
595
|
+
*
|
|
596
|
+
* @param object - The object to query.
|
|
597
|
+
* @param path - The path of the property to get.
|
|
598
|
+
* @param defaultValue - The value returned for `undefined` resolved values.
|
|
599
|
+
* @returns Returns the resolved value.
|
|
600
|
+
* @internal
|
|
601
|
+
*/
|
|
602
|
+
export declare function _get<TObject extends object, TKey extends keyof TObject>(object: TObject, path: TKey | [TKey]): TObject[TKey];
|
|
603
|
+
|
|
604
|
+
/**
|
|
605
|
+
* @internal
|
|
606
|
+
*/
|
|
607
|
+
export declare function _get<TObject extends object, TKey extends keyof TObject>(object: TObject | null | undefined, path: TKey | [TKey]): TObject[TKey] | undefined;
|
|
608
|
+
|
|
609
|
+
/**
|
|
610
|
+
* @internal
|
|
611
|
+
*/
|
|
612
|
+
export declare function _get<TObject extends object, TKey extends keyof TObject, TDefault>(object: TObject | null | undefined, path: TKey | [TKey], defaultValue: TDefault): Exclude<TObject[TKey], undefined> | TDefault;
|
|
613
|
+
|
|
614
|
+
/**
|
|
615
|
+
* @internal
|
|
616
|
+
*/
|
|
617
|
+
export declare function _get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(object: TObject, path: [TKey1, TKey2]): TObject[TKey1][TKey2];
|
|
618
|
+
|
|
619
|
+
/**
|
|
620
|
+
* @internal
|
|
621
|
+
*/
|
|
622
|
+
export declare function _get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof NonNullable<TObject[TKey1]>>(object: TObject | null | undefined, path: [TKey1, TKey2]): NonNullable<TObject[TKey1]>[TKey2] | undefined;
|
|
623
|
+
|
|
624
|
+
/**
|
|
625
|
+
* @internal
|
|
626
|
+
*/
|
|
627
|
+
export declare function _get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof NonNullable<TObject[TKey1]>, TDefault>(object: TObject | null | undefined, path: [TKey1, TKey2], defaultValue: TDefault): Exclude<NonNullable<TObject[TKey1]>[TKey2], undefined> | TDefault;
|
|
628
|
+
|
|
629
|
+
/**
|
|
630
|
+
* @internal
|
|
631
|
+
*/
|
|
632
|
+
export declare function _get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(object: TObject, path: [TKey1, TKey2, TKey3]): TObject[TKey1][TKey2][TKey3];
|
|
633
|
+
|
|
634
|
+
/**
|
|
635
|
+
* @internal
|
|
636
|
+
*/
|
|
637
|
+
export declare function _get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof NonNullable<TObject[TKey1]>, TKey3 extends keyof NonNullable<NonNullable<TObject[TKey1]>[TKey2]>>(object: TObject | null | undefined, path: [TKey1, TKey2, TKey3]): NonNullable<NonNullable<TObject[TKey1]>[TKey2]>[TKey3] | undefined;
|
|
638
|
+
|
|
639
|
+
/**
|
|
640
|
+
* @internal
|
|
641
|
+
*/
|
|
642
|
+
export declare function _get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof NonNullable<TObject[TKey1]>, TKey3 extends keyof NonNullable<NonNullable<TObject[TKey1]>[TKey2]>, TDefault>(object: TObject | null | undefined, path: [TKey1, TKey2, TKey3], defaultValue: TDefault): Exclude<NonNullable<NonNullable<TObject[TKey1]>[TKey2]>[TKey3], undefined> | TDefault;
|
|
643
|
+
|
|
644
|
+
/**
|
|
645
|
+
* @internal
|
|
646
|
+
*/
|
|
647
|
+
export declare function _get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(object: TObject, path: [TKey1, TKey2, TKey3, TKey4]): TObject[TKey1][TKey2][TKey3][TKey4];
|
|
648
|
+
|
|
649
|
+
/**
|
|
650
|
+
* @internal
|
|
651
|
+
*/
|
|
652
|
+
export declare function _get<T>(object: _NumericDictionary<T>, path: number): T;
|
|
653
|
+
|
|
654
|
+
/**
|
|
655
|
+
* @internal
|
|
656
|
+
*/
|
|
657
|
+
export declare function _get<T>(object: _NumericDictionary<T> | null | undefined, path: number): T | undefined;
|
|
658
|
+
|
|
659
|
+
/**
|
|
660
|
+
* @internal
|
|
661
|
+
*/
|
|
662
|
+
export declare function _get<T, TDefault>(object: _NumericDictionary<T> | null | undefined, path: number, defaultValue: TDefault): T | TDefault;
|
|
663
|
+
|
|
664
|
+
/**
|
|
665
|
+
* @internal
|
|
666
|
+
*/
|
|
667
|
+
export declare function _get<TDefault>(object: null | undefined, path: _PropertyPath, defaultValue: TDefault): TDefault;
|
|
668
|
+
|
|
669
|
+
/**
|
|
670
|
+
* @internal
|
|
671
|
+
*/
|
|
672
|
+
export declare function _get(object: null | undefined, path: _PropertyPath): undefined;
|
|
673
|
+
|
|
674
|
+
/**
|
|
675
|
+
* @internal
|
|
676
|
+
*/
|
|
677
|
+
export declare function _get(object: any, path: _PropertyPath, defaultValue?: any): any;
|
|
678
|
+
|
|
329
679
|
/**
|
|
330
680
|
* Creates an object composed of keys generated from the results of running each element of
|
|
331
681
|
* `collection` thru `iteratee`. The order of grouped values is determined by the order they occur in
|
|
@@ -359,33 +709,147 @@ export declare type GuardType<T> = T extends ((o: unknown) => o is infer U) ? U
|
|
|
359
709
|
* @returns Returns `true` if `path` exists, else `false`.
|
|
360
710
|
* @internal
|
|
361
711
|
*/
|
|
362
|
-
export declare function _has<T, K extends _PropertyName>(object: T, path: K): object is T & {
|
|
363
|
-
[P in K]: P extends keyof T ? T[P] : Record<string, unknown> extends T ? T[keyof T] : unknown;
|
|
364
|
-
} & {
|
|
365
|
-
[uniqueSymbol]: unknown;
|
|
366
|
-
};
|
|
712
|
+
export declare function _has<T, K extends _PropertyName>(object: T, path: K): object is T & {
|
|
713
|
+
[P in K]: P extends keyof T ? T[P] : Record<string, unknown> extends T ? T[keyof T] : unknown;
|
|
714
|
+
} & {
|
|
715
|
+
[uniqueSymbol]: unknown;
|
|
716
|
+
};
|
|
717
|
+
|
|
718
|
+
/**
|
|
719
|
+
* @internal
|
|
720
|
+
*/
|
|
721
|
+
export declare function _has<T>(object: T, path: _PropertyPath): boolean;
|
|
722
|
+
|
|
723
|
+
/**
|
|
724
|
+
* Returns a hash code for a string.
|
|
725
|
+
*
|
|
726
|
+
* The hash code for a string object is computed as
|
|
727
|
+
* s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
|
|
728
|
+
* using number arithmetic, where s[i] is the i th character
|
|
729
|
+
* of the given string, n is the length of the string,
|
|
730
|
+
* and ^ indicates exponentiation.
|
|
731
|
+
* (The hash value of the empty string is zero.)
|
|
732
|
+
*
|
|
733
|
+
* @param value - s a string
|
|
734
|
+
* @returns a hash code value for the given string.
|
|
735
|
+
*
|
|
736
|
+
* @internal
|
|
737
|
+
*/
|
|
738
|
+
export declare function hashCodeString(value: string): number;
|
|
739
|
+
|
|
740
|
+
/**
|
|
741
|
+
* Gets all but the last element of `array` as a new dense array. Nullish input and anything without a
|
|
742
|
+
* truthy `length` yield an empty array.
|
|
743
|
+
*
|
|
744
|
+
* @param array - The array to query.
|
|
745
|
+
* @returns Returns the slice of `array`.
|
|
746
|
+
* @internal
|
|
747
|
+
*/
|
|
748
|
+
export declare function _initial<T>(array: _List<T> | null | undefined): T[];
|
|
749
|
+
|
|
750
|
+
/**
|
|
751
|
+
* Checks if `number` is between `start` and up to, but not including, `end`. If `end` is not specified,
|
|
752
|
+
* it's set to `start` with `start` then set to `0`. If `start` is greater than `end` the params are swapped
|
|
753
|
+
* to support negative ranges. The bounds are coerced to finite numbers and `number` to a number the way
|
|
754
|
+
* lodash does it, so a `NaN` bound becomes `0` and a `NaN` number is never in range.
|
|
755
|
+
*
|
|
756
|
+
* @param number - The number to check.
|
|
757
|
+
* @param start - The start of the range.
|
|
758
|
+
* @param end - The end of the range.
|
|
759
|
+
* @returns Returns `true` if `number` is in the range, else `false`.
|
|
760
|
+
* @internal
|
|
761
|
+
*/
|
|
762
|
+
export declare function _inRange(number: number, start: number, end?: number): boolean;
|
|
763
|
+
|
|
764
|
+
/**
|
|
765
|
+
* Creates an array of unique values that are included in all given arrays using SameValueZero for equality
|
|
766
|
+
* comparisons. The order and references of result values are determined by the first array, with `-0`
|
|
767
|
+
* normalised to `0`. A first argument that is not an array-like object yields an empty array, and any other
|
|
768
|
+
* argument that is not one counts as an empty array.
|
|
769
|
+
*
|
|
770
|
+
* @param arrays - The arrays to inspect.
|
|
771
|
+
* @returns Returns the new array of intersecting values.
|
|
772
|
+
* @internal
|
|
773
|
+
*/
|
|
774
|
+
export declare function _intersection<T>(...arrays: (_List<T> | null | undefined)[]): T[];
|
|
775
|
+
|
|
776
|
+
/**
|
|
777
|
+
* This method is like `_intersection` except that it accepts `iteratee` which is invoked for each element
|
|
778
|
+
* of each array to generate the criterion by which they're compared. The order and references of result
|
|
779
|
+
* values are determined by the first array. The iteratee is invoked with one argument: (value). As in
|
|
780
|
+
* lodash, the last argument is taken as the iteratee unless it is an array-like object, so an array is
|
|
781
|
+
* always a list to intersect.
|
|
782
|
+
*
|
|
783
|
+
* @param array - The first array to inspect.
|
|
784
|
+
* @param values - The other arrays to inspect.
|
|
785
|
+
* @param iteratee - The iteratee invoked per element.
|
|
786
|
+
* @returns Returns the new array of intersecting values.
|
|
787
|
+
* @internal
|
|
788
|
+
*/
|
|
789
|
+
export declare function _intersectionBy<T1, T2>(array: _List<T1> | null, values: _List<T2>, iteratee: _ValueIteratee<T1 | T2>): T1[];
|
|
790
|
+
|
|
791
|
+
/**
|
|
792
|
+
* @internal
|
|
793
|
+
*/
|
|
794
|
+
export declare function _intersectionBy<T1, T2, T3>(array: _List<T1> | null, values1: _List<T2>, values2: _List<T3>, iteratee: _ValueIteratee<T1 | T2 | T3>): T1[];
|
|
795
|
+
|
|
796
|
+
/**
|
|
797
|
+
* @internal
|
|
798
|
+
*/
|
|
799
|
+
export declare function _intersectionBy<T1, T2, T3, T4>(array: _List<T1> | null | undefined, values1: _List<T2>, values2: _List<T3>, ...values: (_List<T4> | _ValueIteratee<T1 | T2 | T3 | T4>)[]): T1[];
|
|
800
|
+
|
|
801
|
+
/**
|
|
802
|
+
* @internal
|
|
803
|
+
*/
|
|
804
|
+
export declare function _intersectionBy<T>(array?: _List<T> | null, ...values: _List<T>[]): T[];
|
|
805
|
+
|
|
806
|
+
/**
|
|
807
|
+
* @internal
|
|
808
|
+
*/
|
|
809
|
+
export declare function _intersectionBy<T>(...values: (_List<T> | _ValueIteratee<T>)[]): T[];
|
|
810
|
+
|
|
811
|
+
/**
|
|
812
|
+
* This method is like `_intersection` except that it accepts `comparator` which is invoked to compare
|
|
813
|
+
* elements of the arrays. The order and references of result values are determined by the first array. The
|
|
814
|
+
* comparator is invoked with two arguments: (arrVal, othVal). As in lodash, only a function in the last
|
|
815
|
+
* position is taken as the comparator, arguments that are not array-like objects count as empty, the result
|
|
816
|
+
* is deduplicated through the comparator too, and `-0` is kept as it is when a comparator is used.
|
|
817
|
+
*
|
|
818
|
+
* @param array - The first array to inspect.
|
|
819
|
+
* @param values - The other arrays to inspect.
|
|
820
|
+
* @param comparator - The comparator invoked per element.
|
|
821
|
+
* @returns Returns the new array of intersecting values.
|
|
822
|
+
* @internal
|
|
823
|
+
*/
|
|
824
|
+
export declare function _intersectionWith<T1, T2>(array: _List<T1> | null | undefined, values: _List<T2>, comparator: _Comparator2<T1, T1 | T2>): T1[];
|
|
825
|
+
|
|
826
|
+
/**
|
|
827
|
+
* @internal
|
|
828
|
+
*/
|
|
829
|
+
export declare function _intersectionWith<T1, T2, T3>(array: _List<T1> | null | undefined, values1: _List<T2>, values2: _List<T3>, comparator: _Comparator2<T1, T1 | T2 | T3>): T1[];
|
|
830
|
+
|
|
831
|
+
/**
|
|
832
|
+
* @internal
|
|
833
|
+
*/
|
|
834
|
+
export declare function _intersectionWith<T1, T2, T3, T4>(array: _List<T1> | null | undefined, values1: _List<T2>, values2: _List<T3>, ...values: (_List<T4> | _Comparator2<T1, T1 | T2 | T3 | T4>)[]): T1[];
|
|
367
835
|
|
|
368
836
|
/**
|
|
369
837
|
* @internal
|
|
370
838
|
*/
|
|
371
|
-
export declare function
|
|
839
|
+
export declare function _intersectionWith<T>(array?: _List<T> | null, ...values: (_List<T> | _Comparator<T>)[]): T[];
|
|
372
840
|
|
|
373
841
|
/**
|
|
374
|
-
*
|
|
375
|
-
*
|
|
376
|
-
*
|
|
377
|
-
*
|
|
378
|
-
*
|
|
379
|
-
* of the given string, n is the length of the string,
|
|
380
|
-
* and ^ indicates exponentiation.
|
|
381
|
-
* (The hash value of the empty string is zero.)
|
|
382
|
-
*
|
|
383
|
-
* @param value - s a string
|
|
384
|
-
* @returns a hash code value for the given string.
|
|
842
|
+
* Creates an object composed of the inverted keys and values of `object`. If `object` contains duplicate
|
|
843
|
+
* values, subsequent values overwrite property assignments of previous values. Only own enumerable string
|
|
844
|
+
* keyed properties are inverted. As in lodash, a value is coerced to a property key the way property
|
|
845
|
+
* assignment does it, except that a value without a callable `toString` (such as an object with a null
|
|
846
|
+
* prototype) becomes `[object Object]`; a symbol value becomes a symbol key.
|
|
385
847
|
*
|
|
848
|
+
* @param object - The object to invert.
|
|
849
|
+
* @returns Returns the new inverted object.
|
|
386
850
|
* @internal
|
|
387
851
|
*/
|
|
388
|
-
export declare function
|
|
852
|
+
export declare function _invert(object: object): _Dictionary<string>;
|
|
389
853
|
|
|
390
854
|
/**
|
|
391
855
|
* Checks if value is empty. A value is considered empty unless it’s an arguments object, array, string, or
|
|
@@ -444,6 +908,17 @@ export declare function _isEmpty(value?: any): boolean;
|
|
|
444
908
|
*/
|
|
445
909
|
export declare function _isEqual(value: unknown, other: unknown): boolean;
|
|
446
910
|
|
|
911
|
+
/**
|
|
912
|
+
* Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`, `SyntaxError`, `TypeError`,
|
|
913
|
+
* `URIError` or `DOMException` object, or a non-plain object with string `message` and `name` properties.
|
|
914
|
+
* The raw tag is used, so a faked `Symbol.toStringTag` is ignored.
|
|
915
|
+
*
|
|
916
|
+
* @param value - The value to check.
|
|
917
|
+
* @returns Returns `true` if `value` is an error object, else `false`.
|
|
918
|
+
* @internal
|
|
919
|
+
*/
|
|
920
|
+
export declare function _isError(value: unknown): value is Error;
|
|
921
|
+
|
|
447
922
|
/**
|
|
448
923
|
* @internal
|
|
449
924
|
*/
|
|
@@ -502,6 +977,11 @@ export declare type _List<T> = ArrayLike<T>;
|
|
|
502
977
|
*/
|
|
503
978
|
export declare type _ListIteratee<T> = _ListIterator<T, _NotVoid> | _IterateeShorthand<T>;
|
|
504
979
|
|
|
980
|
+
/**
|
|
981
|
+
* @internal
|
|
982
|
+
*/
|
|
983
|
+
export declare type _ListIterateeCustom<T, TResult> = _ListIterator<T, TResult> | _IterateeShorthand<T>;
|
|
984
|
+
|
|
505
985
|
/**
|
|
506
986
|
* @internal
|
|
507
987
|
*/
|
|
@@ -536,6 +1016,79 @@ export declare type _MapCache = {
|
|
|
536
1016
|
*/
|
|
537
1017
|
export declare type _MapCacheConstructor = new () => _MapCache;
|
|
538
1018
|
|
|
1019
|
+
/**
|
|
1020
|
+
* Creates an object with the same keys as `object` and values generated by running each own enumerable
|
|
1021
|
+
* string keyed property of `object` thru `iteratee`. The iteratee is invoked with three arguments:
|
|
1022
|
+
* (value, key, object). Arrays, strings and other array-likes are mapped by index.
|
|
1023
|
+
*
|
|
1024
|
+
* @param object - The object to iterate over.
|
|
1025
|
+
* @param iteratee - The function invoked per iteration, or an iteratee shorthand. Defaults to identity.
|
|
1026
|
+
* @returns Returns the new mapped object.
|
|
1027
|
+
* @internal
|
|
1028
|
+
*/
|
|
1029
|
+
export declare function _mapValues<TResult>(obj: string | null | undefined, callback: _StringIterator<TResult>): _NumericDictionary<TResult>;
|
|
1030
|
+
|
|
1031
|
+
/**
|
|
1032
|
+
* @internal
|
|
1033
|
+
*/
|
|
1034
|
+
export declare function _mapValues<T, TResult>(array: T[], callback: _ArrayIterator<T, TResult>): _NumericDictionary<TResult>;
|
|
1035
|
+
|
|
1036
|
+
/**
|
|
1037
|
+
* @internal
|
|
1038
|
+
*/
|
|
1039
|
+
export declare function _mapValues<T extends object, TResult>(obj: T | null | undefined, callback: _ObjectIterator<T, TResult>): {
|
|
1040
|
+
[P in keyof T]: TResult;
|
|
1041
|
+
};
|
|
1042
|
+
|
|
1043
|
+
/**
|
|
1044
|
+
* @internal
|
|
1045
|
+
*/
|
|
1046
|
+
export declare function _mapValues<T>(obj: _Dictionary<T> | _NumericDictionary<T> | null | undefined, iteratee: object): _Dictionary<boolean>;
|
|
1047
|
+
|
|
1048
|
+
/**
|
|
1049
|
+
* @internal
|
|
1050
|
+
*/
|
|
1051
|
+
export declare function _mapValues<T extends object>(obj: T | null | undefined, iteratee: object): {
|
|
1052
|
+
[P in keyof T]: boolean;
|
|
1053
|
+
};
|
|
1054
|
+
|
|
1055
|
+
/**
|
|
1056
|
+
* @internal
|
|
1057
|
+
*/
|
|
1058
|
+
export declare function _mapValues<T, TKey extends keyof T>(obj: _Dictionary<T> | _NumericDictionary<T> | null | undefined, iteratee: TKey): _Dictionary<T[TKey]>;
|
|
1059
|
+
|
|
1060
|
+
/**
|
|
1061
|
+
* @internal
|
|
1062
|
+
*/
|
|
1063
|
+
export declare function _mapValues<T>(obj: _Dictionary<T> | _NumericDictionary<T> | null | undefined, iteratee: string): _Dictionary<any>;
|
|
1064
|
+
|
|
1065
|
+
/**
|
|
1066
|
+
* @internal
|
|
1067
|
+
*/
|
|
1068
|
+
export declare function _mapValues<T extends object>(obj: T | null | undefined, iteratee: string): {
|
|
1069
|
+
[P in keyof T]: any;
|
|
1070
|
+
};
|
|
1071
|
+
|
|
1072
|
+
/**
|
|
1073
|
+
* @internal
|
|
1074
|
+
*/
|
|
1075
|
+
export declare function _mapValues(obj: string | null | undefined): _NumericDictionary<string>;
|
|
1076
|
+
|
|
1077
|
+
/**
|
|
1078
|
+
* @internal
|
|
1079
|
+
*/
|
|
1080
|
+
export declare function _mapValues<T>(obj: _Dictionary<T> | _NumericDictionary<T> | null | undefined): _Dictionary<T>;
|
|
1081
|
+
|
|
1082
|
+
/**
|
|
1083
|
+
* @internal
|
|
1084
|
+
*/
|
|
1085
|
+
export declare function _mapValues<T extends object>(obj: T): T;
|
|
1086
|
+
|
|
1087
|
+
/**
|
|
1088
|
+
* @internal
|
|
1089
|
+
*/
|
|
1090
|
+
export declare function _mapValues<T extends object>(obj: T | null | undefined): _PartialObject<T>;
|
|
1091
|
+
|
|
539
1092
|
/**
|
|
540
1093
|
* A matcher for suppressConsole
|
|
541
1094
|
*
|
|
@@ -556,6 +1109,22 @@ export declare type Matcher = {
|
|
|
556
1109
|
*/
|
|
557
1110
|
export declare type MatcherFunction = (console: Record<ConsoleType, ConsoleFunction>, type: ConsoleType, message: string) => boolean;
|
|
558
1111
|
|
|
1112
|
+
/**
|
|
1113
|
+
* Computes the maximum value of `array` using the `>` operator, so mixed values coerce the way the operator
|
|
1114
|
+
* does. Nullish, `NaN` and symbol elements are skipped. If `array` is empty or falsey, `undefined` is
|
|
1115
|
+
* returned.
|
|
1116
|
+
*
|
|
1117
|
+
* @param array - The array to iterate over.
|
|
1118
|
+
* @returns Returns the maximum value.
|
|
1119
|
+
* @internal
|
|
1120
|
+
*/
|
|
1121
|
+
export declare function _max<T>(array: readonly [T, ...T[]]): T;
|
|
1122
|
+
|
|
1123
|
+
/**
|
|
1124
|
+
* @internal
|
|
1125
|
+
*/
|
|
1126
|
+
export declare function _max<T>(array: _List<T> | null | undefined): T | undefined;
|
|
1127
|
+
|
|
559
1128
|
/**
|
|
560
1129
|
* The shape of `_memoize`: the memoizing function itself plus the `Cache` constructor every memoized
|
|
561
1130
|
* function starts with.
|
|
@@ -595,6 +1164,16 @@ export declare type _MemoizedFunction = {
|
|
|
595
1164
|
cache: _MapCache;
|
|
596
1165
|
};
|
|
597
1166
|
|
|
1167
|
+
/**
|
|
1168
|
+
* @internal
|
|
1169
|
+
*/
|
|
1170
|
+
export declare type _MemoListIterator<T, TResult, TList> = (prev: TResult, curr: T, index: number, list: TList) => TResult;
|
|
1171
|
+
|
|
1172
|
+
/**
|
|
1173
|
+
* @internal
|
|
1174
|
+
*/
|
|
1175
|
+
export declare type _MemoObjectIterator<T, TResult, TList> = (prev: TResult, curr: T, key: string, list: TList) => TResult;
|
|
1176
|
+
|
|
598
1177
|
/**
|
|
599
1178
|
* Recursively merges own and inherited enumerable string keyed properties of source objects into the
|
|
600
1179
|
* destination object. Source properties that resolve to `undefined` are skipped if a destination value
|
|
@@ -631,6 +1210,79 @@ export declare function _merge<TObject, TSource1, TSource2, TSource3, TSource4>(
|
|
|
631
1210
|
*/
|
|
632
1211
|
export declare function _merge(object: any, ...otherArgs: any[]): any;
|
|
633
1212
|
|
|
1213
|
+
/**
|
|
1214
|
+
* This method is like `_merge` except that it accepts `customizer` which is invoked to produce the merged
|
|
1215
|
+
* values of the destination and source properties. If `customizer` returns `undefined`, merging is handled
|
|
1216
|
+
* by the method instead. The `customizer` is invoked with six arguments: (objValue, srcValue, key, object,
|
|
1217
|
+
* source, stack). It is taken from the last argument when that is a function preceded by at least one
|
|
1218
|
+
* source.
|
|
1219
|
+
*
|
|
1220
|
+
* **Note:** This method mutates `object`.
|
|
1221
|
+
*
|
|
1222
|
+
* @param object - The destination object.
|
|
1223
|
+
* @param source - The source object.
|
|
1224
|
+
* @param customizer - The function to customize assigned values.
|
|
1225
|
+
* @returns Returns `object`.
|
|
1226
|
+
* @internal
|
|
1227
|
+
*/
|
|
1228
|
+
export declare function _mergeWith<TObject, TSource>(object: TObject, source: TSource, customizer: _MergeWithCustomizer): TObject & TSource;
|
|
1229
|
+
|
|
1230
|
+
/**
|
|
1231
|
+
* @internal
|
|
1232
|
+
*/
|
|
1233
|
+
export declare function _mergeWith<TObject, TSource1, TSource2>(object: TObject, source1: TSource1, source2: TSource2, customizer: _MergeWithCustomizer): TObject & TSource1 & TSource2;
|
|
1234
|
+
|
|
1235
|
+
/**
|
|
1236
|
+
* @internal
|
|
1237
|
+
*/
|
|
1238
|
+
export declare function _mergeWith<TObject, TSource1, TSource2, TSource3>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, customizer: _MergeWithCustomizer): TObject & TSource1 & TSource2 & TSource3;
|
|
1239
|
+
|
|
1240
|
+
/**
|
|
1241
|
+
* @internal
|
|
1242
|
+
*/
|
|
1243
|
+
export declare function _mergeWith<TObject, TSource1, TSource2, TSource3, TSource4>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: _MergeWithCustomizer): TObject & TSource1 & TSource2 & TSource3 & TSource4;
|
|
1244
|
+
|
|
1245
|
+
/**
|
|
1246
|
+
* @internal
|
|
1247
|
+
*/
|
|
1248
|
+
export declare function _mergeWith(object: any, ...otherArgs: any[]): any;
|
|
1249
|
+
|
|
1250
|
+
/**
|
|
1251
|
+
* The customizer of `_mergeWith`: invoked per property with the destination value, the source value, the
|
|
1252
|
+
* key, the destination and source objects being merged, and the stack of traversed source values. A result
|
|
1253
|
+
* other than `undefined` is used as the merged value.
|
|
1254
|
+
*
|
|
1255
|
+
* @internal
|
|
1256
|
+
*/
|
|
1257
|
+
export declare type _MergeWithCustomizer = (value: any, srcValue: any, key: string, object: any, source: any, stack: any) => any;
|
|
1258
|
+
|
|
1259
|
+
/**
|
|
1260
|
+
* Computes the minimum value of `array` using the `<` operator, so mixed values coerce the way the operator
|
|
1261
|
+
* does. Nullish, `NaN` and symbol elements are skipped. If `array` is empty or falsey, `undefined` is
|
|
1262
|
+
* returned.
|
|
1263
|
+
*
|
|
1264
|
+
* @param array - The array to iterate over.
|
|
1265
|
+
* @returns Returns the minimum value.
|
|
1266
|
+
* @internal
|
|
1267
|
+
*/
|
|
1268
|
+
export declare function _min<T>(array: readonly [T, ...T[]]): T;
|
|
1269
|
+
|
|
1270
|
+
/**
|
|
1271
|
+
* @internal
|
|
1272
|
+
*/
|
|
1273
|
+
export declare function _min<T>(array: _List<T> | null | undefined): T | undefined;
|
|
1274
|
+
|
|
1275
|
+
/**
|
|
1276
|
+
* Creates a function that negates the result of the predicate `predicate`. The predicate is invoked with
|
|
1277
|
+
* the `this` binding and arguments of the created function, and its result is coerced to a boolean.
|
|
1278
|
+
*
|
|
1279
|
+
* @param predicate - The predicate to negate.
|
|
1280
|
+
* @returns Returns the new negated function.
|
|
1281
|
+
* @throws TypeError when `predicate` is not a function.
|
|
1282
|
+
* @internal
|
|
1283
|
+
*/
|
|
1284
|
+
export declare function _negate<T extends unknown[]>(predicate: (...args: T) => boolean): (...args: T) => boolean;
|
|
1285
|
+
|
|
634
1286
|
/**
|
|
635
1287
|
* @internal
|
|
636
1288
|
*/
|
|
@@ -891,6 +1543,47 @@ export declare function _range(start: number, end?: number, step?: number): numb
|
|
|
891
1543
|
*/
|
|
892
1544
|
export declare function _range(end: number, index: string | number, guard: object): number[];
|
|
893
1545
|
|
|
1546
|
+
/**
|
|
1547
|
+
* Reduces `collection` to a value which is the accumulated result of running each element in `collection`
|
|
1548
|
+
* thru `iteratee`, where each successive invocation is supplied the return value of the previous. If
|
|
1549
|
+
* `accumulator` is not given, the first element of `collection` is used as the initial value; whether it
|
|
1550
|
+
* was given is decided by the argument count, as in lodash. The iteratee is invoked with four arguments:
|
|
1551
|
+
* (accumulator, value, index|key, collection). Arrays and array-likes are iterated by index, strings by
|
|
1552
|
+
* character, other objects by their own enumerable string keys.
|
|
1553
|
+
*
|
|
1554
|
+
* @param collection - The collection to iterate over.
|
|
1555
|
+
* @param iteratee - The function invoked per iteration, or an iteratee shorthand.
|
|
1556
|
+
* @param accumulator - The initial value.
|
|
1557
|
+
* @returns Returns the accumulated value.
|
|
1558
|
+
* @internal
|
|
1559
|
+
*/
|
|
1560
|
+
export declare function _reduce<T, TResult>(collection: T[] | null | undefined, iteratee: _MemoListIterator<T, TResult, T[]>, accumulator: TResult): TResult;
|
|
1561
|
+
|
|
1562
|
+
/**
|
|
1563
|
+
* @internal
|
|
1564
|
+
*/
|
|
1565
|
+
export declare function _reduce<T, TResult>(collection: _List<T> | null | undefined, iteratee: _MemoListIterator<T, TResult, _List<T>>, accumulator: TResult): TResult;
|
|
1566
|
+
|
|
1567
|
+
/**
|
|
1568
|
+
* @internal
|
|
1569
|
+
*/
|
|
1570
|
+
export declare function _reduce<T extends object, TResult>(collection: T | null | undefined, iteratee: _MemoObjectIterator<T[keyof T], TResult, T>, accumulator: TResult): TResult;
|
|
1571
|
+
|
|
1572
|
+
/**
|
|
1573
|
+
* @internal
|
|
1574
|
+
*/
|
|
1575
|
+
export declare function _reduce<T>(collection: T[] | null | undefined, iteratee: _MemoListIterator<T, T, T[]>): T | undefined;
|
|
1576
|
+
|
|
1577
|
+
/**
|
|
1578
|
+
* @internal
|
|
1579
|
+
*/
|
|
1580
|
+
export declare function _reduce<T>(collection: _List<T> | null | undefined, iteratee: _MemoListIterator<T, T, _List<T>>): T | undefined;
|
|
1581
|
+
|
|
1582
|
+
/**
|
|
1583
|
+
* @internal
|
|
1584
|
+
*/
|
|
1585
|
+
export declare function _reduce<T extends object>(collection: T | null | undefined, iteratee: _MemoObjectIterator<T[keyof T], T[keyof T], T>): T[keyof T] | undefined;
|
|
1586
|
+
|
|
894
1587
|
/**
|
|
895
1588
|
* Given an object containing the parsed translation bundle, this function creates a new object which contains
|
|
896
1589
|
* only key → value mapping between translation key and the actual value.
|
|
@@ -929,6 +1622,14 @@ export declare function _set<T extends object>(object: T, path: _PropertyPath, v
|
|
|
929
1622
|
*/
|
|
930
1623
|
export declare function _set<TResult>(object: object, path: _PropertyPath, value: unknown): TResult;
|
|
931
1624
|
|
|
1625
|
+
/**
|
|
1626
|
+
* The customizer of `_updateWith`: invoked for every intermediate path segment with the current value, the
|
|
1627
|
+
* key and the object holding it. A result other than `undefined` is used as the container for that segment.
|
|
1628
|
+
*
|
|
1629
|
+
* @internal
|
|
1630
|
+
*/
|
|
1631
|
+
export declare type _SetWithCustomizer<T> = (nsValue: any, key: string, nsObject: T) => any;
|
|
1632
|
+
|
|
932
1633
|
/**
|
|
933
1634
|
* @internal
|
|
934
1635
|
*/
|
|
@@ -1005,6 +1706,24 @@ export declare type SpecificMatcherFunction = (message: string) => boolean;
|
|
|
1005
1706
|
*/
|
|
1006
1707
|
export declare function strictBarrel<T extends object>(packageName: string, exports: T): T;
|
|
1007
1708
|
|
|
1709
|
+
/**
|
|
1710
|
+
* @internal
|
|
1711
|
+
*/
|
|
1712
|
+
export declare type _StringIterator<TResult> = (char: string, index: number, string: string) => TResult;
|
|
1713
|
+
|
|
1714
|
+
/**
|
|
1715
|
+
* This method is like `_sum` except that it accepts `iteratee` which is invoked for each element in `array`
|
|
1716
|
+
* to generate the value to be summed. The iteratee is invoked with one argument: (value). Values are added
|
|
1717
|
+
* with the `+` operator, `undefined` results are skipped, and, as in lodash, an empty or nullish array
|
|
1718
|
+
* yields `0` while an array without any defined result yields `undefined`.
|
|
1719
|
+
*
|
|
1720
|
+
* @param array - The array to iterate over.
|
|
1721
|
+
* @param iteratee - The iteratee invoked per element, or a property shorthand.
|
|
1722
|
+
* @returns Returns the sum.
|
|
1723
|
+
* @internal
|
|
1724
|
+
*/
|
|
1725
|
+
export declare function _sumBy<T>(array: _List<T> | null | undefined, iteratee?: ((value: T) => number) | string): number;
|
|
1726
|
+
|
|
1008
1727
|
/**
|
|
1009
1728
|
* Suppresses certain console outputs
|
|
1010
1729
|
*
|
|
@@ -1026,6 +1745,21 @@ export declare function suppressConsole<T>(fn: () => T | Promise<T>, type?: Cons
|
|
|
1026
1745
|
*/
|
|
1027
1746
|
export declare function suppressConsole<T>(fn: () => T | Promise<T>, matcherFn: MatcherFunction): T | Promise<T>;
|
|
1028
1747
|
|
|
1748
|
+
/**
|
|
1749
|
+
* Gets all but the first element of `array` as a new dense array. Nullish input and anything without a
|
|
1750
|
+
* truthy `length` yield an empty array.
|
|
1751
|
+
*
|
|
1752
|
+
* @param array - The array to query.
|
|
1753
|
+
* @returns Returns the slice of `array`.
|
|
1754
|
+
* @internal
|
|
1755
|
+
*/
|
|
1756
|
+
export declare function _tail<T extends unknown[]>(array: readonly [unknown, ...T]): T;
|
|
1757
|
+
|
|
1758
|
+
/**
|
|
1759
|
+
* @internal
|
|
1760
|
+
*/
|
|
1761
|
+
export declare function _tail<T>(array?: _List<T> | null): T[];
|
|
1762
|
+
|
|
1029
1763
|
/**
|
|
1030
1764
|
* Creates a throttled function that only invokes `func` at most once per every `wait` milliseconds. The
|
|
1031
1765
|
* throttled function comes with a `cancel` method to cancel delayed `func` invocations and a `flush` method
|
|
@@ -1074,6 +1808,37 @@ export declare type _ThrottleSettingsLeading = (_ThrottleSettings & {
|
|
|
1074
1808
|
leading: true;
|
|
1075
1809
|
}) | Omit<_ThrottleSettings, "leading">;
|
|
1076
1810
|
|
|
1811
|
+
/**
|
|
1812
|
+
* Invokes the iteratee `n` times, returning an array of the results of each invocation. The iteratee is
|
|
1813
|
+
* invoked with one argument, the index, and anything but a function is replaced by the identity, so the
|
|
1814
|
+
* indices are returned. The count is coerced to an integer the way lodash does it; a count below 1 or above
|
|
1815
|
+
* the safe integer range yields an empty array.
|
|
1816
|
+
*
|
|
1817
|
+
* @param n - The number of times to invoke `iteratee`.
|
|
1818
|
+
* @param iteratee - The function invoked per iteration.
|
|
1819
|
+
* @returns Returns the array of results.
|
|
1820
|
+
* @internal
|
|
1821
|
+
*/
|
|
1822
|
+
export declare function _times<TResult>(n: number, iteratee: (index: number) => TResult): TResult[];
|
|
1823
|
+
|
|
1824
|
+
/**
|
|
1825
|
+
* @internal
|
|
1826
|
+
*/
|
|
1827
|
+
export declare function _times(n: number): number[];
|
|
1828
|
+
|
|
1829
|
+
/**
|
|
1830
|
+
* The inverse of `_escape`; this method converts the HTML entities `&`, `<`, `>`, `"` and
|
|
1831
|
+
* `'` in `string` to their corresponding characters.
|
|
1832
|
+
*
|
|
1833
|
+
* **Note:** No other HTML entities are unescaped. To unescape additional HTML entities use a third-party
|
|
1834
|
+
* library like [he](https://mths.be/he).
|
|
1835
|
+
*
|
|
1836
|
+
* @param string - The string to unescape.
|
|
1837
|
+
* @returns Returns the unescaped string.
|
|
1838
|
+
* @internal
|
|
1839
|
+
*/
|
|
1840
|
+
export declare function _unescape(string?: string): string;
|
|
1841
|
+
|
|
1077
1842
|
/**
|
|
1078
1843
|
* Creates an array of unique values, in order, from all given arrays using SameValueZero for equality
|
|
1079
1844
|
* comparisons. Only array-like objects are inspected; other arguments, strings included, are skipped.
|
|
@@ -1084,6 +1849,44 @@ export declare type _ThrottleSettingsLeading = (_ThrottleSettings & {
|
|
|
1084
1849
|
*/
|
|
1085
1850
|
export declare function _union<T>(...arrays: (_List<T> | null | undefined)[]): T[];
|
|
1086
1851
|
|
|
1852
|
+
/**
|
|
1853
|
+
* This method is like `_union` except that it accepts `iteratee` which is invoked for each element of each
|
|
1854
|
+
* array to generate the criterion by which uniqueness is computed. Result values are chosen from the first
|
|
1855
|
+
* array in which the value occurs. The iteratee is invoked with one argument: (value). As in lodash, the
|
|
1856
|
+
* last argument is taken as the iteratee unless it is an array-like object, so an array is always a list
|
|
1857
|
+
* to merge, and arguments that are not array-like objects are skipped.
|
|
1858
|
+
*
|
|
1859
|
+
* @param arrays - The arrays to inspect, followed by the optional iteratee.
|
|
1860
|
+
* @returns Returns the new array of combined values.
|
|
1861
|
+
* @internal
|
|
1862
|
+
*/
|
|
1863
|
+
export declare function _unionBy<T>(arrays: _List<T> | null | undefined, iteratee?: _ValueIteratee<T>): T[];
|
|
1864
|
+
|
|
1865
|
+
/**
|
|
1866
|
+
* @internal
|
|
1867
|
+
*/
|
|
1868
|
+
export declare function _unionBy<T>(arrays1: _List<T> | null | undefined, arrays2: _List<T> | null | undefined, iteratee?: _ValueIteratee<T>): T[];
|
|
1869
|
+
|
|
1870
|
+
/**
|
|
1871
|
+
* @internal
|
|
1872
|
+
*/
|
|
1873
|
+
export declare function _unionBy<T>(arrays1: _List<T> | null | undefined, arrays2: _List<T> | null | undefined, arrays3: _List<T> | null | undefined, iteratee?: _ValueIteratee<T>): T[];
|
|
1874
|
+
|
|
1875
|
+
/**
|
|
1876
|
+
* @internal
|
|
1877
|
+
*/
|
|
1878
|
+
export declare function _unionBy<T>(arrays1: _List<T> | null | undefined, arrays2: _List<T> | null | undefined, arrays3: _List<T> | null | undefined, arrays4: _List<T> | null | undefined, iteratee?: _ValueIteratee<T>): T[];
|
|
1879
|
+
|
|
1880
|
+
/**
|
|
1881
|
+
* @internal
|
|
1882
|
+
*/
|
|
1883
|
+
export declare function _unionBy<T>(arrays1: _List<T> | null | undefined, arrays2: _List<T> | null | undefined, arrays3: _List<T> | null | undefined, arrays4: _List<T> | null | undefined, arrays5: _List<T> | null | undefined, ...iteratee: (_ValueIteratee<T> | _List<T> | null | undefined)[]): T[];
|
|
1884
|
+
|
|
1885
|
+
/**
|
|
1886
|
+
* @internal
|
|
1887
|
+
*/
|
|
1888
|
+
export declare function _unionBy<T>(...values: (_ValueIteratee<T> | _List<T> | null | undefined)[]): T[];
|
|
1889
|
+
|
|
1087
1890
|
/**
|
|
1088
1891
|
* Creates a duplicate-free version of an array, using SameValueZero for equality comparisons, in which
|
|
1089
1892
|
* only the first occurrence of each element is kept. The order of result values is determined by the
|
|
@@ -1138,6 +1941,28 @@ export declare function _uniqWith<T>(array: _List<T> | null | undefined, compara
|
|
|
1138
1941
|
*/
|
|
1139
1942
|
export declare function _update(object: object, path: _PropertyPath, updater: (value: any) => any): any;
|
|
1140
1943
|
|
|
1944
|
+
/**
|
|
1945
|
+
* This method is like `_update` except that it accepts `customizer` which is invoked to produce the objects
|
|
1946
|
+
* of `path`. If `customizer` returns `undefined` path creation is handled by the method instead. The
|
|
1947
|
+
* `customizer` is invoked with three arguments: (nsValue, key, nsObject). Anything but a function is
|
|
1948
|
+
* ignored as a customizer, and anything but a function is the identity as an updater.
|
|
1949
|
+
*
|
|
1950
|
+
* **Note:** This method mutates `object`.
|
|
1951
|
+
*
|
|
1952
|
+
* @param object - The object to modify.
|
|
1953
|
+
* @param path - The path of the property to set.
|
|
1954
|
+
* @param updater - The function to produce the updated value.
|
|
1955
|
+
* @param customizer - The function to customize assigned values.
|
|
1956
|
+
* @returns Returns `object`.
|
|
1957
|
+
* @internal
|
|
1958
|
+
*/
|
|
1959
|
+
export declare function _updateWith<T extends object>(object: T, path: _PropertyPath, updater: (oldValue: any) => any, customizer?: _SetWithCustomizer<T>): T;
|
|
1960
|
+
|
|
1961
|
+
/**
|
|
1962
|
+
* @internal
|
|
1963
|
+
*/
|
|
1964
|
+
export declare function _updateWith<T extends object, TResult>(object: T, path: _PropertyPath, updater: (oldValue: any) => any, customizer?: _SetWithCustomizer<T>): TResult;
|
|
1965
|
+
|
|
1141
1966
|
/**
|
|
1142
1967
|
* An iteratee as lodash accepts it: a function, a property name or path, a `[path, value]` pair, or a
|
|
1143
1968
|
* partial object to match.
|
|
@@ -1173,6 +1998,20 @@ export declare type WaitForFn = <T>(callback: () => T | Promise<T>, options?: {
|
|
|
1173
1998
|
timeout?: number;
|
|
1174
1999
|
}) => Promise<T>;
|
|
1175
2000
|
|
|
2001
|
+
/**
|
|
2002
|
+
* Creates an array excluding all given values using SameValueZero for equality comparisons. The order and
|
|
2003
|
+
* references of result values are determined by the input array, with `-0` normalised to `0`. Only an
|
|
2004
|
+
* array-like object is inspected: any other `array` yields an empty array.
|
|
2005
|
+
*
|
|
2006
|
+
* **Note:** Unlike `_.pull`, this method returns a new array.
|
|
2007
|
+
*
|
|
2008
|
+
* @param array - The array to inspect.
|
|
2009
|
+
* @param values - The values to exclude.
|
|
2010
|
+
* @returns Returns the new array of filtered values.
|
|
2011
|
+
* @internal
|
|
2012
|
+
*/
|
|
2013
|
+
export declare function _without<T>(array: _List<T> | null | undefined, ...values: T[]): T[];
|
|
2014
|
+
|
|
1176
2015
|
/**
|
|
1177
2016
|
* Creates an array of grouped elements, the first of which contains the first elements of the given arrays,
|
|
1178
2017
|
* the second of which contains the second elements of the given arrays, and so on. Shorter arrays are padded
|