@unicom-cloud/utils 0.1.23 → 0.1.24

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;

package/types/lodash/omitBy.d.ts

@@ -0,0 +1,22 @@
+export default omitBy;
+/**
+ * The opposite of `_.pickBy`; this method creates an object composed of
+ * the own and inherited enumerable string keyed properties of `object` that
+ * `predicate` doesn't return truthy for. The predicate is invoked with two
+ * arguments: (value, key).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Object
+ * @param {Object} object The source object.
+ * @param {Function} [predicate=_.identity] The function invoked per property.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': '2', 'c': 3 };
+ *
+ * _.omitBy(object, _.isNumber);
+ * // => { 'b': '2' }
+ */
+declare function omitBy(object: Object, predicate?: Function): Object;

package/types/lodash/once.d.ts

@@ -0,0 +1,20 @@
+export default once;
+/**
+ * Creates a function that is restricted to invoking `func` once. Repeat calls
+ * to the function return the value of the first invocation. The `func` is
+ * invoked with the `this` binding and arguments of the created function.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to restrict.
+ * @returns {Function} Returns the new restricted function.
+ * @example
+ *
+ * var initialize = _.once(createApplication);
+ * initialize();
+ * initialize();
+ * // => `createApplication` is invoked once
+ */
+declare function once(func: Function): Function;

package/types/lodash/orderBy.d.ts

@@ -0,0 +1,31 @@
+export default orderBy;
+/**
+ * This method is like `_.sortBy` except that it allows specifying the sort
+ * orders of the iteratees to sort by. If `orders` is unspecified, all values
+ * are sorted in ascending order. Otherwise, specify an order of "desc" for
+ * descending or "asc" for ascending sort order of corresponding values.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]]
+ *  The iteratees to sort by.
+ * @param {string[]} [orders] The sort orders of `iteratees`.
+ * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.
+ * @returns {Array} Returns the new sorted array.
+ * @example
+ *
+ * var users = [
+ *   { 'user': 'fred',   'age': 48 },
+ *   { 'user': 'barney', 'age': 34 },
+ *   { 'user': 'fred',   'age': 40 },
+ *   { 'user': 'barney', 'age': 36 }
+ * ];
+ *
+ * // Sort by `user` in ascending order and by `age` in descending order.
+ * _.orderBy(users, ['user', 'age'], ['asc', 'desc']);
+ * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]
+ */
+declare function orderBy(collection: any[] | Object, iteratees?: any[][] | Function[] | Object[] | string[], orders?: string[], guard: any): any[];

package/types/lodash/over.d.ts

@@ -0,0 +1,20 @@
+export default over;
+/**
+ * Creates a function that invokes `iteratees` with the arguments it receives
+ * and returns their results.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Util
+ * @param {...(Function|Function[])} [iteratees=[_.identity]]
+ *  The iteratees to invoke.
+ * @returns {Function} Returns the new function.
+ * @example
+ *
+ * var func = _.over([Math.max, Math.min]);
+ *
+ * func(1, 2, 3, 4);
+ * // => [4, 1]
+ */
+declare var over: Function;

package/types/lodash/overArgs.d.ts

@@ -0,0 +1,33 @@
+export default overArgs;
+/**
+ * Creates a function that invokes `func` with its arguments transformed.
+ *
+ * @static
+ * @since 4.0.0
+ * @memberOf _
+ * @category Function
+ * @param {Function} func The function to wrap.
+ * @param {...(Function|Function[])} [transforms=[_.identity]]
+ *  The argument transforms.
+ * @returns {Function} Returns the new function.
+ * @example
+ *
+ * function doubled(n) {
+ *   return n * 2;
+ * }
+ *
+ * function square(n) {
+ *   return n * n;
+ * }
+ *
+ * var func = _.overArgs(function(x, y) {
+ *   return [x, y];
+ * }, [square, doubled]);
+ *
+ * func(9, 3);
+ * // => [81, 6]
+ *
+ * func(10, 5);
+ * // => [100, 10]
+ */
+declare var overArgs: any;

