@gooddata/util 11.68.0-alpha.7 → 11.68.0-alpha.9
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 +4 -2
- 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 +18 -0
- package/esm/_/_baseDifference.d.ts.map +1 -0
- package/esm/_/_baseDifference.js +79 -0
- 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/_/clamp.d.ts +17 -0
- package/esm/_/clamp.d.ts.map +1 -0
- package/esm/_/clamp.js +56 -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/_/difference.d.ts.map +1 -1
- package/esm/_/difference.js +2 -23
- package/esm/_/differenceBy.d.ts +39 -0
- package/esm/_/differenceBy.d.ts.map +1 -0
- package/esm/_/differenceBy.js +40 -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/_/toNumber.d.ts +11 -0
- package/esm/_/toNumber.d.ts.map +1 -0
- package/esm/_/toNumber.js +69 -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/_/update.d.ts +17 -0
- package/esm/_/update.d.ts.map +1 -0
- package/esm/_/update.js +55 -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 +40 -3
- package/esm/index.d.ts.map +1 -1
- package/esm/index.js +39 -2
- package/esm/util.d.ts +918 -1
- 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,50 @@ 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
|
+
|
|
103
|
+
/**
|
|
104
|
+
* Clamps `number` within the inclusive `lower` and `upper` bounds. With two arguments the second one is the
|
|
105
|
+
* upper bound. The upper bound is applied first, bounds that convert to `NaN` count as `0`, an `undefined`
|
|
106
|
+
* bound is skipped, and a `NaN` number is returned as is.
|
|
107
|
+
*
|
|
108
|
+
* @param number - The number to clamp.
|
|
109
|
+
* @param lower - The lower bound.
|
|
110
|
+
* @param upper - The upper bound.
|
|
111
|
+
* @returns Returns the clamped number.
|
|
112
|
+
* @internal
|
|
113
|
+
*/
|
|
114
|
+
export declare function _clamp(number: number, lower: number, upper: number): number;
|
|
115
|
+
|
|
116
|
+
/**
|
|
117
|
+
* @internal
|
|
118
|
+
*/
|
|
119
|
+
export declare function _clamp(number: number, upper: number): number;
|
|
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
|
+
|
|
29
133
|
/**
|
|
30
134
|
* Recursively clones `value`.
|
|
31
135
|
*
|
|
@@ -40,6 +144,33 @@ export declare function _capitalize(string?: string): string;
|
|
|
40
144
|
*/
|
|
41
145
|
export declare function _cloneDeep<T>(value: T): T;
|
|
42
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
|
+
|
|
43
174
|
/**
|
|
44
175
|
* Returns combine guard from input guards as a result type is union type of guarded types
|
|
45
176
|
* Its good for array filtering base on multiple guards and its return correct result union type
|
|
@@ -63,6 +194,11 @@ export declare function _compact<T>(array: _List<T | _Falsey> | null | undefined
|
|
|
63
194
|
*/
|
|
64
195
|
export declare type _Comparator<T> = (a: T, b: T) => boolean;
|
|
65
196
|
|
|
197
|
+
/**
|
|
198
|
+
* @internal
|
|
199
|
+
*/
|
|
200
|
+
export declare type _Comparator2<T1, T2> = (a: T1, b: T2) => boolean;
|
|
201
|
+
|
|
66
202
|
/**
|
|
67
203
|
* A console function, like log, warn or error
|
|
68
204
|
*
|
|
@@ -77,6 +213,15 @@ export declare type ConsoleFunction = (...data: any[]) => void;
|
|
|
77
213
|
*/
|
|
78
214
|
export declare type ConsoleType = "error" | "warn" | "log" | "debug" | "info";
|
|
79
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
|
+
|
|
80
225
|
/**
|
|
81
226
|
* Wraps a testing-library waitFor so it polls every millisecond instead of the default 50ms.
|
|
82
227
|
*
|
|
@@ -165,6 +310,57 @@ export declare type _DebounceSettingsLeading = _DebounceSettings & {
|
|
|
165
310
|
leading: true;
|
|
166
311
|
};
|
|
167
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
|
+
|
|
168
364
|
/**
|
|
169
365
|
* Returns a promise which will resolve after the provided number of milliseconds.
|
|
170
366
|
*
|
|
@@ -193,6 +389,91 @@ export declare type _Dictionary<T> = {
|
|
|
193
389
|
*/
|
|
194
390
|
export declare function _difference<T>(array: _List<T> | null | undefined, ...values: _List<T>[]): T[];
|
|
195
391
|
|
|
392
|
+
/**
|
|
393
|
+
* This method is like `_difference` except that it accepts `iteratee` which is invoked for each element of
|
|
394
|
+
* `array` and `values` to generate the criterion by which they're compared. The order and references of
|
|
395
|
+
* result values are determined by the first array. The iteratee is invoked with one argument: (value).
|
|
396
|
+
* The iteratee is the last argument unless that argument is array-like, in which case it is one more list of
|
|
397
|
+
* values and the elements are compared as they are.
|
|
398
|
+
*
|
|
399
|
+
* @param array - The array to inspect.
|
|
400
|
+
* @param values - The values to exclude, followed by the iteratee.
|
|
401
|
+
* @returns Returns the new array of filtered values.
|
|
402
|
+
* @internal
|
|
403
|
+
*/
|
|
404
|
+
export declare function _differenceBy<T1, T2>(array: _List<T1> | null | undefined, values: _List<T2>, iteratee: _ValueIteratee<T1 | T2>): T1[];
|
|
405
|
+
|
|
406
|
+
/**
|
|
407
|
+
* @internal
|
|
408
|
+
*/
|
|
409
|
+
export declare function _differenceBy<T1, T2, T3>(array: _List<T1> | null | undefined, values1: _List<T2>, values2: _List<T3>, iteratee: _ValueIteratee<T1 | T2 | T3>): T1[];
|
|
410
|
+
|
|
411
|
+
/**
|
|
412
|
+
* @internal
|
|
413
|
+
*/
|
|
414
|
+
export declare function _differenceBy<T1, T2, T3, T4>(array: _List<T1> | null | undefined, values1: _List<T2>, values2: _List<T3>, values3: _List<T4>, iteratee: _ValueIteratee<T1 | T2 | T3 | T4>): T1[];
|
|
415
|
+
|
|
416
|
+
/**
|
|
417
|
+
* @internal
|
|
418
|
+
*/
|
|
419
|
+
export declare function _differenceBy<T1, T2, T3, T4, T5>(array: _List<T1> | null | undefined, values1: _List<T2>, values2: _List<T3>, values3: _List<T4>, values4: _List<T5>, iteratee: _ValueIteratee<T1 | T2 | T3 | T4 | T5>): T1[];
|
|
420
|
+
|
|
421
|
+
/**
|
|
422
|
+
* @internal
|
|
423
|
+
*/
|
|
424
|
+
export declare function _differenceBy<T1, T2, T3, T4, T5, T6>(array: _List<T1> | null | undefined, values1: _List<T2>, values2: _List<T3>, values3: _List<T4>, values4: _List<T5>, values5: _List<T6>, iteratee: _ValueIteratee<T1 | T2 | T3 | T4 | T5 | T6>): T1[];
|
|
425
|
+
|
|
426
|
+
/**
|
|
427
|
+
* @internal
|
|
428
|
+
*/
|
|
429
|
+
export declare function _differenceBy<T1, T2, T3, T4, T5, T6, T7>(array: _List<T1> | null | undefined, values1: _List<T2>, values2: _List<T3>, values3: _List<T4>, values4: _List<T5>, values5: _List<T6>, ...values: (_List<T7> | _ValueIteratee<T1 | T2 | T3 | T4 | T5 | T6 | T7>)[]): T1[];
|
|
430
|
+
|
|
431
|
+
/**
|
|
432
|
+
* @internal
|
|
433
|
+
*/
|
|
434
|
+
export declare function _differenceBy<T>(array: _List<T> | null | undefined, ...values: _List<T>[]): T[];
|
|
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
|
+
|
|
196
477
|
/**
|
|
197
478
|
* @internal
|
|
198
479
|
*/
|
|
@@ -233,12 +514,52 @@ export declare function _escape(string?: string): string;
|
|
|
233
514
|
*/
|
|
234
515
|
export declare function escapeRegExp(value: string): string;
|
|
235
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
|
+
|
|
236
529
|
/** Common interface between Arrays and jQuery objects */
|
|
237
530
|
/**
|
|
238
531
|
* @internal
|
|
239
532
|
*/
|
|
240
533
|
export declare type _Falsey = null | undefined | false | "" | 0 | 0n;
|
|
241
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
|
+
|
|
242
563
|
/**
|
|
243
564
|
* @internal
|
|
244
565
|
*/
|
|
@@ -264,6 +585,97 @@ export declare type _Function3<T1, T2, T3, R> = (t1: T1, t2: T2, t3: T3) => R;
|
|
|
264
585
|
*/
|
|
265
586
|
export declare type _Function4<T1, T2, T3, T4, R> = (t1: T1, t2: T2, t3: T3, t4: T4) => R;
|
|
266
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
|
+
|
|
267
679
|
/**
|
|
268
680
|
* Creates an object composed of keys generated from the results of running each element of
|
|
269
681
|
* `collection` thru `iteratee`. The order of grouped values is determined by the order they occur in
|
|
@@ -323,7 +735,121 @@ export declare function _has<T>(object: T, path: _PropertyPath): boolean;
|
|
|
323
735
|
*
|
|
324
736
|
* @internal
|
|
325
737
|
*/
|
|
326
|
-
export declare function hashCodeString(value: string): number;
|
|
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[];
|
|
835
|
+
|
|
836
|
+
/**
|
|
837
|
+
* @internal
|
|
838
|
+
*/
|
|
839
|
+
export declare function _intersectionWith<T>(array?: _List<T> | null, ...values: (_List<T> | _Comparator<T>)[]): T[];
|
|
840
|
+
|
|
841
|
+
/**
|
|
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.
|
|
847
|
+
*
|
|
848
|
+
* @param object - The object to invert.
|
|
849
|
+
* @returns Returns the new inverted object.
|
|
850
|
+
* @internal
|
|
851
|
+
*/
|
|
852
|
+
export declare function _invert(object: object): _Dictionary<string>;
|
|
327
853
|
|
|
328
854
|
/**
|
|
329
855
|
* Checks if value is empty. A value is considered empty unless it’s an arguments object, array, string, or
|
|
@@ -382,6 +908,17 @@ export declare function _isEmpty(value?: any): boolean;
|
|
|
382
908
|
*/
|
|
383
909
|
export declare function _isEqual(value: unknown, other: unknown): boolean;
|
|
384
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
|
+
|
|
385
922
|
/**
|
|
386
923
|
* @internal
|
|
387
924
|
*/
|
|
@@ -440,6 +977,11 @@ export declare type _List<T> = ArrayLike<T>;
|
|
|
440
977
|
*/
|
|
441
978
|
export declare type _ListIteratee<T> = _ListIterator<T, _NotVoid> | _IterateeShorthand<T>;
|
|
442
979
|
|
|
980
|
+
/**
|
|
981
|
+
* @internal
|
|
982
|
+
*/
|
|
983
|
+
export declare type _ListIterateeCustom<T, TResult> = _ListIterator<T, TResult> | _IterateeShorthand<T>;
|
|
984
|
+
|
|
443
985
|
/**
|
|
444
986
|
* @internal
|
|
445
987
|
*/
|
|
@@ -474,6 +1016,79 @@ export declare type _MapCache = {
|
|
|
474
1016
|
*/
|
|
475
1017
|
export declare type _MapCacheConstructor = new () => _MapCache;
|
|
476
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
|
+
|
|
477
1092
|
/**
|
|
478
1093
|
* A matcher for suppressConsole
|
|
479
1094
|
*
|
|
@@ -494,6 +1109,22 @@ export declare type Matcher = {
|
|
|
494
1109
|
*/
|
|
495
1110
|
export declare type MatcherFunction = (console: Record<ConsoleType, ConsoleFunction>, type: ConsoleType, message: string) => boolean;
|
|
496
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
|
+
|
|
497
1128
|
/**
|
|
498
1129
|
* The shape of `_memoize`: the memoizing function itself plus the `Cache` constructor every memoized
|
|
499
1130
|
* function starts with.
|
|
@@ -533,6 +1164,16 @@ export declare type _MemoizedFunction = {
|
|
|
533
1164
|
cache: _MapCache;
|
|
534
1165
|
};
|
|
535
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
|
+
|
|
536
1177
|
/**
|
|
537
1178
|
* Recursively merges own and inherited enumerable string keyed properties of source objects into the
|
|
538
1179
|
* destination object. Source properties that resolve to `undefined` are skipped if a destination value
|
|
@@ -569,6 +1210,79 @@ export declare function _merge<TObject, TSource1, TSource2, TSource3, TSource4>(
|
|
|
569
1210
|
*/
|
|
570
1211
|
export declare function _merge(object: any, ...otherArgs: any[]): any;
|
|
571
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
|
+
|
|
572
1286
|
/**
|
|
573
1287
|
* @internal
|
|
574
1288
|
*/
|
|
@@ -829,6 +1543,47 @@ export declare function _range(start: number, end?: number, step?: number): numb
|
|
|
829
1543
|
*/
|
|
830
1544
|
export declare function _range(end: number, index: string | number, guard: object): number[];
|
|
831
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
|
+
|
|
832
1587
|
/**
|
|
833
1588
|
* Given an object containing the parsed translation bundle, this function creates a new object which contains
|
|
834
1589
|
* only key → value mapping between translation key and the actual value.
|
|
@@ -867,6 +1622,14 @@ export declare function _set<T extends object>(object: T, path: _PropertyPath, v
|
|
|
867
1622
|
*/
|
|
868
1623
|
export declare function _set<TResult>(object: object, path: _PropertyPath, value: unknown): TResult;
|
|
869
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
|
+
|
|
870
1633
|
/**
|
|
871
1634
|
* @internal
|
|
872
1635
|
*/
|
|
@@ -943,6 +1706,24 @@ export declare type SpecificMatcherFunction = (message: string) => boolean;
|
|
|
943
1706
|
*/
|
|
944
1707
|
export declare function strictBarrel<T extends object>(packageName: string, exports: T): T;
|
|
945
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
|
+
|
|
946
1727
|
/**
|
|
947
1728
|
* Suppresses certain console outputs
|
|
948
1729
|
*
|
|
@@ -964,6 +1745,21 @@ export declare function suppressConsole<T>(fn: () => T | Promise<T>, type?: Cons
|
|
|
964
1745
|
*/
|
|
965
1746
|
export declare function suppressConsole<T>(fn: () => T | Promise<T>, matcherFn: MatcherFunction): T | Promise<T>;
|
|
966
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
|
+
|
|
967
1763
|
/**
|
|
968
1764
|
* Creates a throttled function that only invokes `func` at most once per every `wait` milliseconds. The
|
|
969
1765
|
* throttled function comes with a `cancel` method to cancel delayed `func` invocations and a `flush` method
|
|
@@ -1012,6 +1808,37 @@ export declare type _ThrottleSettingsLeading = (_ThrottleSettings & {
|
|
|
1012
1808
|
leading: true;
|
|
1013
1809
|
}) | Omit<_ThrottleSettings, "leading">;
|
|
1014
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
|
+
|
|
1015
1842
|
/**
|
|
1016
1843
|
* Creates an array of unique values, in order, from all given arrays using SameValueZero for equality
|
|
1017
1844
|
* comparisons. Only array-like objects are inspected; other arguments, strings included, are skipped.
|
|
@@ -1022,6 +1849,44 @@ export declare type _ThrottleSettingsLeading = (_ThrottleSettings & {
|
|
|
1022
1849
|
*/
|
|
1023
1850
|
export declare function _union<T>(...arrays: (_List<T> | null | undefined)[]): T[];
|
|
1024
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
|
+
|
|
1025
1890
|
/**
|
|
1026
1891
|
* Creates a duplicate-free version of an array, using SameValueZero for equality comparisons, in which
|
|
1027
1892
|
* only the first occurrence of each element is kept. The order of result values is determined by the
|
|
@@ -1060,6 +1925,44 @@ declare const uniqueSymbol: unique symbol;
|
|
|
1060
1925
|
*/
|
|
1061
1926
|
export declare function _uniqWith<T>(array: _List<T> | null | undefined, comparator?: _Comparator<T>): T[];
|
|
1062
1927
|
|
|
1928
|
+
/**
|
|
1929
|
+
* This method is like `_set` except that it accepts `updater` to produce the value to set. The updater is
|
|
1930
|
+
* invoked with one argument, the current value at `path`, which is `undefined` when the path does not exist;
|
|
1931
|
+
* a non-function updater keeps the current value. Missing segments of the path are created as lodash does,
|
|
1932
|
+
* arrays for index segments and plain objects otherwise.
|
|
1933
|
+
*
|
|
1934
|
+
* **Note:** This method mutates `object`.
|
|
1935
|
+
*
|
|
1936
|
+
* @param object - The object to modify.
|
|
1937
|
+
* @param path - The path of the property to set.
|
|
1938
|
+
* @param updater - The function to produce the updated value.
|
|
1939
|
+
* @returns Returns `object`.
|
|
1940
|
+
* @internal
|
|
1941
|
+
*/
|
|
1942
|
+
export declare function _update(object: object, path: _PropertyPath, updater: (value: any) => any): any;
|
|
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
|
+
|
|
1063
1966
|
/**
|
|
1064
1967
|
* An iteratee as lodash accepts it: a function, a property name or path, a `[path, value]` pair, or a
|
|
1065
1968
|
* partial object to match.
|
|
@@ -1095,6 +1998,20 @@ export declare type WaitForFn = <T>(callback: () => T | Promise<T>, options?: {
|
|
|
1095
1998
|
timeout?: number;
|
|
1096
1999
|
}) => Promise<T>;
|
|
1097
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
|
+
|
|
1098
2015
|
/**
|
|
1099
2016
|
* Creates an array of grouped elements, the first of which contains the first elements of the given arrays,
|
|
1100
2017
|
* the second of which contains the second elements of the given arrays, and so on. Shorter arrays are padded
|