@unicom-cloud/utils 0.1.23 → 0.1.25

package/types/lodash/isUndefined.d.ts

@@ -0,0 +1,19 @@
+export default isUndefined;
+/**
+ * Checks if `value` is `undefined`.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.
+ * @example
+ *
+ * _.isUndefined(void 0);
+ * // => true
+ *
+ * _.isUndefined(null);
+ * // => false
+ */
+declare function isUndefined(value: any): boolean;

package/types/lodash/isWeakMap.d.ts

@@ -0,0 +1,19 @@
+export default isWeakMap;
+/**
+ * Checks if `value` is classified as a `WeakMap` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.3.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a weak map, else `false`.
+ * @example
+ *
+ * _.isWeakMap(new WeakMap);
+ * // => true
+ *
+ * _.isWeakMap(new Map);
+ * // => false
+ */
+declare function isWeakMap(value: any): boolean;

package/types/lodash/isWeakSet.d.ts

@@ -0,0 +1,19 @@
+export default isWeakSet;
+/**
+ * Checks if `value` is classified as a `WeakSet` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.3.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a weak set, else `false`.
+ * @example
+ *
+ * _.isWeakSet(new WeakSet);
+ * // => true
+ *
+ * _.isWeakSet(new Set);
+ * // => false
+ */
+declare function isWeakSet(value: any): boolean;

package/types/lodash/iteratee.d.ts

@@ -0,0 +1,44 @@
+export default iteratee;
+/**
+ * Creates a function that invokes `func` with the arguments of the created
+ * function. If `func` is a property name, the created function returns the
+ * property value for a given element. If `func` is an array or object, the
+ * created function returns `true` for elements that contain the equivalent
+ * source properties, otherwise it returns `false`.
+ *
+ * @static
+ * @since 4.0.0
+ * @memberOf _
+ * @category Util
+ * @param {*} [func=_.identity] The value to convert to a callback.
+ * @returns {Function} Returns the callback.
+ * @example
+ *
+ * var users = [
+ *   { 'user': 'barney', 'age': 36, 'active': true },
+ *   { 'user': 'fred',   'age': 40, 'active': false }
+ * ];
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.filter(users, _.iteratee({ 'user': 'barney', 'active': true }));
+ * // => [{ 'user': 'barney', 'age': 36, 'active': true }]
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.filter(users, _.iteratee(['user', 'fred']));
+ * // => [{ 'user': 'fred', 'age': 40 }]
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.map(users, _.iteratee('user'));
+ * // => ['barney', 'fred']
+ *
+ * // Create custom iteratee shorthands.
+ * _.iteratee = _.wrap(_.iteratee, function(iteratee, func) {
+ *   return !_.isRegExp(func) ? iteratee(func) : function(string) {
+ *     return func.test(string);
+ *   };
+ * });
+ *
+ * _.filter(['abc', 'def'], /ef/);
+ * // => ['def']
+ */
+declare function iteratee(func?: any): Function;

package/types/lodash/join.d.ts

@@ -0,0 +1,17 @@
+export default join;
+/**
+ * Converts all elements in `array` into a string separated by `separator`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {Array} array The array to convert.
+ * @param {string} [separator=','] The element separator.
+ * @returns {string} Returns the joined string.
+ * @example
+ *
+ * _.join(['a', 'b', 'c'], '~');
+ * // => 'a~b~c'
+ */
+declare function join(array: any[], separator?: string): string;

package/types/lodash/kebabCase.d.ts

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

package/types/lodash/keyBy.d.ts

@@ -0,0 +1,30 @@
+export default keyBy;
+/**
+ * Creates an object composed of keys generated from the results of running
+ * each element of `collection` thru `iteratee`. The corresponding value of
+ * each key is the last element responsible for generating the key. The
+ * iteratee is invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [iteratee=_.identity] The iteratee to transform keys.
+ * @returns {Object} Returns the composed aggregate object.
+ * @example
+ *
+ * var array = [
+ *   { 'dir': 'left', 'code': 97 },
+ *   { 'dir': 'right', 'code': 100 }
+ * ];
+ *
+ * _.keyBy(array, function(o) {
+ *   return String.fromCharCode(o.code);
+ * });
+ * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
+ *
+ * _.keyBy(array, 'dir');
+ * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }
+ */
+declare var keyBy: Function;

package/types/lodash/keys.d.ts