package/types/lodash/overEvery.d.ts

@@ -0,0 +1,30 @@
+export default overEvery;
+/**
+ * Creates a function that checks if **all** of the `predicates` return
+ * truthy when invoked with the arguments it receives.
+ *
+ * Following shorthands are possible for providing predicates.
+ * Pass an `Object` and it will be used as an parameter for `_.matches` to create the predicate.
+ * Pass an `Array` of parameters for `_.matchesProperty` and the predicate will be created using them.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Util
+ * @param {...(Function|Function[])} [predicates=[_.identity]]
+ *  The predicates to check.
+ * @returns {Function} Returns the new function.
+ * @example
+ *
+ * var func = _.overEvery([Boolean, isFinite]);
+ *
+ * func('1');
+ * // => true
+ *
+ * func(null);
+ * // => false
+ *
+ * func(NaN);
+ * // => false
+ */
+declare var overEvery: Function;

package/types/lodash/overSome.d.ts

@@ -0,0 +1,33 @@
+export default overSome;
+/**
+ * Creates a function that checks if **any** of the `predicates` return
+ * truthy when invoked with the arguments it receives.
+ *
+ * Following shorthands are possible for providing predicates.
+ * Pass an `Object` and it will be used as an parameter for `_.matches` to create the predicate.
+ * Pass an `Array` of parameters for `_.matchesProperty` and the predicate will be created using them.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Util
+ * @param {...(Function|Function[])} [predicates=[_.identity]]
+ *  The predicates to check.
+ * @returns {Function} Returns the new function.
+ * @example
+ *
+ * var func = _.overSome([Boolean, isFinite]);
+ *
+ * func('1');
+ * // => true
+ *
+ * func(null);
+ * // => true
+ *
+ * func(NaN);
+ * // => false
+ *
+ * var matchesFunc = _.overSome([{ 'a': 1 }, { 'a': 2 }])
+ * var matchesPropertyFunc = _.overSome([['a', 1], ['a', 2]])
+ */
+declare var overSome: Function;

package/types/lodash/pad.d.ts

@@ -0,0 +1,25 @@
+export default pad;
+/**
+ * Pads `string` on the left and right sides if it's shorter than `length`.
+ * Padding characters are truncated if they can't be evenly divided by `length`.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category String
+ * @param {string} [string=''] The string to pad.
+ * @param {number} [length=0] The padding length.
+ * @param {string} [chars=' '] The string used as padding.
+ * @returns {string} Returns the padded string.
+ * @example
+ *
+ * _.pad('abc', 8);
+ * // => '  abc   '
+ *
+ * _.pad('abc', 8, '_-');
+ * // => '_-abc_-_'
+ *
+ * _.pad('abc', 3);
+ * // => 'abc'
+ */
+declare function pad(string?: string, length?: number, chars?: string): string;

package/types/lodash/padEnd.d.ts

@@ -0,0 +1,25 @@
+export default padEnd;
+/**
+ * Pads `string` on the right side if it's shorter than `length`. Padding
+ * characters are truncated if they exceed `length`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category String
+ * @param {string} [string=''] The string to pad.
+ * @param {number} [length=0] The padding length.
+ * @param {string} [chars=' '] The string used as padding.
+ * @returns {string} Returns the padded string.
+ * @example
+ *
+ * _.padEnd('abc', 6);
+ * // => 'abc   '
+ *
+ * _.padEnd('abc', 6, '_-');
+ * // => 'abc_-_'
+ *
+ * _.padEnd('abc', 3);
+ * // => 'abc'
+ */
+declare function padEnd(string?: string, length?: number, chars?: string): string;

package/types/lodash/padStart.d.ts

