@unicom-cloud/utils 0.1.23 → 0.1.25

package/types/lodash/maxBy.d.ts

@@ -0,0 +1,25 @@
+export default maxBy;
+/**
+ * This method is like `_.max` except that it accepts `iteratee` which is
+ * invoked for each element in `array` to generate the criterion by which
+ * the value is ranked. The iteratee is invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Math
+ * @param {Array} array The array to iterate over.
+ * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
+ * @returns {*} Returns the maximum value.
+ * @example
+ *
+ * var objects = [{ 'n': 1 }, { 'n': 2 }];
+ *
+ * _.maxBy(objects, function(o) { return o.n; });
+ * // => { 'n': 2 }
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.maxBy(objects, 'n');
+ * // => { 'n': 2 }
+ */
+declare function maxBy(array: any[], iteratee?: Function): any;

package/types/lodash/mean.d.ts

@@ -0,0 +1,16 @@
+export default mean;
+/**
+ * Computes the mean of the values in `array`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Math
+ * @param {Array} array The array to iterate over.
+ * @returns {number} Returns the mean.
+ * @example
+ *
+ * _.mean([4, 2, 8, 6]);
+ * // => 5
+ */
+declare function mean(array: any[]): number;

package/types/lodash/meanBy.d.ts

@@ -0,0 +1,25 @@
+export default meanBy;
+/**
+ * This method is like `_.mean` except that it accepts `iteratee` which is
+ * invoked for each element in `array` to generate the value to be averaged.
+ * The iteratee is invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.7.0
+ * @category Math
+ * @param {Array} array The array to iterate over.
+ * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
+ * @returns {number} Returns the mean.
+ * @example
+ *
+ * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
+ *
+ * _.meanBy(objects, function(o) { return o.n; });
+ * // => 5
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.meanBy(objects, 'n');
+ * // => 5
+ */
+declare function meanBy(array: any[], iteratee?: Function): number;

package/types/lodash/memoize.d.ts

@@ -0,0 +1,50 @@
+export default memoize;
+/**
+ * Creates a function that memoizes the result of `func`. If `resolver` is
+ * provided, it determines the cache key for storing the result based on the
+ * arguments provided to the memoized function. By default, the first argument
+ * provided to the memoized function is used as the map cache key. The `func`
+ * is invoked with the `this` binding of the memoized function.
+ *
+ * **Note:** The cache is exposed as the `cache` property on the memoized
+ * function. Its creation may be customized by replacing the `_.memoize.Cache`
+ * constructor with one whose instances implement the
+ * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
+ * method interface of `clear`, `delete`, `get`, `has`, and `set`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to have its output memoized.
+ * @param {Function} [resolver] The function to resolve the cache key.
+ * @returns {Function} Returns the new memoized function.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': 2 };
+ * var other = { 'c': 3, 'd': 4 };
+ *
+ * var values = _.memoize(_.values);
+ * values(object);
+ * // => [1, 2]
+ *
+ * values(other);
+ * // => [3, 4]
+ *
+ * object.a = 2;
+ * values(object);
+ * // => [1, 2]
+ *
+ * // Modify the result cache.
+ * values.cache.set(object, ['a', 'b']);
+ * values(object);
+ * // => ['a', 'b']
+ *
+ * // Replace `_.memoize.Cache`.
+ * _.memoize.Cache = WeakMap;
+ */
+declare function memoize(func: Function, resolver?: Function): Function;
+declare namespace memoize {
+    export { MapCache as Cache };
+}
+import MapCache from './_MapCache.js';

package/types/lodash/merge.d.ts

@@ -0,0 +1,33 @@
+export default merge;
+/**
+ * This method is like `_.assign` except that it recursively merges own and
+ * inherited enumerable string keyed properties of source objects into the
+ * destination object. Source properties that resolve to `undefined` are
+ * skipped if a destination value exists. Array and plain object properties
+ * are merged recursively. Other objects and value types are overridden by
+ * assignment. Source objects are applied from left to right. Subsequent
+ * sources overwrite property assignments of previous sources.
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.5.0
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} [sources] The source objects.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * var object = {
+ *   'a': [{ 'b': 2 }, { 'd': 4 }]
+ * };
+ *
+ * var other = {
+ *   'a': [{ 'c': 3 }, { 'e': 5 }]
+ * };
+ *
+ * _.merge(object, other);
+ * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }
+ */
+declare var merge: Function;