@@ -0,0 +1,30 @@
+export default keys;
+/**
+ * Creates an array of the own enumerable property names of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects. See the
+ * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+ * for more details.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ * @example
+ *
+ * function Foo() {
+ *   this.a = 1;
+ *   this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.keys(new Foo);
+ * // => ['a', 'b'] (iteration order is not guaranteed)
+ *
+ * _.keys('hi');
+ * // => ['0', '1']
+ */
+declare function keys(object: Object): any[];

package/types/lodash/keysIn.d.ts

@@ -0,0 +1,25 @@
+export default keysIn;
+/**
+ * Creates an array of the own and inherited enumerable property names of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ * @example
+ *
+ * function Foo() {
+ *   this.a = 1;
+ *   this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.keysIn(new Foo);
+ * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
+ */
+declare function keysIn(object: Object): any[];

package/types/lodash/lang.d.ts

@@ -0,0 +1,57 @@
+export { default as castArray } from "./castArray.js";
+export { default as clone } from "./clone.js";
+export { default as cloneDeep } from "./cloneDeep.js";
+export { default as cloneDeepWith } from "./cloneDeepWith.js";
+export { default as cloneWith } from "./cloneWith.js";
+export { default as conformsTo } from "./conformsTo.js";
+export { default as eq } from "./eq.js";
+export { default as gt } from "./gt.js";
+export { default as gte } from "./gte.js";
+export { default as isArguments } from "./isArguments.js";
+export { default as isArray } from "./isArray.js";
+export { default as isArrayBuffer } from "./isArrayBuffer.js";
+export { default as isArrayLike } from "./isArrayLike.js";
+export { default as isArrayLikeObject } from "./isArrayLikeObject.js";
+export { default as isBoolean } from "./isBoolean.js";
+export { default as isBuffer } from "./isBuffer.js";
+export { default as isDate } from "./isDate.js";
+export { default as isElement } from "./isElement.js";
+export { default as isEmpty } from "./isEmpty.js";
+export { default as isEqual } from "./isEqual.js";
+export { default as isEqualWith } from "./isEqualWith.js";
+export { default as isError } from "./isError.js";
+export { default as isFinite } from "./isFinite.js";
+export { default as isFunction } from "./isFunction.js";
+export { default as isInteger } from "./isInteger.js";
+export { default as isLength } from "./isLength.js";
+export { default as isMap } from "./isMap.js";
+export { default as isMatch } from "./isMatch.js";
+export { default as isMatchWith } from "./isMatchWith.js";
+export { default as isNaN } from "./isNaN.js";
+export { default as isNative } from "./isNative.js";
+export { default as isNil } from "./isNil.js";
+export { default as isNull } from "./isNull.js";
+export { default as isNumber } from "./isNumber.js";
+export { default as isObject } from "./isObject.js";
+export { default as isObjectLike } from "./isObjectLike.js";
+export { default as isPlainObject } from "./isPlainObject.js";
+export { default as isRegExp } from "./isRegExp.js";
+export { default as isSafeInteger } from "./isSafeInteger.js";
+export { default as isSet } from "./isSet.js";
+export { default as isString } from "./isString.js";
+export { default as isSymbol } from "./isSymbol.js";
+export { default as isTypedArray } from "./isTypedArray.js";
+export { default as isUndefined } from "./isUndefined.js";
+export { default as isWeakMap } from "./isWeakMap.js";
+export { default as isWeakSet } from "./isWeakSet.js";
+export { default as lt } from "./lt.js";
+export { default as lte } from "./lte.js";
+export { default as toArray } from "./toArray.js";
+export { default as toFinite } from "./toFinite.js";
+export { default as toInteger } from "./toInteger.js";
+export { default as toLength } from "./toLength.js";
+export { default as toNumber } from "./toNumber.js";
+export { default as toPlainObject } from "./toPlainObject.js";
+export { default as toSafeInteger } from "./toSafeInteger.js";
+export { default as toString } from "./toString.js";
+export { default } from "./lang.default.js";

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

