@unicom-cloud/utils 0.1.23 → 0.1.24

package/types/lodash/set.d.ts

@@ -0,0 +1,30 @@
+export default set;
+/**
+ * Sets the value at `path` of `object`. If a portion of `path` doesn't exist,
+ * it's created. Arrays are created for missing index properties while objects
+ * are created for all other missing properties. Use `_.setWith` to customize
+ * `path` creation.
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.7.0
+ * @category Object
+ * @param {Object} object The object to modify.
+ * @param {Array|string} path The path of the property to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * var object = { 'a': [{ 'b': { 'c': 3 } }] };
+ *
+ * _.set(object, 'a[0].b.c', 4);
+ * console.log(object.a[0].b.c);
+ * // => 4
+ *
+ * _.set(object, ['x', '0', 'y', 'z'], 5);
+ * console.log(object.x[0].y.z);
+ * // => 5
+ */
+declare function set(object: Object, path: any[] | string, value: any): Object;

package/types/lodash/setWith.d.ts

@@ -0,0 +1,26 @@
+export default setWith;
+/**
+ * This method is like `_.set` except that it accepts `customizer` which is
+ * invoked to produce the objects of `path`.  If `customizer` returns `undefined`
+ * path creation is handled by the method instead. The `customizer` is invoked
+ * with three arguments: (nsValue, key, nsObject).
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Object
+ * @param {Object} object The object to modify.
+ * @param {Array|string} path The path of the property to set.
+ * @param {*} value The value to set.
+ * @param {Function} [customizer] The function to customize assigned values.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * var object = {};
+ *
+ * _.setWith(object, '[0][1]', 'a', Object);
+ * // => { '0': { '1': 'a' } }
+ */
+declare function setWith(object: Object, path: any[] | string, value: any, customizer?: Function): Object;

package/types/lodash/shuffle.d.ts

@@ -0,0 +1,17 @@
+export default shuffle;
+/**
+ * Creates an array of shuffled values, using a version of the
+ * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle).
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to shuffle.
+ * @returns {Array} Returns the new shuffled array.
+ * @example
+ *
+ * _.shuffle([1, 2, 3, 4]);
+ * // => [4, 1, 3, 2]
+ */
+declare function shuffle(collection: any[] | Object): any[];

package/types/lodash/size.d.ts

@@ -0,0 +1,23 @@
+export default size;
+/**
+ * Gets the size of `collection` by returning its length for array-like
+ * values or the number of own enumerable string keyed properties for objects.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object|string} collection The collection to inspect.
+ * @returns {number} Returns the collection size.
+ * @example
+ *
+ * _.size([1, 2, 3]);
+ * // => 3
+ *
+ * _.size({ 'a': 1, 'b': 2 });
+ * // => 2
+ *
+ * _.size('pebbles');
+ * // => 7
+ */
+declare function size(collection: any[] | Object | string): number;

package/types/lodash/slice.d.ts

@@ -0,0 +1,18 @@
+export default slice;
+/**
+ * Creates a slice of `array` from `start` up to, but not including, `end`.
+ *
+ * **Note:** This method is used instead of
+ * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are
+ * returned.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Array
+ * @param {Array} array The array to slice.
+ * @param {number} [start=0] The start position.
+ * @param {number} [end=array.length] The end position.
+ * @returns {Array} Returns the slice of `array`.
+ */
+declare function slice(array: any[], start?: number, end?: number): any[];

package/types/lodash/snakeCase.d.ts

@@ -0,0 +1,23 @@
+export default snakeCase;
+/**
+ * Converts `string` to
+ * [snake case](https://en.wikipedia.org/wiki/Snake_case).
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category String
+ * @param {string} [string=''] The string to convert.
+ * @returns {string} Returns the snake cased string.
+ * @example
+ *
+ * _.snakeCase('Foo Bar');
+ * // => 'foo_bar'
+ *
+ * _.snakeCase('fooBar');
+ * // => 'foo_bar'
+ *
+ * _.snakeCase('--FOO-BAR--');
+ * // => 'foo_bar'
+ */
+declare var snakeCase: Function;