@@ -0,0 +1,25 @@
+export default padStart;
+/**
+ * Pads `string` on the left side if it's shorter than `length`. Padding
+ * characters are truncated if they exceed `length`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category String
+ * @param {string} [string=''] The string to pad.
+ * @param {number} [length=0] The padding length.
+ * @param {string} [chars=' '] The string used as padding.
+ * @returns {string} Returns the padded string.
+ * @example
+ *
+ * _.padStart('abc', 6);
+ * // => '   abc'
+ *
+ * _.padStart('abc', 6, '_-');
+ * // => '_-_abc'
+ *
+ * _.padStart('abc', 3);
+ * // => 'abc'
+ */
+declare function padStart(string?: string, length?: number, chars?: string): string;

package/types/lodash/parseInt.d.ts

@@ -0,0 +1,26 @@
+export default parseInt;
+/**
+ * Converts `string` to an integer of the specified radix. If `radix` is
+ * `undefined` or `0`, a `radix` of `10` is used unless `value` is a
+ * hexadecimal, in which case a `radix` of `16` is used.
+ *
+ * **Note:** This method aligns with the
+ * [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`.
+ *
+ * @static
+ * @memberOf _
+ * @since 1.1.0
+ * @category String
+ * @param {string} string The string to convert.
+ * @param {number} [radix=10] The radix to interpret `value` by.
+ * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
+ * @returns {number} Returns the converted integer.
+ * @example
+ *
+ * _.parseInt('08');
+ * // => 8
+ *
+ * _.map(['6', '08', '10'], _.parseInt);
+ * // => [6, 8, 10]
+ */
+declare function parseInt(string: string, radix?: number, guard: any): number;

package/types/lodash/partial.d.ts

@@ -0,0 +1,35 @@
+export default partial;
+/**
+ * Creates a function that invokes `func` with `partials` prepended to the
+ * arguments it receives. This method is like `_.bind` except it does **not**
+ * alter the `this` binding.
+ *
+ * The `_.partial.placeholder` value, which defaults to `_` in monolithic
+ * builds, may be used as a placeholder for partially applied arguments.
+ *
+ * **Note:** This method doesn't set the "length" property of partially
+ * applied functions.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.2.0
+ * @category Function
+ * @param {Function} func The function to partially apply arguments to.
+ * @param {...*} [partials] The arguments to be partially applied.
+ * @returns {Function} Returns the new partially applied function.
+ * @example
+ *
+ * function greet(greeting, name) {
+ *   return greeting + ' ' + name;
+ * }
+ *
+ * var sayHelloTo = _.partial(greet, 'hello');
+ * sayHelloTo('fred');
+ * // => 'hello fred'
+ *
+ * // Partially applied with placeholders.
+ * var greetFred = _.partial(greet, _, 'fred');
+ * greetFred('hi');
+ * // => 'hi fred'
+ */
+declare var partial: Function;

package/types/lodash/partialRight.d.ts

@@ -0,0 +1,34 @@
+export default partialRight;
+/**
+ * This method is like `_.partial` except that partially applied arguments
+ * are appended to the arguments it receives.
+ *
+ * The `_.partialRight.placeholder` value, which defaults to `_` in monolithic
+ * builds, may be used as a placeholder for partially applied arguments.
+ *
+ * **Note:** This method doesn't set the "length" property of partially
+ * applied functions.
+ *
+ * @static
+ * @memberOf _
+ * @since 1.0.0
+ * @category Function
+ * @param {Function} func The function to partially apply arguments to.
+ * @param {...*} [partials] The arguments to be partially applied.
+ * @returns {Function} Returns the new partially applied function.
+ * @example
+ *
+ * function greet(greeting, name) {
+ *   return greeting + ' ' + name;
+ * }
+ *
+ * var greetFred = _.partialRight(greet, 'fred');
+ * greetFred('hi');
+ * // => 'hi fred'
+ *
+ * // Partially applied with placeholders.
+ * var sayHelloTo = _.partialRight(greet, 'hello', _);
+ * sayHelloTo('fred');
+ * // => 'hello fred'
+ */
+declare var partialRight: Function;