@@ -0,0 +1,115 @@
+declare namespace _default {
+    export { castArray };
+    export { clone };
+    export { cloneDeep };
+    export { cloneDeepWith };
+    export { cloneWith };
+    export { conformsTo };
+    export { eq };
+    export { gt };
+    export { gte };
+    export { isArguments };
+    export { isArray };
+    export { isArrayBuffer };
+    export { isArrayLike };
+    export { isArrayLikeObject };
+    export { isBoolean };
+    export { isBuffer };
+    export { isDate };
+    export { isElement };
+    export { isEmpty };
+    export { isEqual };
+    export { isEqualWith };
+    export { isError };
+    export { isFinite };
+    export { isFunction };
+    export { isInteger };
+    export { isLength };
+    export { isMap };
+    export { isMatch };
+    export { isMatchWith };
+    export { isNaN };
+    export { isNative };
+    export { isNil };
+    export { isNull };
+    export { isNumber };
+    export { isObject };
+    export { isObjectLike };
+    export { isPlainObject };
+    export { isRegExp };
+    export { isSafeInteger };
+    export { isSet };
+    export { isString };
+    export { isSymbol };
+    export { isTypedArray };
+    export { isUndefined };
+    export { isWeakMap };
+    export { isWeakSet };
+    export { lt };
+    export { lte };
+    export { toArray };
+    export { toFinite };
+    export { toInteger };
+    export { toLength };
+    export { toNumber };
+    export { toPlainObject };
+    export { toSafeInteger };
+    export { toString };
+}
+export default _default;
+import castArray from './castArray.js';
+import clone from './clone.js';
+import cloneDeep from './cloneDeep.js';
+import cloneDeepWith from './cloneDeepWith.js';
+import cloneWith from './cloneWith.js';
+import conformsTo from './conformsTo.js';
+import eq from './eq.js';
+import gt from './gt.js';
+import gte from './gte.js';
+import isArguments from './isArguments.js';
+import isArray from './isArray.js';
+import isArrayBuffer from './isArrayBuffer.js';
+import isArrayLike from './isArrayLike.js';
+import isArrayLikeObject from './isArrayLikeObject.js';
+import isBoolean from './isBoolean.js';
+import isBuffer from './isBuffer.js';
+import isDate from './isDate.js';
+import isElement from './isElement.js';
+import isEmpty from './isEmpty.js';
+import isEqual from './isEqual.js';
+import isEqualWith from './isEqualWith.js';
+import isError from './isError.js';
+import isFinite from './isFinite.js';
+import isFunction from './isFunction.js';
+import isInteger from './isInteger.js';
+import isLength from './isLength.js';
+import isMap from './isMap.js';
+import isMatch from './isMatch.js';
+import isMatchWith from './isMatchWith.js';
+import isNaN from './isNaN.js';
+import isNative from './isNative.js';
+import isNil from './isNil.js';
+import isNull from './isNull.js';
+import isNumber from './isNumber.js';
+import isObject from './isObject.js';
+import isObjectLike from './isObjectLike.js';
+import isPlainObject from './isPlainObject.js';
+import isRegExp from './isRegExp.js';
+import isSafeInteger from './isSafeInteger.js';
+import isSet from './isSet.js';
+import isString from './isString.js';
+import isSymbol from './isSymbol.js';
+import isTypedArray from './isTypedArray.js';
+import isUndefined from './isUndefined.js';
+import isWeakMap from './isWeakMap.js';
+import isWeakSet from './isWeakSet.js';
+import lt from './lt.js';
+import lte from './lte.js';
+import toArray from './toArray.js';
+import toFinite from './toFinite.js';
+import toInteger from './toInteger.js';
+import toLength from './toLength.js';
+import toNumber from './toNumber.js';
+import toPlainObject from './toPlainObject.js';
+import toSafeInteger from './toSafeInteger.js';
+import toString from './toString.js';

package/types/lodash/last.d.ts

@@ -0,0 +1,16 @@
+export default last;
+/**
+ * Gets the last element of `array`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {Array} array The array to query.
+ * @returns {*} Returns the last element of `array`.
+ * @example
+ *
+ * _.last([1, 2, 3]);
+ * // => 3
+ */
+declare function last(array: any[]): any;

package/types/lodash/lastIndexOf.d.ts

@@ -0,0 +1,23 @@
+export default lastIndexOf;
+/**
+ * This method is like `_.indexOf` except that it iterates over elements of
+ * `array` from right to left.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {*} value The value to search for.
+ * @param {number} [fromIndex=array.length-1] The index to search from.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ * @example
+ *
+ * _.lastIndexOf([1, 2, 1, 2], 2);
+ * // => 3
+ *
+ * // Search from the `fromIndex`.
+ * _.lastIndexOf([1, 2, 1, 2], 2, 2);
+ * // => 1
+ */
+declare function lastIndexOf(array: any[], value: any, fromIndex?: number): number;