package/types/lodash/some.d.ts

@@ -0,0 +1,38 @@
+export default some;
+/**
+ * Checks if `predicate` returns truthy for **any** element of `collection`.
+ * Iteration is stopped once `predicate` returns truthy. The predicate is
+ * invoked with three arguments: (value, index|key, collection).
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [predicate=_.identity] The function invoked per iteration.
+ * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
+ * @returns {boolean} Returns `true` if any element passes the predicate check,
+ *  else `false`.
+ * @example
+ *
+ * _.some([null, 0, 'yes', false], Boolean);
+ * // => true
+ *
+ * var users = [
+ *   { 'user': 'barney', 'active': true },
+ *   { 'user': 'fred',   'active': false }
+ * ];
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.some(users, { 'user': 'barney', 'active': false });
+ * // => false
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.some(users, ['active', false]);
+ * // => true
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.some(users, 'active');
+ * // => true
+ */
+declare function some(collection: any[] | Object, predicate?: Function, guard: any): boolean;

package/types/lodash/sortBy.d.ts

@@ -0,0 +1,31 @@
+export default sortBy;
+/**
+ * Creates an array of elements, sorted in ascending order by the results of
+ * running each element in a collection thru each iteratee. This method
+ * performs a stable sort, that is, it preserves the original sort order of
+ * equal elements. The iteratees are invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {...(Function|Function[])} [iteratees=[_.identity]]
+ *  The iteratees to sort by.
+ * @returns {Array} Returns the new sorted array.
+ * @example
+ *
+ * var users = [
+ *   { 'user': 'fred',   'age': 48 },
+ *   { 'user': 'barney', 'age': 36 },
+ *   { 'user': 'fred',   'age': 30 },
+ *   { 'user': 'barney', 'age': 34 }
+ * ];
+ *
+ * _.sortBy(users, [function(o) { return o.user; }]);
+ * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 30]]
+ *
+ * _.sortBy(users, ['user', 'age']);
+ * // => objects for [['barney', 34], ['barney', 36], ['fred', 30], ['fred', 48]]
+ */
+declare var sortBy: Function;

package/types/lodash/sortedIndex.d.ts

@@ -0,0 +1,19 @@
+export default sortedIndex;
+/**
+ * Uses a binary search to determine the lowest index at which `value`
+ * should be inserted into `array` in order to maintain its sort order.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {Array} array The sorted array to inspect.
+ * @param {*} value The value to evaluate.
+ * @returns {number} Returns the index at which `value` should be inserted
+ *  into `array`.
+ * @example
+ *
+ * _.sortedIndex([30, 50], 40);
+ * // => 1
+ */
+declare function sortedIndex(array: any[], value: any): number;

package/types/lodash/sortedIndexBy.d.ts

@@ -0,0 +1,27 @@
+export default sortedIndexBy;
+/**
+ * This method is like `_.sortedIndex` except that it accepts `iteratee`
+ * which is invoked for `value` and each element of `array` to compute their
+ * sort ranking. The iteratee is invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {Array} array The sorted array to inspect.
+ * @param {*} value The value to evaluate.
+ * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
+ * @returns {number} Returns the index at which `value` should be inserted
+ *  into `array`.
+ * @example
+ *
+ * var objects = [{ 'x': 4 }, { 'x': 5 }];
+ *
+ * _.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
+ * // => 0
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.sortedIndexBy(objects, { 'x': 4 }, 'x');
+ * // => 0
+ */
+declare function sortedIndexBy(array: any[], value: any, iteratee?: Function): number;

package/types/lodash/sortedIndexOf.d.ts

@@ -0,0 +1,18 @@
+export default sortedIndexOf;
+/**
+ * This method is like `_.indexOf` except that it performs a binary
+ * search on a sorted `array`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {*} value The value to search for.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ * @example
+ *
+ * _.sortedIndexOf([4, 5, 5, 5, 6], 5);
+ * // => 1
+ */
+declare function sortedIndexOf(array: any[], value: any): number;

