@gooddata/util 11.68.0-alpha.5 → 11.68.0-alpha.7
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/LICENSE +1 -1
- package/NOTICE +177 -0
- package/esm/_/_assignValue.d.ts.map +1 -1
- package/esm/_/_assignValue.js +2 -6
- package/esm/_/_baseAssignValue.d.ts +41 -0
- package/esm/_/_baseAssignValue.d.ts.map +1 -0
- package/esm/_/_baseAssignValue.js +48 -0
- package/esm/_/_baseClone.d.ts.map +1 -1
- package/esm/_/_baseClone.js +3 -30
- package/esm/_/_baseMerge.d.ts +15 -0
- package/esm/_/_baseMerge.d.ts.map +1 -0
- package/esm/_/_baseMerge.js +137 -0
- package/esm/_/_baseOrderBy.d.ts +11 -0
- package/esm/_/_baseOrderBy.d.ts.map +1 -0
- package/esm/_/_baseOrderBy.js +70 -0
- package/esm/_/_basePickBy.d.ts +14 -0
- package/esm/_/_basePickBy.d.ts.map +1 -0
- package/esm/_/_basePickBy.js +57 -0
- package/esm/_/_cloneArrayBuffer.d.ts +39 -0
- package/esm/_/_cloneArrayBuffer.d.ts.map +1 -0
- package/esm/_/_cloneArrayBuffer.js +45 -0
- package/esm/_/_cloneTypedArray.d.ts +10 -0
- package/esm/_/_cloneTypedArray.d.ts.map +1 -0
- package/esm/_/_cloneTypedArray.js +49 -0
- package/esm/_/_compareAscending.d.ts +12 -0
- package/esm/_/_compareAscending.d.ts.map +1 -0
- package/esm/_/_compareAscending.js +78 -0
- package/esm/_/_createCompounder.d.ts +11 -0
- package/esm/_/_createCompounder.d.ts.map +1 -0
- package/esm/_/_createCompounder.js +47 -0
- package/esm/_/_initCloneObject.d.ts +10 -0
- package/esm/_/_initCloneObject.d.ts.map +1 -0
- package/esm/_/_initCloneObject.js +48 -0
- package/esm/_/_unicode.d.ts +27 -0
- package/esm/_/_unicode.d.ts.map +1 -0
- package/esm/_/_unicode.js +120 -0
- package/esm/_/camelCase.d.ts +10 -0
- package/esm/_/camelCase.d.ts.map +1 -0
- package/esm/_/camelCase.js +45 -0
- package/esm/_/capitalize.d.ts +9 -0
- package/esm/_/capitalize.d.ts.map +1 -0
- package/esm/_/capitalize.js +43 -0
- package/esm/_/deburr.d.ts +10 -0
- package/esm/_/deburr.d.ts.map +1 -0
- package/esm/_/deburr.js +243 -0
- package/esm/_/difference.d.ts +14 -0
- package/esm/_/difference.d.ts.map +1 -0
- package/esm/_/difference.js +67 -0
- package/esm/_/escape.d.ts +13 -0
- package/esm/_/escape.d.ts.map +1 -0
- package/esm/_/escape.js +56 -0
- package/esm/_/has.d.ts +23 -0
- package/esm/_/has.d.ts.map +1 -0
- package/esm/_/has.js +35 -0
- package/esm/_/isArray.d.ts +61 -0
- package/esm/_/isArray.d.ts.map +1 -0
- package/esm/_/isArray.js +62 -0
- package/esm/_/isPlainObject.d.ts +1 -1
- package/esm/_/isPlainObject.d.ts.map +1 -1
- package/esm/_/kebabCase.d.ts +9 -0
- package/esm/_/kebabCase.d.ts.map +1 -0
- package/esm/_/kebabCase.js +40 -0
- package/esm/_/keyBy.d.ts +17 -0
- package/esm/_/keyBy.d.ts.map +1 -0
- package/esm/_/keyBy.js +43 -0
- package/esm/_/keysIn.d.ts +10 -0
- package/esm/_/keysIn.d.ts.map +1 -0
- package/esm/_/keysIn.js +54 -0
- package/esm/_/memoize.d.ts +89 -0
- package/esm/_/memoize.d.ts.map +1 -0
- package/esm/_/memoize.js +36 -0
- package/esm/_/merge.d.ts +32 -0
- package/esm/_/merge.d.ts.map +1 -0
- package/esm/_/merge.js +45 -0
- package/esm/_/omit.d.ts +1 -5
- package/esm/_/omit.d.ts.map +1 -1
- package/esm/_/omitBy.d.ts +21 -0
- package/esm/_/omitBy.d.ts.map +1 -0
- package/esm/_/omitBy.js +37 -0
- package/esm/_/partial.d.ts +87 -0
- package/esm/_/partial.d.ts.map +1 -0
- package/esm/_/partial.js +30 -0
- package/esm/_/partition.d.ts +23 -0
- package/esm/_/partition.d.ts.map +1 -0
- package/esm/_/partition.js +42 -0
- package/esm/_/pick.d.ts +18 -0
- package/esm/_/pick.d.ts.map +1 -0
- package/esm/_/pick.js +48 -0
- package/esm/_/pickBy.d.ts +21 -0
- package/esm/_/pickBy.d.ts.map +1 -0
- package/esm/_/pickBy.js +36 -0
- package/esm/_/sortBy.d.ts +17 -0
- package/esm/_/sortBy.d.ts.map +1 -0
- package/esm/_/sortBy.js +46 -0
- package/esm/_/throttle.d.ts +76 -0
- package/esm/_/throttle.d.ts.map +1 -0
- package/esm/_/throttle.js +45 -0
- package/esm/_/toString.d.ts +11 -0
- package/esm/_/toString.d.ts.map +1 -0
- package/esm/_/toString.js +57 -0
- package/esm/_/types.d.ts +64 -0
- package/esm/_/types.d.ts.map +1 -1
- package/esm/_/union.d.ts +11 -0
- package/esm/_/union.d.ts.map +1 -0
- package/esm/_/union.js +55 -0
- package/esm/_/uniq.d.ts +12 -0
- package/esm/_/uniq.d.ts.map +1 -0
- package/esm/_/uniq.js +47 -0
- package/esm/_/uniqWith.d.ts +14 -0
- package/esm/_/uniqWith.d.ts.map +1 -0
- package/esm/_/uniqWith.js +59 -0
- package/esm/_/upperFirst.d.ts +10 -0
- package/esm/_/upperFirst.d.ts.map +1 -0
- package/esm/_/upperFirst.js +46 -0
- package/esm/_/words.d.ts +9 -0
- package/esm/_/words.d.ts.map +1 -0
- package/esm/_/words.js +50 -0
- package/esm/_/zip.d.ts +28 -0
- package/esm/_/zip.d.ts.map +1 -0
- package/esm/_/zip.js +38 -0
- package/esm/index.d.ts +23 -2
- package/esm/index.d.ts.map +1 -1
- package/esm/index.js +21 -0
- package/esm/util.d.ts +549 -0
- package/package.json +5 -4
package/esm/util.d.ts
CHANGED
|
@@ -7,6 +7,25 @@
|
|
|
7
7
|
* @packageDocumentation
|
|
8
8
|
*/
|
|
9
9
|
|
|
10
|
+
/**
|
|
11
|
+
* Converts `string` to camel case: the words of the string, lower-cased, with every word but the first
|
|
12
|
+
* capitalised, joined together.
|
|
13
|
+
*
|
|
14
|
+
* @param string - The string to convert.
|
|
15
|
+
* @returns Returns the camel cased string.
|
|
16
|
+
* @internal
|
|
17
|
+
*/
|
|
18
|
+
export declare const _camelCase: (string?: string) => string;
|
|
19
|
+
|
|
20
|
+
/**
|
|
21
|
+
* Converts the first character of `string` to upper case and the remaining to lower case.
|
|
22
|
+
*
|
|
23
|
+
* @param string - The string to capitalize.
|
|
24
|
+
* @returns Returns the capitalized string.
|
|
25
|
+
* @internal
|
|
26
|
+
*/
|
|
27
|
+
export declare function _capitalize(string?: string): string;
|
|
28
|
+
|
|
10
29
|
/**
|
|
11
30
|
* Recursively clones `value`.
|
|
12
31
|
*
|
|
@@ -39,6 +58,11 @@ export declare function combineGuards<T extends ((x: unknown) => x is unknown)[]
|
|
|
39
58
|
*/
|
|
40
59
|
export declare function _compact<T>(array: _List<T | _Falsey> | null | undefined): T[];
|
|
41
60
|
|
|
61
|
+
/**
|
|
62
|
+
* @internal
|
|
63
|
+
*/
|
|
64
|
+
export declare type _Comparator<T> = (a: T, b: T) => boolean;
|
|
65
|
+
|
|
42
66
|
/**
|
|
43
67
|
* A console function, like log, warn or error
|
|
44
68
|
*
|
|
@@ -156,6 +180,19 @@ export declare type _Dictionary<T> = {
|
|
|
156
180
|
[index: string]: T;
|
|
157
181
|
};
|
|
158
182
|
|
|
183
|
+
/**
|
|
184
|
+
* Creates an array of `array` values not included in the other given arrays using SameValueZero for equality
|
|
185
|
+
* comparisons. The order and references of result values are determined by the first array. Only array-like
|
|
186
|
+
* objects are inspected: any other first argument yields an empty array and any other exclusion argument is
|
|
187
|
+
* skipped.
|
|
188
|
+
*
|
|
189
|
+
* @param array - The array to inspect.
|
|
190
|
+
* @param values - The arrays of values to exclude.
|
|
191
|
+
* @returns Returns the new array of filtered values.
|
|
192
|
+
* @internal
|
|
193
|
+
*/
|
|
194
|
+
export declare function _difference<T>(array: _List<T> | null | undefined, ...values: _List<T>[]): T[];
|
|
195
|
+
|
|
159
196
|
/**
|
|
160
197
|
* @internal
|
|
161
198
|
*/
|
|
@@ -174,6 +211,19 @@ export declare type _EmptyObject<T> = {
|
|
|
174
211
|
*/
|
|
175
212
|
export declare type _EmptyObjectOf<T> = _EmptyObject<T> extends T ? _EmptyObject<T> : never;
|
|
176
213
|
|
|
214
|
+
/**
|
|
215
|
+
* Converts the characters `&`, `<`, `>`, `"` and `'` in `string` to their corresponding HTML entities.
|
|
216
|
+
*
|
|
217
|
+
* **Note:** No other characters are escaped. Though `>` is escaped for symmetry, characters like `>` and `/`
|
|
218
|
+
* don't need escaping in HTML and have no special meaning unless they're part of a tag or unquoted attribute
|
|
219
|
+
* value. When working with HTML you should always quote attribute values to reduce XSS vectors.
|
|
220
|
+
*
|
|
221
|
+
* @param string - The string to escape.
|
|
222
|
+
* @returns Returns the escaped string.
|
|
223
|
+
* @internal
|
|
224
|
+
*/
|
|
225
|
+
export declare function _escape(string?: string): string;
|
|
226
|
+
|
|
177
227
|
/**
|
|
178
228
|
* Escapes special characters used in regular expressions.
|
|
179
229
|
* @param value - string to be escaped
|
|
@@ -189,6 +239,31 @@ export declare function escapeRegExp(value: string): string;
|
|
|
189
239
|
*/
|
|
190
240
|
export declare type _Falsey = null | undefined | false | "" | 0 | 0n;
|
|
191
241
|
|
|
242
|
+
/**
|
|
243
|
+
* @internal
|
|
244
|
+
*/
|
|
245
|
+
export declare type _Function0<R> = () => R;
|
|
246
|
+
|
|
247
|
+
/**
|
|
248
|
+
* @internal
|
|
249
|
+
*/
|
|
250
|
+
export declare type _Function1<T1, R> = (t1: T1) => R;
|
|
251
|
+
|
|
252
|
+
/**
|
|
253
|
+
* @internal
|
|
254
|
+
*/
|
|
255
|
+
export declare type _Function2<T1, T2, R> = (t1: T1, t2: T2) => R;
|
|
256
|
+
|
|
257
|
+
/**
|
|
258
|
+
* @internal
|
|
259
|
+
*/
|
|
260
|
+
export declare type _Function3<T1, T2, T3, R> = (t1: T1, t2: T2, t3: T3) => R;
|
|
261
|
+
|
|
262
|
+
/**
|
|
263
|
+
* @internal
|
|
264
|
+
*/
|
|
265
|
+
export declare type _Function4<T1, T2, T3, T4, R> = (t1: T1, t2: T2, t3: T3, t4: T4) => R;
|
|
266
|
+
|
|
192
267
|
/**
|
|
193
268
|
* Creates an object composed of keys generated from the results of running each element of
|
|
194
269
|
* `collection` thru `iteratee`. The order of grouped values is determined by the order they occur in
|
|
@@ -213,6 +288,26 @@ export declare function _groupBy<T extends object>(collection: T | null | undefi
|
|
|
213
288
|
*/
|
|
214
289
|
export declare type GuardType<T> = T extends ((o: unknown) => o is infer U) ? U : never;
|
|
215
290
|
|
|
291
|
+
/**
|
|
292
|
+
* Checks if `path` is a direct property of `object`: every segment of the path must be an own property of
|
|
293
|
+
* the value before it, or a valid index of an array or arguments object.
|
|
294
|
+
*
|
|
295
|
+
* @param object - The object to query.
|
|
296
|
+
* @param path - The path to check.
|
|
297
|
+
* @returns Returns `true` if `path` exists, else `false`.
|
|
298
|
+
* @internal
|
|
299
|
+
*/
|
|
300
|
+
export declare function _has<T, K extends _PropertyName>(object: T, path: K): object is T & {
|
|
301
|
+
[P in K]: P extends keyof T ? T[P] : Record<string, unknown> extends T ? T[keyof T] : unknown;
|
|
302
|
+
} & {
|
|
303
|
+
[uniqueSymbol]: unknown;
|
|
304
|
+
};
|
|
305
|
+
|
|
306
|
+
/**
|
|
307
|
+
* @internal
|
|
308
|
+
*/
|
|
309
|
+
export declare function _has<T>(object: T, path: _PropertyPath): boolean;
|
|
310
|
+
|
|
216
311
|
/**
|
|
217
312
|
* Returns a hash code for a string.
|
|
218
313
|
*
|
|
@@ -294,21 +389,91 @@ export declare interface IShortenTextOptions {
|
|
|
294
389
|
maxLength?: number;
|
|
295
390
|
}
|
|
296
391
|
|
|
392
|
+
/**
|
|
393
|
+
* Checks if `value` is a plain object, that is, an object created by the `Object` constructor or one
|
|
394
|
+
* with a `[[Prototype]]` of `null`.
|
|
395
|
+
*
|
|
396
|
+
* @param value - The value to check.
|
|
397
|
+
* @returns Returns `true` if `value` is a plain object, else `false`.
|
|
398
|
+
* @internal
|
|
399
|
+
*/
|
|
400
|
+
export declare function _isPlainObject(value?: unknown): boolean;
|
|
401
|
+
|
|
297
402
|
/**
|
|
298
403
|
* @internal
|
|
299
404
|
*/
|
|
300
405
|
export declare type _IterateeShorthand<T> = _PropertyName | [_PropertyName, any] | _PartialShallow<T>;
|
|
301
406
|
|
|
407
|
+
/**
|
|
408
|
+
* Converts `string` to kebab case: the words of the string, lower-cased and joined with hyphens.
|
|
409
|
+
*
|
|
410
|
+
* @param string - The string to convert.
|
|
411
|
+
* @returns Returns the kebab cased string.
|
|
412
|
+
* @internal
|
|
413
|
+
*/
|
|
414
|
+
export declare const _kebabCase: (string?: string) => string;
|
|
415
|
+
|
|
416
|
+
/**
|
|
417
|
+
* Creates an object composed of keys generated from the results of running each element of `collection`
|
|
418
|
+
* thru `iteratee`. The corresponding value of each key is the last element responsible for generating the
|
|
419
|
+
* key. The iteratee is invoked with one argument: (value).
|
|
420
|
+
*
|
|
421
|
+
* @param collection - The collection to iterate over.
|
|
422
|
+
* @param iteratee - The iteratee to transform keys.
|
|
423
|
+
* @returns Returns the composed aggregate object.
|
|
424
|
+
* @internal
|
|
425
|
+
*/
|
|
426
|
+
export declare function _keyBy<T>(collection: _List<T> | null | undefined, iteratee?: _ValueIterateeCustom<T, _PropertyName>): _Dictionary<T>;
|
|
427
|
+
|
|
428
|
+
/**
|
|
429
|
+
* @internal
|
|
430
|
+
*/
|
|
431
|
+
export declare function _keyBy<T extends object>(collection: T | null | undefined, iteratee?: _ValueIterateeCustom<T[keyof T], _PropertyName>): _Dictionary<T[keyof T]>;
|
|
432
|
+
|
|
302
433
|
/**
|
|
303
434
|
* @internal
|
|
304
435
|
*/
|
|
305
436
|
export declare type _List<T> = ArrayLike<T>;
|
|
306
437
|
|
|
438
|
+
/**
|
|
439
|
+
* @internal
|
|
440
|
+
*/
|
|
441
|
+
export declare type _ListIteratee<T> = _ListIterator<T, _NotVoid> | _IterateeShorthand<T>;
|
|
442
|
+
|
|
443
|
+
/**
|
|
444
|
+
* @internal
|
|
445
|
+
*/
|
|
446
|
+
export declare type _ListIterator<T, TResult> = (value: T, index: number, collection: _List<T>) => TResult;
|
|
447
|
+
|
|
307
448
|
/**
|
|
308
449
|
* @internal
|
|
309
450
|
*/
|
|
310
451
|
export declare type _Many<T> = T | readonly T[];
|
|
311
452
|
|
|
453
|
+
/**
|
|
454
|
+
* The cache a memoized function keeps its results in. Keys are compared by SameValueZero, as a `Map`
|
|
455
|
+
* does, so `NaN` equals `NaN` and objects compare by reference.
|
|
456
|
+
*
|
|
457
|
+
* @internal
|
|
458
|
+
*/
|
|
459
|
+
export declare type _MapCache = {
|
|
460
|
+
/** Removes `key` and its value from the cache; returns whether the entry was removed. */
|
|
461
|
+
delete(key: unknown): boolean;
|
|
462
|
+
/** Gets the cached value for `key`. */
|
|
463
|
+
get(key: unknown): unknown;
|
|
464
|
+
/** Checks if a cached value for `key` exists. */
|
|
465
|
+
has(key: unknown): boolean;
|
|
466
|
+
/** Sets `value` to `key` of the cache; a cache that returns itself here lets `set` be chained. */
|
|
467
|
+
set(key: unknown, value: unknown): unknown;
|
|
468
|
+
/** Removes all entries from the cache. */
|
|
469
|
+
clear?: (() => void) | undefined;
|
|
470
|
+
};
|
|
471
|
+
|
|
472
|
+
/**
|
|
473
|
+
* @internal
|
|
474
|
+
*/
|
|
475
|
+
export declare type _MapCacheConstructor = new () => _MapCache;
|
|
476
|
+
|
|
312
477
|
/**
|
|
313
478
|
* A matcher for suppressConsole
|
|
314
479
|
*
|
|
@@ -329,11 +494,103 @@ export declare type Matcher = {
|
|
|
329
494
|
*/
|
|
330
495
|
export declare type MatcherFunction = (console: Record<ConsoleType, ConsoleFunction>, type: ConsoleType, message: string) => boolean;
|
|
331
496
|
|
|
497
|
+
/**
|
|
498
|
+
* The shape of `_memoize`: the memoizing function itself plus the `Cache` constructor every memoized
|
|
499
|
+
* function starts with.
|
|
500
|
+
*
|
|
501
|
+
* @internal
|
|
502
|
+
*/
|
|
503
|
+
export declare type _Memoize = {
|
|
504
|
+
<T extends (...args: any) => any>(func: T, resolver?: (this: ThisParameterType<T>, ...args: Parameters<T>) => unknown): T & _MemoizedFunction;
|
|
505
|
+
/** The constructor of the cache every memoized function starts with; a native `Map` unless replaced. */
|
|
506
|
+
Cache: _MapCacheConstructor;
|
|
507
|
+
};
|
|
508
|
+
|
|
509
|
+
/**
|
|
510
|
+
* Creates a function that memoizes the result of `func`. If `resolver` is provided, it determines the
|
|
511
|
+
* cache key for storing the result based on the arguments provided to the memoized function. By
|
|
512
|
+
* default, the first argument provided to the memoized function is used as the map cache key. The
|
|
513
|
+
* `func` is invoked with the `this` binding of the memoized function.
|
|
514
|
+
*
|
|
515
|
+
* **Note:** The cache is exposed as the `cache` property on the memoized function. Its creation may be
|
|
516
|
+
* customized by replacing the `_memoize.Cache` constructor with one whose instances implement the
|
|
517
|
+
* `Map` method interface of `clear`, `delete`, `get`, `has`, and `set`.
|
|
518
|
+
*
|
|
519
|
+
* @param func - The function to have its output memoized.
|
|
520
|
+
* @param resolver - The function to resolve the cache key.
|
|
521
|
+
* @returns Returns the new memoized function.
|
|
522
|
+
* @internal
|
|
523
|
+
*/
|
|
524
|
+
export declare const _memoize: _Memoize;
|
|
525
|
+
|
|
526
|
+
/**
|
|
527
|
+
* What `_memoize` adds to the function it returns.
|
|
528
|
+
*
|
|
529
|
+
* @internal
|
|
530
|
+
*/
|
|
531
|
+
export declare type _MemoizedFunction = {
|
|
532
|
+
/** The cache of results, exposed so callers can inspect or edit it. */
|
|
533
|
+
cache: _MapCache;
|
|
534
|
+
};
|
|
535
|
+
|
|
536
|
+
/**
|
|
537
|
+
* Recursively merges own and inherited enumerable string keyed properties of source objects into the
|
|
538
|
+
* destination object. Source properties that resolve to `undefined` are skipped if a destination value
|
|
539
|
+
* exists. Array and plain object properties are merged recursively. Other objects and value types are
|
|
540
|
+
* overridden by assignment. Source objects are applied from left to right. Subsequent sources overwrite
|
|
541
|
+
* property assignments of previous sources.
|
|
542
|
+
*
|
|
543
|
+
* **Note:** This method mutates `object`.
|
|
544
|
+
*
|
|
545
|
+
* @param object - The destination object.
|
|
546
|
+
* @param sources - The source objects.
|
|
547
|
+
* @returns Returns `object`.
|
|
548
|
+
* @internal
|
|
549
|
+
*/
|
|
550
|
+
export declare function _merge<TObject, TSource>(object: TObject, source: TSource): TObject & TSource;
|
|
551
|
+
|
|
552
|
+
/**
|
|
553
|
+
* @internal
|
|
554
|
+
*/
|
|
555
|
+
export declare function _merge<TObject, TSource1, TSource2>(object: TObject, source1: TSource1, source2: TSource2): TObject & TSource1 & TSource2;
|
|
556
|
+
|
|
557
|
+
/**
|
|
558
|
+
* @internal
|
|
559
|
+
*/
|
|
560
|
+
export declare function _merge<TObject, TSource1, TSource2, TSource3>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3): TObject & TSource1 & TSource2 & TSource3;
|
|
561
|
+
|
|
562
|
+
/**
|
|
563
|
+
* @internal
|
|
564
|
+
*/
|
|
565
|
+
export declare function _merge<TObject, TSource1, TSource2, TSource3, TSource4>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): TObject & TSource1 & TSource2 & TSource3 & TSource4;
|
|
566
|
+
|
|
567
|
+
/**
|
|
568
|
+
* @internal
|
|
569
|
+
*/
|
|
570
|
+
export declare function _merge(object: any, ...otherArgs: any[]): any;
|
|
571
|
+
|
|
332
572
|
/**
|
|
333
573
|
* @internal
|
|
334
574
|
*/
|
|
335
575
|
export declare type _NotVoid = unknown;
|
|
336
576
|
|
|
577
|
+
/**
|
|
578
|
+
* @internal
|
|
579
|
+
*/
|
|
580
|
+
export declare type _NumericDictionary<T> = {
|
|
581
|
+
[index: number]: T;
|
|
582
|
+
};
|
|
583
|
+
|
|
584
|
+
/**
|
|
585
|
+
* @internal
|
|
586
|
+
*/
|
|
587
|
+
export declare type _ObjectIteratee<TObject> = _ObjectIterator<TObject, _NotVoid> | _IterateeShorthand<TObject[keyof TObject]>;
|
|
588
|
+
|
|
589
|
+
/**
|
|
590
|
+
* @internal
|
|
591
|
+
*/
|
|
592
|
+
export declare type _ObjectIterator<TObject, TResult> = (value: TObject[keyof TObject], key: string, collection: TObject) => TResult;
|
|
593
|
+
|
|
337
594
|
/**
|
|
338
595
|
* The opposite of `pick`; this method creates an object composed of the own and inherited enumerable
|
|
339
596
|
* property paths of `object` that are not omitted.
|
|
@@ -362,6 +619,28 @@ export declare function _omit<T extends object, K extends keyof T>(object: T | n
|
|
|
362
619
|
*/
|
|
363
620
|
export declare function _omit<T extends object>(object: T | null | undefined, ...paths: Array<_Many<_PropertyName>>): _PartialObject<T>;
|
|
364
621
|
|
|
622
|
+
/**
|
|
623
|
+
* The opposite of `pickBy`; this method creates an object composed of the own and inherited enumerable
|
|
624
|
+
* string and symbol keyed properties of `object` that `predicate` doesn't return truthy for. The predicate
|
|
625
|
+
* is invoked with two arguments: (value, key). Picked values are kept by reference.
|
|
626
|
+
*
|
|
627
|
+
* @param object - The source object.
|
|
628
|
+
* @param predicate - The function invoked per property, or an iteratee shorthand. Defaults to identity.
|
|
629
|
+
* @returns Returns the new object.
|
|
630
|
+
* @internal
|
|
631
|
+
*/
|
|
632
|
+
export declare function _omitBy<T>(object: _Dictionary<T> | null | undefined, predicate?: _ValueKeyIteratee<T>): _Dictionary<T>;
|
|
633
|
+
|
|
634
|
+
/**
|
|
635
|
+
* @internal
|
|
636
|
+
*/
|
|
637
|
+
export declare function _omitBy<T>(object: _NumericDictionary<T> | null | undefined, predicate?: _ValueKeyIteratee<T>): _NumericDictionary<T>;
|
|
638
|
+
|
|
639
|
+
/**
|
|
640
|
+
* @internal
|
|
641
|
+
*/
|
|
642
|
+
export declare function _omitBy<T extends object>(object: T | null | undefined, predicate: _ValueKeyIteratee<T[keyof T]>): _PartialObject<T>;
|
|
643
|
+
|
|
365
644
|
/**
|
|
366
645
|
* Parse string in a form of [foo, bar] to an array of objects.
|
|
367
646
|
* Assume alphanumeric strings in the array and spaces; if some is not alphanumeric , return null
|
|
@@ -372,6 +651,53 @@ export declare function _omit<T extends object>(object: T | null | undefined, ..
|
|
|
372
651
|
*/
|
|
373
652
|
export declare function parseStringToArray(str: string): string[] | null;
|
|
374
653
|
|
|
654
|
+
/**
|
|
655
|
+
* The call signatures of `_partial`: each applied parameter is dropped from the resulting function, a
|
|
656
|
+
* placeholder keeps its parameter in place.
|
|
657
|
+
*
|
|
658
|
+
* @internal
|
|
659
|
+
*/
|
|
660
|
+
export declare type _Partial = {
|
|
661
|
+
<T1, T2, R>(func: _Function2<T1, T2, R>, plc1: _Placeholder, arg2: T2): _Function1<T1, R>;
|
|
662
|
+
<T1, T2, T3, R>(func: _Function3<T1, T2, T3, R>, plc1: _Placeholder, arg2: T2): _Function2<T1, T3, R>;
|
|
663
|
+
<T1, T2, T3, R>(func: _Function3<T1, T2, T3, R>, plc1: _Placeholder, plc2: _Placeholder, arg3: T3): _Function2<T1, T2, R>;
|
|
664
|
+
<T1, T2, T3, R>(func: _Function3<T1, T2, T3, R>, arg1: T1, plc2: _Placeholder, arg3: T3): _Function1<T2, R>;
|
|
665
|
+
<T1, T2, T3, R>(func: _Function3<T1, T2, T3, R>, plc1: _Placeholder, arg2: T2, arg3: T3): _Function1<T1, R>;
|
|
666
|
+
<T1, T2, T3, T4, R>(func: _Function4<T1, T2, T3, T4, R>, plc1: _Placeholder, arg2: T2): _Function3<T1, T3, T4, R>;
|
|
667
|
+
<T1, T2, T3, T4, R>(func: _Function4<T1, T2, T3, T4, R>, plc1: _Placeholder, plc2: _Placeholder, arg3: T3): _Function3<T1, T2, T4, R>;
|
|
668
|
+
<T1, T2, T3, T4, R>(func: _Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: _Placeholder, arg3: T3): _Function2<T2, T4, R>;
|
|
669
|
+
<T1, T2, T3, T4, R>(func: _Function4<T1, T2, T3, T4, R>, plc1: _Placeholder, arg2: T2, arg3: T3): _Function2<T1, T4, R>;
|
|
670
|
+
<T1, T2, T3, T4, R>(func: _Function4<T1, T2, T3, T4, R>, plc1: _Placeholder, plc2: _Placeholder, plc3: _Placeholder, arg4: T4): _Function3<T1, T2, T3, R>;
|
|
671
|
+
<T1, T2, T3, T4, R>(func: _Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: _Placeholder, plc3: _Placeholder, arg4: T4): _Function2<T2, T3, R>;
|
|
672
|
+
<T1, T2, T3, T4, R>(func: _Function4<T1, T2, T3, T4, R>, plc1: _Placeholder, arg2: T2, plc3: _Placeholder, arg4: T4): _Function2<T1, T3, R>;
|
|
673
|
+
<T1, T2, T3, T4, R>(func: _Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, plc3: _Placeholder, arg4: T4): _Function1<T3, R>;
|
|
674
|
+
<T1, T2, T3, T4, R>(func: _Function4<T1, T2, T3, T4, R>, plc1: _Placeholder, plc2: _Placeholder, arg3: T3, arg4: T4): _Function2<T1, T2, R>;
|
|
675
|
+
<T1, T2, T3, T4, R>(func: _Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: _Placeholder, arg3: T3, arg4: T4): _Function1<T2, R>;
|
|
676
|
+
<T1, T2, T3, T4, R>(func: _Function4<T1, T2, T3, T4, R>, plc1: _Placeholder, arg2: T2, arg3: T3, arg4: T4): _Function1<T1, R>;
|
|
677
|
+
<TS extends any[], R>(func: (...ts: TS) => R): (...ts: TS) => R;
|
|
678
|
+
<TS extends any[], T1, R>(func: (t1: T1, ...ts: TS) => R, arg1: T1): (...ts: TS) => R;
|
|
679
|
+
<TS extends any[], T1, T2, R>(func: (t1: T1, t2: T2, ...ts: TS) => R, t1: T1, t2: T2): (...ts: TS) => R;
|
|
680
|
+
<TS extends any[], T1, T2, T3, R>(func: (t1: T1, t2: T2, t3: T3, ...ts: TS) => R, t1: T1, t2: T2, t3: T3): (...ts: TS) => R;
|
|
681
|
+
<TS extends any[], T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, ...ts: TS) => R, t1: T1, t2: T2, t3: T3, t4: T4): (...ts: TS) => R;
|
|
682
|
+
/** Marks a parameter of the function that is left open; `_partial.placeholder` is its only value. */
|
|
683
|
+
placeholder: _Placeholder;
|
|
684
|
+
};
|
|
685
|
+
|
|
686
|
+
/**
|
|
687
|
+
* Creates a function that invokes `func` with `partials` prepended to the arguments it receives. This method
|
|
688
|
+
* is like `bind` except it does **not** alter the `this` binding. The `_partial.placeholder` value may be
|
|
689
|
+
* used as a placeholder for partially applied arguments: each placeholder takes the next argument of the
|
|
690
|
+
* call, the remaining call arguments are appended. Calling the result with `new` constructs `func`.
|
|
691
|
+
*
|
|
692
|
+
* **Note:** This method doesn't set the "length" property of partially applied functions.
|
|
693
|
+
*
|
|
694
|
+
* @param func - The function to partially apply arguments to.
|
|
695
|
+
* @param partials - The arguments to be partially applied.
|
|
696
|
+
* @returns Returns the new partially applied function.
|
|
697
|
+
* @internal
|
|
698
|
+
*/
|
|
699
|
+
export declare const _partial: _Partial;
|
|
700
|
+
|
|
375
701
|
/**
|
|
376
702
|
* @internal
|
|
377
703
|
*/
|
|
@@ -384,6 +710,80 @@ export declare type _PartialShallow<T> = {
|
|
|
384
710
|
[P in keyof T]?: T[P] extends object ? object : T[P];
|
|
385
711
|
};
|
|
386
712
|
|
|
713
|
+
/**
|
|
714
|
+
* Creates an array of elements split into two groups, the first of which contains elements `predicate`
|
|
715
|
+
* returns truthy for, the second of which contains elements `predicate` returns falsey for. The
|
|
716
|
+
* predicate is invoked with one argument: (value).
|
|
717
|
+
*
|
|
718
|
+
* @param collection - The collection to iterate over.
|
|
719
|
+
* @param predicate - The function invoked per iteration.
|
|
720
|
+
* @returns Returns the array of grouped elements.
|
|
721
|
+
* @internal
|
|
722
|
+
*/
|
|
723
|
+
export declare function _partition<T, U extends T>(collection: _List<T> | null | undefined, predicate: _ValueIteratorTypeGuard<T, U>): [U[], Array<Exclude<T, U>>];
|
|
724
|
+
|
|
725
|
+
/**
|
|
726
|
+
* @see _partition
|
|
727
|
+
* @internal
|
|
728
|
+
*/
|
|
729
|
+
export declare function _partition<T>(collection: _List<T> | null | undefined, predicate: _ValueIteratee<T>): [T[], T[]];
|
|
730
|
+
|
|
731
|
+
/**
|
|
732
|
+
* @see _partition
|
|
733
|
+
* @internal
|
|
734
|
+
*/
|
|
735
|
+
export declare function _partition<T extends object>(collection: T | null | undefined, predicate: _ValueIteratee<T[keyof T]>): [Array<T[keyof T]>, Array<T[keyof T]>];
|
|
736
|
+
|
|
737
|
+
/**
|
|
738
|
+
* Creates an object composed of the picked `object` properties, own or inherited. Paths may be given
|
|
739
|
+
* individually or in arrays and may be deep; a deep path recreates the containers along it in the result,
|
|
740
|
+
* while the picked value itself is kept by reference.
|
|
741
|
+
*
|
|
742
|
+
* @param object - The source object.
|
|
743
|
+
* @param props - The property paths to pick, given individually or in arrays.
|
|
744
|
+
* @returns Returns the new object.
|
|
745
|
+
* @internal
|
|
746
|
+
*/
|
|
747
|
+
export declare function _pick<T extends object, U extends keyof T>(object: T, ...props: _Many<U>[]): Pick<T, U>;
|
|
748
|
+
|
|
749
|
+
/**
|
|
750
|
+
* @internal
|
|
751
|
+
*/
|
|
752
|
+
export declare function _pick<T>(object: T | null | undefined, ...props: _Many<_PropertyPath>[]): _PartialObject<T>;
|
|
753
|
+
|
|
754
|
+
/**
|
|
755
|
+
* Creates an object composed of the own and inherited enumerable string and symbol keyed properties of
|
|
756
|
+
* `object` that `predicate` returns truthy for. The predicate is invoked with two arguments: (value, key).
|
|
757
|
+
* Picked values are kept by reference.
|
|
758
|
+
*
|
|
759
|
+
* @param object - The source object.
|
|
760
|
+
* @param predicate - The function invoked per property, or an iteratee shorthand. Defaults to identity.
|
|
761
|
+
* @returns Returns the new object.
|
|
762
|
+
* @internal
|
|
763
|
+
*/
|
|
764
|
+
export declare function _pickBy<T>(object: _Dictionary<T> | null | undefined, predicate?: _ValueKeyIteratee<T>): _Dictionary<T>;
|
|
765
|
+
|
|
766
|
+
/**
|
|
767
|
+
* @internal
|
|
768
|
+
*/
|
|
769
|
+
export declare function _pickBy<T>(object: _NumericDictionary<T> | null | undefined, predicate?: _ValueKeyIteratee<T>): _NumericDictionary<T>;
|
|
770
|
+
|
|
771
|
+
/**
|
|
772
|
+
* @internal
|
|
773
|
+
*/
|
|
774
|
+
export declare function _pickBy<T extends object>(object: T | null | undefined, predicate?: _ValueKeyIteratee<T[keyof T]>): _PartialObject<T>;
|
|
775
|
+
|
|
776
|
+
/**
|
|
777
|
+
* The type of `_partial.placeholder`, which stands in for lodash's `_` placeholder.
|
|
778
|
+
*
|
|
779
|
+
* @internal
|
|
780
|
+
*/
|
|
781
|
+
export declare type _Placeholder = {
|
|
782
|
+
readonly [placeholderBrand]: true;
|
|
783
|
+
};
|
|
784
|
+
|
|
785
|
+
declare const placeholderBrand: unique symbol;
|
|
786
|
+
|
|
387
787
|
/**
|
|
388
788
|
* @internal
|
|
389
789
|
*/
|
|
@@ -502,6 +902,23 @@ export declare function shortenText(value: string, options?: IShortenTextOptions
|
|
|
502
902
|
*/
|
|
503
903
|
export declare function simplifyText(value: string | number | null): string;
|
|
504
904
|
|
|
905
|
+
/**
|
|
906
|
+
* Creates an array of elements, sorted in ascending order by the results of running each element in a
|
|
907
|
+
* collection through each iteratee. This method performs a stable sort, that is, it preserves the original
|
|
908
|
+
* sort order of equal elements. The iteratees are invoked with one argument: (value).
|
|
909
|
+
*
|
|
910
|
+
* @param collection - The collection to iterate over.
|
|
911
|
+
* @param iteratees - The iteratees to sort by, specified individually or in arrays.
|
|
912
|
+
* @returns Returns the new sorted array.
|
|
913
|
+
* @internal
|
|
914
|
+
*/
|
|
915
|
+
export declare function _sortBy<T>(collection: _List<T> | null | undefined, ...iteratees: _Many<_ListIteratee<T>>[]): T[];
|
|
916
|
+
|
|
917
|
+
/**
|
|
918
|
+
* @internal
|
|
919
|
+
*/
|
|
920
|
+
export declare function _sortBy<T extends object>(collection: T | null | undefined, ...iteratees: _Many<_ObjectIteratee<T>>[]): T[keyof T][];
|
|
921
|
+
|
|
505
922
|
/**
|
|
506
923
|
* A specific matcher function
|
|
507
924
|
*
|
|
@@ -547,6 +964,75 @@ export declare function suppressConsole<T>(fn: () => T | Promise<T>, type?: Cons
|
|
|
547
964
|
*/
|
|
548
965
|
export declare function suppressConsole<T>(fn: () => T | Promise<T>, matcherFn: MatcherFunction): T | Promise<T>;
|
|
549
966
|
|
|
967
|
+
/**
|
|
968
|
+
* Creates a throttled function that only invokes `func` at most once per every `wait` milliseconds. The
|
|
969
|
+
* throttled function comes with a `cancel` method to cancel delayed `func` invocations and a `flush` method
|
|
970
|
+
* to immediately invoke them. Provide `options` to indicate whether `func` should be invoked on the leading
|
|
971
|
+
* and/or trailing edge of the `wait` timeout. The `func` is invoked with the last arguments provided to the
|
|
972
|
+
* throttled function. Subsequent calls to the throttled function return the result of the last `func`
|
|
973
|
+
* invocation.
|
|
974
|
+
*
|
|
975
|
+
* **Note:** If `leading` and `trailing` options are `true`, `func` is invoked on the trailing edge of the
|
|
976
|
+
* timeout only if the throttled function is invoked more than once during the `wait` timeout.
|
|
977
|
+
*
|
|
978
|
+
* If `wait` is `0` and `leading` is `false`, `func` invocation is deferred until the next tick, similar to
|
|
979
|
+
* `setTimeout` with a timeout of `0`.
|
|
980
|
+
*
|
|
981
|
+
* @param func - The function to throttle.
|
|
982
|
+
* @param wait - The number of milliseconds to throttle invocations to. Defaults to `0`.
|
|
983
|
+
* @param options - The options object.
|
|
984
|
+
* @returns Returns the new throttled function.
|
|
985
|
+
* @internal
|
|
986
|
+
*/
|
|
987
|
+
export declare function _throttle<T extends (...args: any) => any>(func: T, wait?: number, options?: _ThrottleSettingsLeading): _DebouncedFuncLeading<T>;
|
|
988
|
+
|
|
989
|
+
/**
|
|
990
|
+
* @internal
|
|
991
|
+
*/
|
|
992
|
+
export declare function _throttle<T extends (...args: any) => any>(func: T, wait?: number, options?: _ThrottleSettings): _DebouncedFunc<T>;
|
|
993
|
+
|
|
994
|
+
/**
|
|
995
|
+
* Options of `_throttle`.
|
|
996
|
+
*
|
|
997
|
+
* @internal
|
|
998
|
+
*/
|
|
999
|
+
export declare type _ThrottleSettings = {
|
|
1000
|
+
/** Invoke on the leading edge of the timeout. Defaults to `true`. */
|
|
1001
|
+
leading?: boolean | undefined;
|
|
1002
|
+
/** Invoke on the trailing edge of the timeout. Defaults to `true`. */
|
|
1003
|
+
trailing?: boolean | undefined;
|
|
1004
|
+
};
|
|
1005
|
+
|
|
1006
|
+
/**
|
|
1007
|
+
* {@link _ThrottleSettings} that keep `leading` switched on, which guarantees a result on every call.
|
|
1008
|
+
*
|
|
1009
|
+
* @internal
|
|
1010
|
+
*/
|
|
1011
|
+
export declare type _ThrottleSettingsLeading = (_ThrottleSettings & {
|
|
1012
|
+
leading: true;
|
|
1013
|
+
}) | Omit<_ThrottleSettings, "leading">;
|
|
1014
|
+
|
|
1015
|
+
/**
|
|
1016
|
+
* Creates an array of unique values, in order, from all given arrays using SameValueZero for equality
|
|
1017
|
+
* comparisons. Only array-like objects are inspected; other arguments, strings included, are skipped.
|
|
1018
|
+
*
|
|
1019
|
+
* @param arrays - The arrays to inspect.
|
|
1020
|
+
* @returns Returns the new array of combined values.
|
|
1021
|
+
* @internal
|
|
1022
|
+
*/
|
|
1023
|
+
export declare function _union<T>(...arrays: (_List<T> | null | undefined)[]): T[];
|
|
1024
|
+
|
|
1025
|
+
/**
|
|
1026
|
+
* Creates a duplicate-free version of an array, using SameValueZero for equality comparisons, in which
|
|
1027
|
+
* only the first occurrence of each element is kept. The order of result values is determined by the
|
|
1028
|
+
* order they occur in the array.
|
|
1029
|
+
*
|
|
1030
|
+
* @param array - The array to inspect.
|
|
1031
|
+
* @returns Returns the new duplicate free array.
|
|
1032
|
+
* @internal
|
|
1033
|
+
*/
|
|
1034
|
+
export declare function _uniq<T>(array: _List<T> | null | undefined): T[];
|
|
1035
|
+
|
|
550
1036
|
/**
|
|
551
1037
|
* This method is like `uniq` except that it accepts `iteratee` which is invoked for each element in
|
|
552
1038
|
* `array` to generate the criterion by which uniqueness is computed. The order of result values is
|
|
@@ -559,6 +1045,21 @@ export declare function suppressConsole<T>(fn: () => T | Promise<T>, matcherFn:
|
|
|
559
1045
|
*/
|
|
560
1046
|
export declare function _uniqBy<T>(array: _List<T> | null | undefined, iteratee: _ValueIteratee<T>): T[];
|
|
561
1047
|
|
|
1048
|
+
declare const uniqueSymbol: unique symbol;
|
|
1049
|
+
|
|
1050
|
+
/**
|
|
1051
|
+
* This method is like `_uniq` except that it accepts `comparator` which is invoked to compare elements of
|
|
1052
|
+
* `array`. The order of result values is determined by the order they occur in the array. The comparator
|
|
1053
|
+
* is invoked with two arguments: (arrVal, othVal), the candidate first and then each kept element in order.
|
|
1054
|
+
* Without a function comparator, elements are compared with SameValueZero.
|
|
1055
|
+
*
|
|
1056
|
+
* @param array - The array to inspect.
|
|
1057
|
+
* @param comparator - The comparator invoked per element.
|
|
1058
|
+
* @returns Returns the new duplicate free array.
|
|
1059
|
+
* @internal
|
|
1060
|
+
*/
|
|
1061
|
+
export declare function _uniqWith<T>(array: _List<T> | null | undefined, comparator?: _Comparator<T>): T[];
|
|
1062
|
+
|
|
562
1063
|
/**
|
|
563
1064
|
* An iteratee as lodash accepts it: a function, a property name or path, a `[path, value]` pair, or a
|
|
564
1065
|
* partial object to match.
|
|
@@ -567,6 +1068,23 @@ export declare function _uniqBy<T>(array: _List<T> | null | undefined, iteratee:
|
|
|
567
1068
|
*/
|
|
568
1069
|
export declare type _ValueIteratee<T> = ((value: T) => _NotVoid) | _IterateeShorthand<T>;
|
|
569
1070
|
|
|
1071
|
+
/**
|
|
1072
|
+
* @internal
|
|
1073
|
+
*/
|
|
1074
|
+
export declare type _ValueIterateeCustom<T, TResult> = ((value: T) => TResult) | _IterateeShorthand<T>;
|
|
1075
|
+
|
|
1076
|
+
/**
|
|
1077
|
+
* A predicate that narrows the element type, so functions like `_partition` can type their result.
|
|
1078
|
+
*
|
|
1079
|
+
* @internal
|
|
1080
|
+
*/
|
|
1081
|
+
export declare type _ValueIteratorTypeGuard<T, S extends T> = (value: T) => value is S;
|
|
1082
|
+
|
|
1083
|
+
/**
|
|
1084
|
+
* @internal
|
|
1085
|
+
*/
|
|
1086
|
+
export declare type _ValueKeyIteratee<T> = ((value: T, key: string) => _NotVoid) | _IterateeShorthand<T>;
|
|
1087
|
+
|
|
570
1088
|
/**
|
|
571
1089
|
* A waitFor-compatible polling function, structurally matching testing-library's waitFor.
|
|
572
1090
|
*
|
|
@@ -577,4 +1095,35 @@ export declare type WaitForFn = <T>(callback: () => T | Promise<T>, options?: {
|
|
|
577
1095
|
timeout?: number;
|
|
578
1096
|
}) => Promise<T>;
|
|
579
1097
|
|
|
1098
|
+
/**
|
|
1099
|
+
* Creates an array of grouped elements, the first of which contains the first elements of the given arrays,
|
|
1100
|
+
* the second of which contains the second elements of the given arrays, and so on. Shorter arrays are padded
|
|
1101
|
+
* with `undefined` up to the longest one. Only array-like objects take part; other arguments are skipped.
|
|
1102
|
+
*
|
|
1103
|
+
* @param arrays - The arrays to process.
|
|
1104
|
+
* @returns Returns the new array of grouped elements.
|
|
1105
|
+
* @internal
|
|
1106
|
+
*/
|
|
1107
|
+
export declare function _zip<T1, T2>(arrays1: _List<T1>, arrays2: _List<T2>): [T1 | undefined, T2 | undefined][];
|
|
1108
|
+
|
|
1109
|
+
/**
|
|
1110
|
+
* @internal
|
|
1111
|
+
*/
|
|
1112
|
+
export declare function _zip<T1, T2, T3>(arrays1: _List<T1>, arrays2: _List<T2>, arrays3: _List<T3>): [T1 | undefined, T2 | undefined, T3 | undefined][];
|
|
1113
|
+
|
|
1114
|
+
/**
|
|
1115
|
+
* @internal
|
|
1116
|
+
*/
|
|
1117
|
+
export declare function _zip<T1, T2, T3, T4>(arrays1: _List<T1>, arrays2: _List<T2>, arrays3: _List<T3>, arrays4: _List<T4>): [T1 | undefined, T2 | undefined, T3 | undefined, T4 | undefined][];
|
|
1118
|
+
|
|
1119
|
+
/**
|
|
1120
|
+
* @internal
|
|
1121
|
+
*/
|
|
1122
|
+
export declare function _zip<T1, T2, T3, T4, T5>(arrays1: _List<T1>, arrays2: _List<T2>, arrays3: _List<T3>, arrays4: _List<T4>, arrays5: _List<T5>): [T1 | undefined, T2 | undefined, T3 | undefined, T4 | undefined, T5 | undefined][];
|
|
1123
|
+
|
|
1124
|
+
/**
|
|
1125
|
+
* @internal
|
|
1126
|
+
*/
|
|
1127
|
+
export declare function _zip<T>(...arrays: (_List<T> | null | undefined)[]): (T | undefined)[][];
|
|
1128
|
+
|
|
580
1129
|
export { }
|