package/types/lodash/mergeWith.d.ts

@@ -0,0 +1,33 @@
+export default mergeWith;
+/**
+ * This method is like `_.merge` except that it accepts `customizer` which
+ * is invoked to produce the merged values of the destination and source
+ * properties. If `customizer` returns `undefined`, merging is handled by the
+ * method instead. The `customizer` is invoked with six arguments:
+ * (objValue, srcValue, key, object, source, stack).
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} sources The source objects.
+ * @param {Function} customizer The function to customize assigned values.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * function customizer(objValue, srcValue) {
+ *   if (_.isArray(objValue)) {
+ *     return objValue.concat(srcValue);
+ *   }
+ * }
+ *
+ * var object = { 'a': [1], 'b': [2] };
+ * var other = { 'a': [3], 'b': [4] };
+ *
+ * _.mergeWith(object, other, customizer);
+ * // => { 'a': [1, 3], 'b': [2, 4] }
+ */
+declare var mergeWith: Function;

package/types/lodash/method.d.ts

@@ -0,0 +1,26 @@
+export default method;
+/**
+ * Creates a function that invokes the method at `path` of a given object.
+ * Any additional arguments are provided to the invoked method.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.7.0
+ * @category Util
+ * @param {Array|string} path The path of the method to invoke.
+ * @param {...*} [args] The arguments to invoke the method with.
+ * @returns {Function} Returns the new invoker function.
+ * @example
+ *
+ * var objects = [
+ *   { 'a': { 'b': _.constant(2) } },
+ *   { 'a': { 'b': _.constant(1) } }
+ * ];
+ *
+ * _.map(objects, _.method('a.b'));
+ * // => [2, 1]
+ *
+ * _.map(objects, _.method(['a', 'b']));
+ * // => [2, 1]
+ */
+declare var method: Function;

package/types/lodash/methodOf.d.ts

@@ -0,0 +1,25 @@
+export default methodOf;
+/**
+ * The opposite of `_.method`; this method creates a function that invokes
+ * the method at a given path of `object`. Any additional arguments are
+ * provided to the invoked method.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.7.0
+ * @category Util
+ * @param {Object} object The object to query.
+ * @param {...*} [args] The arguments to invoke the method with.
+ * @returns {Function} Returns the new invoker function.
+ * @example
+ *
+ * var array = _.times(3, _.constant),
+ *     object = { 'a': array, 'b': array, 'c': array };
+ *
+ * _.map(['a[2]', 'c[0]'], _.methodOf(object));
+ * // => [2, 0]
+ *
+ * _.map([['a', '2'], ['c', '0']], _.methodOf(object));
+ * // => [2, 0]
+ */
+declare var methodOf: Function;

package/types/lodash/min.d.ts

@@ -0,0 +1,20 @@
+export default min;
+/**
+ * Computes the minimum value of `array`. If `array` is empty or falsey,
+ * `undefined` is returned.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Math
+ * @param {Array} array The array to iterate over.
+ * @returns {*} Returns the minimum value.
+ * @example
+ *
+ * _.min([4, 2, 8, 6]);
+ * // => 2
+ *
+ * _.min([]);
+ * // => undefined
+ */
+declare function min(array: any[]): any;

package/types/lodash/minBy.d.ts

@@ -0,0 +1,25 @@
+export default minBy;
+/**
+ * This method is like `_.min` except that it accepts `iteratee` which is
+ * invoked for each element in `array` to generate the criterion by which
+ * the value is ranked. The iteratee is invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Math
+ * @param {Array} array The array to iterate over.
+ * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
+ * @returns {*} Returns the minimum value.
+ * @example
+ *
+ * var objects = [{ 'n': 1 }, { 'n': 2 }];
+ *
+ * _.minBy(objects, function(o) { return o.n; });
+ * // => { 'n': 1 }
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.minBy(objects, 'n');
+ * // => { 'n': 1 }
+ */
+declare function minBy(array: any[], iteratee?: Function): any;