package/types/lodash/partition.d.ts

@@ -0,0 +1,38 @@
+export default partition;
+/**
+ * Creates an array of elements split into two groups, the first of which
+ * contains elements `predicate` returns truthy for, the second of which
+ * contains elements `predicate` returns falsey for. The predicate is
+ * invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [predicate=_.identity] The function invoked per iteration.
+ * @returns {Array} Returns the array of grouped elements.
+ * @example
+ *
+ * var users = [
+ *   { 'user': 'barney',  'age': 36, 'active': false },
+ *   { 'user': 'fred',    'age': 40, 'active': true },
+ *   { 'user': 'pebbles', 'age': 1,  'active': false }
+ * ];
+ *
+ * _.partition(users, function(o) { return o.active; });
+ * // => objects for [['fred'], ['barney', 'pebbles']]
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.partition(users, { 'age': 1, 'active': false });
+ * // => objects for [['pebbles'], ['barney', 'fred']]
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.partition(users, ['active', false]);
+ * // => objects for [['barney', 'pebbles'], ['fred']]
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.partition(users, 'active');
+ * // => objects for [['fred'], ['barney', 'pebbles']]
+ */
+declare var partition: Function;

package/types/lodash/pick.d.ts

@@ -0,0 +1,19 @@
+export default pick;
+/**
+ * Creates an object composed of the picked `object` properties.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The source object.
+ * @param {...(string|string[])} [paths] The property paths to pick.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': '2', 'c': 3 };
+ *
+ * _.pick(object, ['a', 'c']);
+ * // => { 'a': 1, 'c': 3 }
+ */
+declare var pick: Function;

package/types/lodash/pickBy.d.ts

@@ -0,0 +1,20 @@
+export default pickBy;
+/**
+ * Creates an object composed of the `object` properties `predicate` returns
+ * truthy for. The predicate is invoked with two arguments: (value, key).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Object
+ * @param {Object} object The source object.
+ * @param {Function} [predicate=_.identity] The function invoked per property.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': '2', 'c': 3 };
+ *
+ * _.pickBy(object, _.isNumber);
+ * // => { 'a': 1, 'c': 3 }
+ */
+declare function pickBy(object: Object, predicate?: Function): Object;

package/types/lodash/plant.d.ts

@@ -0,0 +1,26 @@
+export default wrapperPlant;
+/**
+ * Creates a clone of the chain sequence planting `value` as the wrapped value.
+ *
+ * @name plant
+ * @memberOf _
+ * @since 3.2.0
+ * @category Seq
+ * @param {*} value The value to plant.
+ * @returns {Object} Returns the new `lodash` wrapper instance.
+ * @example
+ *
+ * function square(n) {
+ *   return n * n;
+ * }
+ *
+ * var wrapped = _([1, 2]).map(square);
+ * var other = wrapped.plant([3, 4]);
+ *
+ * other.value();
+ * // => [9, 16]
+ *
+ * wrapped.value();
+ * // => [1, 4]
+ */
+declare function wrapperPlant(value: any): Object;

package/types/lodash/property.d.ts

@@ -0,0 +1,24 @@
+export default property;
+/**
+ * Creates a function that returns the value at `path` of a given object.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.4.0
+ * @category Util
+ * @param {Array|string} path The path of the property to get.
+ * @returns {Function} Returns the new accessor function.
+ * @example
+ *
+ * var objects = [
+ *   { 'a': { 'b': 2 } },
+ *   { 'a': { 'b': 1 } }
+ * ];
+ *
+ * _.map(objects, _.property('a.b'));
+ * // => [2, 1]
+ *
+ * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');
+ * // => [1, 2]
+ */
+declare function property(path: any[] | string): Function;