package/types/lodash/sortedLastIndex.d.ts

@@ -0,0 +1,20 @@
+export default sortedLastIndex;
+/**
+ * This method is like `_.sortedIndex` except that it returns the highest
+ * index at which `value` should be inserted into `array` in order to
+ * maintain its sort order.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Array
+ * @param {Array} array The sorted array to inspect.
+ * @param {*} value The value to evaluate.
+ * @returns {number} Returns the index at which `value` should be inserted
+ *  into `array`.
+ * @example
+ *
+ * _.sortedLastIndex([4, 5, 5, 5, 6], 5);
+ * // => 4
+ */
+declare function sortedLastIndex(array: any[], value: any): number;

package/types/lodash/sortedLastIndexBy.d.ts

@@ -0,0 +1,27 @@
+export default sortedLastIndexBy;
+/**
+ * This method is like `_.sortedLastIndex` except that it accepts `iteratee`
+ * which is invoked for `value` and each element of `array` to compute their
+ * sort ranking. The iteratee is invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {Array} array The sorted array to inspect.
+ * @param {*} value The value to evaluate.
+ * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
+ * @returns {number} Returns the index at which `value` should be inserted
+ *  into `array`.
+ * @example
+ *
+ * var objects = [{ 'x': 4 }, { 'x': 5 }];
+ *
+ * _.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
+ * // => 1
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.sortedLastIndexBy(objects, { 'x': 4 }, 'x');
+ * // => 1
+ */
+declare function sortedLastIndexBy(array: any[], value: any, iteratee?: Function): number;

package/types/lodash/sortedLastIndexOf.d.ts

@@ -0,0 +1,18 @@
+export default sortedLastIndexOf;
+/**
+ * This method is like `_.lastIndexOf` except that it performs a binary
+ * search on a sorted `array`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {*} value The value to search for.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ * @example
+ *
+ * _.sortedLastIndexOf([4, 5, 5, 5, 6], 5);
+ * // => 3
+ */
+declare function sortedLastIndexOf(array: any[], value: any): number;

package/types/lodash/sortedUniq.d.ts

@@ -0,0 +1,17 @@
+export default sortedUniq;
+/**
+ * This method is like `_.uniq` except that it's designed and optimized
+ * for sorted arrays.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @returns {Array} Returns the new duplicate free array.
+ * @example
+ *
+ * _.sortedUniq([1, 1, 2]);
+ * // => [1, 2]
+ */
+declare function sortedUniq(array: any[]): any[];

package/types/lodash/sortedUniqBy.d.ts

@@ -0,0 +1,18 @@
+export default sortedUniqBy;
+/**
+ * This method is like `_.uniqBy` except that it's designed and optimized
+ * for sorted arrays.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {Function} [iteratee] The iteratee invoked per element.
+ * @returns {Array} Returns the new duplicate free array.
+ * @example
+ *
+ * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);
+ * // => [1.1, 2.3]
+ */
+declare function sortedUniqBy(array: any[], iteratee?: Function): any[];

package/types/lodash/split.d.ts

@@ -0,0 +1,21 @@
+export default split;
+/**
+ * Splits `string` by `separator`.
+ *
+ * **Note:** This method is based on
+ * [`String#split`](https://mdn.io/String/split).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category String
+ * @param {string} [string=''] The string to split.
+ * @param {RegExp|string} separator The separator pattern to split by.
+ * @param {number} [limit] The length to truncate results to.
+ * @returns {Array} Returns the string segments.
+ * @example
+ *
+ * _.split('a-b-c', '-', 2);
+ * // => ['a', 'b']
+ */
+declare function split(string?: string, separator: RegExp | string, limit?: number): any[];

package/types/lodash/spread.d.ts