package/types/lodash/mixin.d.ts

@@ -0,0 +1,40 @@
+export default mixin;
+/**
+ * Adds all own enumerable string keyed function properties of a source
+ * object to the destination object. If `object` is a function, then methods
+ * are added to its prototype as well.
+ *
+ * **Note:** Use `_.runInContext` to create a pristine `lodash` function to
+ * avoid conflicts caused by modifying the original.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Util
+ * @param {Function|Object} [object=lodash] The destination object.
+ * @param {Object} source The object of functions to add.
+ * @param {Object} [options={}] The options object.
+ * @param {boolean} [options.chain=true] Specify whether mixins are chainable.
+ * @returns {Function|Object} Returns `object`.
+ * @example
+ *
+ * function vowels(string) {
+ *   return _.filter(string, function(v) {
+ *     return /[aeiou]/i.test(v);
+ *   });
+ * }
+ *
+ * _.mixin({ 'vowels': vowels });
+ * _.vowels('fred');
+ * // => ['e']
+ *
+ * _('fred').vowels().value();
+ * // => ['e']
+ *
+ * _.mixin({ 'vowels': vowels }, { 'chain': false });
+ * _('fred').vowels();
+ * // => ['e']
+ */
+declare function mixin(object?: Function | Object, source: Object, options?: {
+    chain?: boolean | undefined;
+}): Function | Object;

package/types/lodash/multiply.d.ts

@@ -0,0 +1,17 @@
+export default multiply;
+/**
+ * Multiply two numbers.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.7.0
+ * @category Math
+ * @param {number} multiplier The first number in a multiplication.
+ * @param {number} multiplicand The second number in a multiplication.
+ * @returns {number} Returns the product.
+ * @example
+ *
+ * _.multiply(6, 4);
+ * // => 24
+ */
+declare var multiply: Function;

package/types/lodash/negate.d.ts

@@ -0,0 +1,22 @@
+export default negate;
+/**
+ * Creates a function that negates the result of the predicate `func`. The
+ * `func` predicate is invoked with the `this` binding and arguments of the
+ * created function.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Function
+ * @param {Function} predicate The predicate to negate.
+ * @returns {Function} Returns the new negated function.
+ * @example
+ *
+ * function isEven(n) {
+ *   return n % 2 == 0;
+ * }
+ *
+ * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));
+ * // => [1, 3, 5]
+ */
+declare function negate(predicate: Function): Function;

package/types/lodash/next.d.ts

@@ -0,0 +1,27 @@
+export default wrapperNext;
+/**
+ * Gets the next value on a wrapped object following the
+ * [iterator protocol](https://mdn.io/iteration_protocols#iterator).
+ *
+ * @name next
+ * @memberOf _
+ * @since 4.0.0
+ * @category Seq
+ * @returns {Object} Returns the next iterator value.
+ * @example
+ *
+ * var wrapped = _([1, 2]);
+ *
+ * wrapped.next();
+ * // => { 'done': false, 'value': 1 }
+ *
+ * wrapped.next();
+ * // => { 'done': false, 'value': 2 }
+ *
+ * wrapped.next();
+ * // => { 'done': true, 'value': undefined }
+ */
+declare function wrapperNext(): Object;
+declare class wrapperNext {
+    __values__: any[];
+}

package/types/lodash/noop.d.ts

@@ -0,0 +1,14 @@
+export default noop;
+/**
+ * This method returns `undefined`.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.3.0
+ * @category Util
+ * @example
+ *
+ * _.times(2, _.noop);
+ * // => [undefined, undefined]
+ */
+declare function noop(): void;

package/types/lodash/now.d.ts

@@ -0,0 +1,18 @@
+export default now;
+/**
+ * Gets the timestamp of the number of milliseconds that have elapsed since
+ * the Unix epoch (1 January 1970 00:00:00 UTC).
+ *
+ * @static
+ * @memberOf _
+ * @since 2.4.0
+ * @category Date
+ * @returns {number} Returns the timestamp.
+ * @example
+ *
+ * _.defer(function(stamp) {
+ *   console.log(_.now() - stamp);
+ * }, _.now());
+ * // => Logs the number of milliseconds it took for the deferred invocation.
+ */
+declare function now(): number;

package/types/lodash/nth.d.ts

@@ -0,0 +1,23 @@
+export default nth;
+/**
+ * Gets the element at index `n` of `array`. If `n` is negative, the nth
+ * element from the end is returned.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.11.0
+ * @category Array
+ * @param {Array} array The array to query.
+ * @param {number} [n=0] The index of the element to return.
+ * @returns {*} Returns the nth element of `array`.
+ * @example
+ *
+ * var array = ['a', 'b', 'c', 'd'];
+ *
+ * _.nth(array, 1);
+ * // => 'b'
+ *
+ * _.nth(array, -2);
+ * // => 'c';
+ */
+declare function nth(array: any[], n?: number): any;

package/types/lodash/nthArg.d.ts

@@ -0,0 +1,22 @@
+export default nthArg;
+/**
+ * Creates a function that gets the argument at index `n`. If `n` is negative,
+ * the nth argument from the end is returned.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Util
+ * @param {number} [n=0] The index of the argument to return.
+ * @returns {Function} Returns the new pass-thru function.
+ * @example
+ *
+ * var func = _.nthArg(1);
+ * func('a', 'b', 'c', 'd');
+ * // => 'b'
+ *
+ * var func = _.nthArg(-2);
+ * func('a', 'b', 'c', 'd');
+ * // => 'c'
+ */
+declare function nthArg(n?: number): Function;

package/types/lodash/number.d.ts

@@ -0,0 +1,4 @@
+export { default as clamp } from "./clamp.js";
+export { default as inRange } from "./inRange.js";
+export { default as random } from "./random.js";
+export { default } from "./number.default.js";

package/types/lodash/number.default.d.ts

@@ -0,0 +1,9 @@
+declare namespace _default {
+    export { clamp };
+    export { inRange };
+    export { random };
+}
+export default _default;
+import clamp from './clamp.js';
+import inRange from './inRange.js';
+import random from './random.js';

package/types/lodash/object.d.ts

@@ -0,0 +1,48 @@
+export { default as assign } from "./assign.js";
+export { default as assignIn } from "./assignIn.js";
+export { default as assignInWith } from "./assignInWith.js";
+export { default as assignWith } from "./assignWith.js";
+export { default as at } from "./at.js";
+export { default as create } from "./create.js";
+export { default as defaults } from "./defaults.js";
+export { default as defaultsDeep } from "./defaultsDeep.js";
+export { default as entries } from "./entries.js";
+export { default as entriesIn } from "./entriesIn.js";
+export { default as extend } from "./extend.js";
+export { default as extendWith } from "./extendWith.js";
+export { default as findKey } from "./findKey.js";
+export { default as findLastKey } from "./findLastKey.js";
+export { default as forIn } from "./forIn.js";
+export { default as forInRight } from "./forInRight.js";
+export { default as forOwn } from "./forOwn.js";
+export { default as forOwnRight } from "./forOwnRight.js";
+export { default as functions } from "./functions.js";
+export { default as functionsIn } from "./functionsIn.js";
+export { default as get } from "./get.js";
+export { default as has } from "./has.js";
+export { default as hasIn } from "./hasIn.js";
+export { default as invert } from "./invert.js";
+export { default as invertBy } from "./invertBy.js";
+export { default as invoke } from "./invoke.js";
+export { default as keys } from "./keys.js";
+export { default as keysIn } from "./keysIn.js";
+export { default as mapKeys } from "./mapKeys.js";
+export { default as mapValues } from "./mapValues.js";
+export { default as merge } from "./merge.js";
+export { default as mergeWith } from "./mergeWith.js";
+export { default as omit } from "./omit.js";
+export { default as omitBy } from "./omitBy.js";
+export { default as pick } from "./pick.js";
+export { default as pickBy } from "./pickBy.js";
+export { default as result } from "./result.js";
+export { default as set } from "./set.js";
+export { default as setWith } from "./setWith.js";
+export { default as toPairs } from "./toPairs.js";
+export { default as toPairsIn } from "./toPairsIn.js";
+export { default as transform } from "./transform.js";
+export { default as unset } from "./unset.js";
+export { default as update } from "./update.js";
+export { default as updateWith } from "./updateWith.js";
+export { default as values } from "./values.js";
+export { default as valuesIn } from "./valuesIn.js";
+export { default } from "./object.default.js";