@@ -0,0 +1,36 @@
+export default spread;
+/**
+ * Creates a function that invokes `func` with the `this` binding of the
+ * create function and an array of arguments much like
+ * [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply).
+ *
+ * **Note:** This method is based on the
+ * [spread operator](https://mdn.io/spread_operator).
+ *
+ * @static
+ * @memberOf _
+ * @since 3.2.0
+ * @category Function
+ * @param {Function} func The function to spread arguments over.
+ * @param {number} [start=0] The start position of the spread.
+ * @returns {Function} Returns the new function.
+ * @example
+ *
+ * var say = _.spread(function(who, what) {
+ *   return who + ' says ' + what;
+ * });
+ *
+ * say(['fred', 'hello']);
+ * // => 'fred says hello'
+ *
+ * var numbers = Promise.all([
+ *   Promise.resolve(40),
+ *   Promise.resolve(36)
+ * ]);
+ *
+ * numbers.then(_.spread(function(x, y) {
+ *   return x + y;
+ * }));
+ * // => a Promise of 76
+ */
+declare function spread(func: Function, start?: number): Function;

package/types/lodash/startCase.d.ts

@@ -0,0 +1,23 @@
+export default startCase;
+/**
+ * Converts `string` to
+ * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage).
+ *
+ * @static
+ * @memberOf _
+ * @since 3.1.0
+ * @category String
+ * @param {string} [string=''] The string to convert.
+ * @returns {string} Returns the start cased string.
+ * @example
+ *
+ * _.startCase('--foo-bar--');
+ * // => 'Foo Bar'
+ *
+ * _.startCase('fooBar');
+ * // => 'Foo Bar'
+ *
+ * _.startCase('__FOO_BAR__');
+ * // => 'FOO BAR'
+ */
+declare var startCase: Function;

package/types/lodash/startsWith.d.ts

@@ -0,0 +1,25 @@
+export default startsWith;
+/**
+ * Checks if `string` starts with the given target string.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category String
+ * @param {string} [string=''] The string to inspect.
+ * @param {string} [target] The string to search for.
+ * @param {number} [position=0] The position to search from.
+ * @returns {boolean} Returns `true` if `string` starts with `target`,
+ *  else `false`.
+ * @example
+ *
+ * _.startsWith('abc', 'a');
+ * // => true
+ *
+ * _.startsWith('abc', 'b');
+ * // => false
+ *
+ * _.startsWith('abc', 'b', 1);
+ * // => true
+ */
+declare function startsWith(string?: string, target?: string, position?: number): boolean;

package/types/lodash/string.d.ts

@@ -0,0 +1,32 @@
+export { default as camelCase } from "./camelCase.js";
+export { default as capitalize } from "./capitalize.js";
+export { default as deburr } from "./deburr.js";
+export { default as endsWith } from "./endsWith.js";
+export { default as escape } from "./escape.js";
+export { default as escapeRegExp } from "./escapeRegExp.js";
+export { default as kebabCase } from "./kebabCase.js";
+export { default as lowerCase } from "./lowerCase.js";
+export { default as lowerFirst } from "./lowerFirst.js";
+export { default as pad } from "./pad.js";
+export { default as padEnd } from "./padEnd.js";
+export { default as padStart } from "./padStart.js";
+export { default as parseInt } from "./parseInt.js";
+export { default as repeat } from "./repeat.js";
+export { default as replace } from "./replace.js";
+export { default as snakeCase } from "./snakeCase.js";
+export { default as split } from "./split.js";
+export { default as startCase } from "./startCase.js";
+export { default as startsWith } from "./startsWith.js";
+export { default as template } from "./template.js";
+export { default as templateSettings } from "./templateSettings.js";
+export { default as toLower } from "./toLower.js";
+export { default as toUpper } from "./toUpper.js";
+export { default as trim } from "./trim.js";
+export { default as trimEnd } from "./trimEnd.js";
+export { default as trimStart } from "./trimStart.js";
+export { default as truncate } from "./truncate.js";
+export { default as unescape } from "./unescape.js";
+export { default as upperCase } from "./upperCase.js";
+export { default as upperFirst } from "./upperFirst.js";
+export { default as words } from "./words.js";
+export { default } from "./string.default.js";

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