package/types/lodash/object.default.d.ts

@@ -0,0 +1,97 @@
+declare namespace _default {
+    export { assign };
+    export { assignIn };
+    export { assignInWith };
+    export { assignWith };
+    export { at };
+    export { create };
+    export { defaults };
+    export { defaultsDeep };
+    export { entries };
+    export { entriesIn };
+    export { extend };
+    export { extendWith };
+    export { findKey };
+    export { findLastKey };
+    export { forIn };
+    export { forInRight };
+    export { forOwn };
+    export { forOwnRight };
+    export { functions };
+    export { functionsIn };
+    export { get };
+    export { has };
+    export { hasIn };
+    export { invert };
+    export { invertBy };
+    export { invoke };
+    export { keys };
+    export { keysIn };
+    export { mapKeys };
+    export { mapValues };
+    export { merge };
+    export { mergeWith };
+    export { omit };
+    export { omitBy };
+    export { pick };
+    export { pickBy };
+    export { result };
+    export { set };
+    export { setWith };
+    export { toPairs };
+    export { toPairsIn };
+    export { transform };
+    export { unset };
+    export { update };
+    export { updateWith };
+    export { values };
+    export { valuesIn };
+}
+export default _default;
+import assign from './assign.js';
+import assignIn from './assignIn.js';
+import assignInWith from './assignInWith.js';
+import assignWith from './assignWith.js';
+import at from './at.js';
+import create from './create.js';
+import defaults from './defaults.js';
+import defaultsDeep from './defaultsDeep.js';
+import entries from './entries.js';
+import entriesIn from './entriesIn.js';
+import extend from './extend.js';
+import extendWith from './extendWith.js';
+import findKey from './findKey.js';
+import findLastKey from './findLastKey.js';
+import forIn from './forIn.js';
+import forInRight from './forInRight.js';
+import forOwn from './forOwn.js';
+import forOwnRight from './forOwnRight.js';
+import functions from './functions.js';
+import functionsIn from './functionsIn.js';
+import get from './get.js';
+import has from './has.js';
+import hasIn from './hasIn.js';
+import invert from './invert.js';
+import invertBy from './invertBy.js';
+import invoke from './invoke.js';
+import keys from './keys.js';
+import keysIn from './keysIn.js';
+import mapKeys from './mapKeys.js';
+import mapValues from './mapValues.js';
+import merge from './merge.js';
+import mergeWith from './mergeWith.js';
+import omit from './omit.js';
+import omitBy from './omitBy.js';
+import pick from './pick.js';
+import pickBy from './pickBy.js';
+import result from './result.js';
+import set from './set.js';
+import setWith from './setWith.js';
+import toPairs from './toPairs.js';
+import toPairsIn from './toPairsIn.js';
+import transform from './transform.js';
+import unset from './unset.js';
+import update from './update.js';
+import updateWith from './updateWith.js';
+import values from './values.js';
+import valuesIn from './valuesIn.js';

package/types/lodash/omit.d.ts

@@ -0,0 +1,22 @@
+export default omit;
+/**
+ * The opposite of `_.pick`; this method creates an object composed of the
+ * own and inherited enumerable property paths of `object` that are not omitted.
+ *
+ * **Note:** This method is considerably slower than `_.pick`.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The source object.
+ * @param {...(string|string[])} [paths] The property paths to omit.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': '2', 'c': 3 };
+ *
+ * _.omit(object, ['a', 'c']);
+ * // => { 'b': '2' }
+ */
+declare var omit: Function;