@@ -0,0 +1,65 @@
+declare namespace _default {
+    export { camelCase };
+    export { capitalize };
+    export { deburr };
+    export { endsWith };
+    export { escape };
+    export { escapeRegExp };
+    export { kebabCase };
+    export { lowerCase };
+    export { lowerFirst };
+    export { pad };
+    export { padEnd };
+    export { padStart };
+    export { parseInt };
+    export { repeat };
+    export { replace };
+    export { snakeCase };
+    export { split };
+    export { startCase };
+    export { startsWith };
+    export { template };
+    export { templateSettings };
+    export { toLower };
+    export { toUpper };
+    export { trim };
+    export { trimEnd };
+    export { trimStart };
+    export { truncate };
+    export { unescape };
+    export { upperCase };
+    export { upperFirst };
+    export { words };
+}
+export default _default;
+import camelCase from './camelCase.js';
+import capitalize from './capitalize.js';
+import deburr from './deburr.js';
+import endsWith from './endsWith.js';
+import escape from './escape.js';
+import escapeRegExp from './escapeRegExp.js';
+import kebabCase from './kebabCase.js';
+import lowerCase from './lowerCase.js';
+import lowerFirst from './lowerFirst.js';
+import pad from './pad.js';
+import padEnd from './padEnd.js';
+import padStart from './padStart.js';
+import parseInt from './parseInt.js';
+import repeat from './repeat.js';
+import replace from './replace.js';
+import snakeCase from './snakeCase.js';
+import split from './split.js';
+import startCase from './startCase.js';
+import startsWith from './startsWith.js';
+import template from './template.js';
+import templateSettings from './templateSettings.js';
+import toLower from './toLower.js';
+import toUpper from './toUpper.js';
+import trim from './trim.js';
+import trimEnd from './trimEnd.js';
+import trimStart from './trimStart.js';
+import truncate from './truncate.js';
+import unescape from './unescape.js';
+import upperCase from './upperCase.js';
+import upperFirst from './upperFirst.js';
+import words from './words.js';

package/types/lodash/stubArray.d.ts

@@ -0,0 +1,20 @@
+export default stubArray;
+/**
+ * This method returns a new empty array.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.13.0
+ * @category Util
+ * @returns {Array} Returns the new empty array.
+ * @example
+ *
+ * var arrays = _.times(2, _.stubArray);
+ *
+ * console.log(arrays);
+ * // => [[], []]
+ *
+ * console.log(arrays[0] === arrays[1]);
+ * // => false
+ */
+declare function stubArray(): any[];

package/types/lodash/stubFalse.d.ts

@@ -0,0 +1,15 @@
+export default stubFalse;
+/**
+ * This method returns `false`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.13.0
+ * @category Util
+ * @returns {boolean} Returns `false`.
+ * @example
+ *
+ * _.times(2, _.stubFalse);
+ * // => [false, false]
+ */
+declare function stubFalse(): boolean;

package/types/lodash/stubObject.d.ts

@@ -0,0 +1,20 @@
+export default stubObject;
+/**
+ * This method returns a new empty object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.13.0
+ * @category Util
+ * @returns {Object} Returns the new empty object.
+ * @example
+ *
+ * var objects = _.times(2, _.stubObject);
+ *
+ * console.log(objects);
+ * // => [{}, {}]
+ *
+ * console.log(objects[0] === objects[1]);
+ * // => false
+ */
+declare function stubObject(): Object;

package/types/lodash/stubString.d.ts

@@ -0,0 +1,15 @@
+export default stubString;
+/**
+ * This method returns an empty string.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.13.0
+ * @category Util
+ * @returns {string} Returns the empty string.
+ * @example
+ *
+ * _.times(2, _.stubString);
+ * // => ['', '']
+ */
+declare function stubString(): string;