@dxyl/utils 1.1.0 → 1.1.2

package/types/lodash/_toSource.d.ts

@@ -0,0 +1,9 @@
+export default toSource;
+/**
+ * Converts `func` to its source code.
+ *
+ * @private
+ * @param {Function} func The function to convert.
+ * @returns {string} Returns the source code.
+ */
+declare function toSource(func: Function): string;

package/types/lodash/_trimmedEndIndex.d.ts

@@ -0,0 +1,10 @@
+export default trimmedEndIndex;
+/**
+ * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace
+ * character of `string`.
+ *
+ * @private
+ * @param {string} string The string to inspect.
+ * @returns {number} Returns the index of the last non-whitespace character.
+ */
+declare function trimmedEndIndex(string: string): number;

package/types/lodash/_unescapeHtmlChar.d.ts

@@ -0,0 +1,9 @@
+export default unescapeHtmlChar;
+/**
+ * Used by `_.unescape` to convert HTML entities to characters.
+ *
+ * @private
+ * @param {string} chr The matched character to unescape.
+ * @returns {string} Returns the unescaped character.
+ */
+declare var unescapeHtmlChar: Function;

package/types/lodash/_unicodeSize.d.ts

@@ -0,0 +1,9 @@
+export default unicodeSize;
+/**
+ * Gets the size of a Unicode `string`.
+ *
+ * @private
+ * @param {string} string The string inspect.
+ * @returns {number} Returns the string size.
+ */
+declare function unicodeSize(string: string): number;

package/types/lodash/_unicodeToArray.d.ts

@@ -0,0 +1,9 @@
+export default unicodeToArray;
+/**
+ * Converts a Unicode `string` to an array.
+ *
+ * @private
+ * @param {string} string The string to convert.
+ * @returns {Array} Returns the converted array.
+ */
+declare function unicodeToArray(string: string): any[];

package/types/lodash/_unicodeWords.d.ts

@@ -0,0 +1,9 @@
+export default unicodeWords;
+/**
+ * Splits a Unicode `string` into an array of its words.
+ *
+ * @private
+ * @param {string} The string to inspect.
+ * @returns {Array} Returns the words of `string`.
+ */
+declare function unicodeWords(string: any): any[];

package/types/lodash/_updateWrapDetails.d.ts

@@ -0,0 +1,10 @@
+export default updateWrapDetails;
+/**
+ * Updates wrapper `details` based on `bitmask` flags.
+ *
+ * @private
+ * @returns {Array} details The details to modify.
+ * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
+ * @returns {Array} Returns `details`.
+ */
+declare function updateWrapDetails(details: any, bitmask: number): any[];

package/types/lodash/_wrapperClone.d.ts

@@ -0,0 +1,9 @@
+export default wrapperClone;
+/**
+ * Creates a clone of `wrapper`.
+ *
+ * @private
+ * @param {Object} wrapper The wrapper to clone.
+ * @returns {Object} Returns the cloned wrapper.
+ */
+declare function wrapperClone(wrapper: Object): Object;

package/types/lodash/add.d.ts

@@ -0,0 +1,2 @@
+import { add } from 'lodash';
+export default add;

package/types/lodash/after.d.ts

@@ -0,0 +1,2 @@
+import { after } from 'lodash';
+export default after;

package/types/lodash/array.d.ts

@@ -0,0 +1,66 @@
+import { default as chunk } from './chunk';
+import { default as compact } from './compact';
+import { default as concat } from './concat';
+import { default as difference } from './difference';
+import { default as differenceBy } from './differenceBy';
+import { default as differenceWith } from './differenceWith';
+import { default as drop } from './drop';
+import { default as dropRight } from './dropRight';
+import { default as dropRightWhile } from './dropRightWhile';
+import { default as dropWhile } from './dropWhile';
+import { default as fill } from './fill';
+import { default as findIndex } from './findIndex';
+import { default as findLastIndex } from './findLastIndex';
+import { default as first } from './first';
+import { default as flatten } from './flatten';
+import { default as flattenDeep } from './flattenDeep';
+import { default as flattenDepth } from './flattenDepth';
+import { default as fromPairs } from './fromPairs';
+import { default as head } from './head';
+import { default as indexOf } from './indexOf';
+import { default as initial } from './initial';
+import { default as intersection } from './intersection';
+import { default as intersectionBy } from './intersectionBy';
+import { default as intersectionWith } from './intersectionWith';
+import { default as join } from './join';
+import { default as last } from './last';
+import { default as lastIndexOf } from './lastIndexOf';
+import { default as nth } from './nth';
+import { default as pull } from './pull';
+import { default as pullAll } from './pullAll';
+import { default as pullAllBy } from './pullAllBy';
+import { default as pullAllWith } from './pullAllWith';
+import { default as pullAt } from './pullAt';
+import { default as remove } from './remove';
+import { default as reverse } from './reverse';
+import { default as slice } from './slice';
+import { default as sortedIndex } from './sortedIndex';
+import { default as sortedIndexBy } from './sortedIndexBy';
+import { default as sortedIndexOf } from './sortedIndexOf';
+import { default as sortedLastIndex } from './sortedLastIndex';
+import { default as sortedLastIndexBy } from './sortedLastIndexBy';
+import { default as sortedLastIndexOf } from './sortedLastIndexOf';
+import { default as sortedUniq } from './sortedUniq';
+import { default as sortedUniqBy } from './sortedUniqBy';
+import { default as tail } from './tail';
+import { default as take } from './take';
+import { default as takeRight } from './takeRight';
+import { default as takeRightWhile } from './takeRightWhile';
+import { default as takeWhile } from './takeWhile';
+import { default as union } from './union';
+import { default as unionBy } from './unionBy';
+import { default as unionWith } from './unionWith';
+import { default as uniq } from './uniq';
+import { default as uniqBy } from './uniqBy';
+import { default as uniqWith } from './uniqWith';
+import { default as unzip } from './unzip';
+import { default as unzipWith } from './unzipWith';
+import { default as without } from './without';
+import { default as xor } from './xor';
+import { default as xorBy } from './xorBy';
+import { default as xorWith } from './xorWith';
+import { default as zip } from './zip';
+import { default as zipObject } from './zipObject';
+import { default as zipObjectDeep } from './zipObjectDeep';
+import { default as zipWith } from './zipWith';
+export { default } from './array.default';

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

@@ -0,0 +1,133 @@
+import { default as chunk } from './chunk';
+import { default as compact } from './compact';
+import { default as concat } from './concat';
+import { default as difference } from './difference';
+import { default as differenceBy } from './differenceBy';
+import { default as differenceWith } from './differenceWith';
+import { default as drop } from './drop';
+import { default as dropRight } from './dropRight';
+import { default as dropRightWhile } from './dropRightWhile';
+import { default as dropWhile } from './dropWhile';
+import { default as fill } from './fill';
+import { default as findIndex } from './findIndex';
+import { default as findLastIndex } from './findLastIndex';
+import { default as first } from './first';
+import { default as flatten } from './flatten';
+import { default as flattenDeep } from './flattenDeep';
+import { default as flattenDepth } from './flattenDepth';
+import { default as fromPairs } from './fromPairs';
+import { default as head } from './head';
+import { default as indexOf } from './indexOf';
+import { default as initial } from './initial';
+import { default as intersection } from './intersection';
+import { default as intersectionBy } from './intersectionBy';
+import { default as intersectionWith } from './intersectionWith';
+import { default as join } from './join';
+import { default as last } from './last';
+import { default as lastIndexOf } from './lastIndexOf';
+import { default as nth } from './nth';
+import { default as pull } from './pull';
+import { default as pullAll } from './pullAll';
+import { default as pullAllBy } from './pullAllBy';
+import { default as pullAllWith } from './pullAllWith';
+import { default as pullAt } from './pullAt';
+import { default as remove } from './remove';
+import { default as reverse } from './reverse';
+import { default as slice } from './slice';
+import { default as sortedIndex } from './sortedIndex';
+import { default as sortedIndexBy } from './sortedIndexBy';
+import { default as sortedIndexOf } from './sortedIndexOf';
+import { default as sortedLastIndex } from './sortedLastIndex';
+import { default as sortedLastIndexBy } from './sortedLastIndexBy';
+import { default as sortedLastIndexOf } from './sortedLastIndexOf';
+import { default as sortedUniq } from './sortedUniq';
+import { default as sortedUniqBy } from './sortedUniqBy';
+import { default as tail } from './tail';
+import { default as take } from './take';
+import { default as takeRight } from './takeRight';
+import { default as takeRightWhile } from './takeRightWhile';
+import { default as takeWhile } from './takeWhile';
+import { default as union } from './union';
+import { default as unionBy } from './unionBy';
+import { default as unionWith } from './unionWith';
+import { default as uniq } from './uniq';
+import { default as uniqBy } from './uniqBy';
+import { default as uniqWith } from './uniqWith';
+import { default as unzip } from './unzip';
+import { default as unzipWith } from './unzipWith';
+import { default as without } from './without';
+import { default as xor } from './xor';
+import { default as xorBy } from './xorBy';
+import { default as xorWith } from './xorWith';
+import { default as zip } from './zip';
+import { default as zipObject } from './zipObject';
+import { default as zipObjectDeep } from './zipObjectDeep';
+import { default as zipWith } from './zipWith';
+declare const defaultExport: {
+    chunk: typeof chunk;
+    compact: typeof compact;
+    concat: typeof concat;
+    difference: typeof difference;
+    differenceBy: typeof differenceBy;
+    differenceWith: typeof differenceWith;
+    drop: typeof drop;
+    dropRight: typeof dropRight;
+    dropRightWhile: typeof dropRightWhile;
+    dropWhile: typeof dropWhile;
+    fill: typeof fill;
+    findIndex: typeof findIndex;
+    findLastIndex: typeof findLastIndex;
+    first: typeof first;
+    flatten: typeof flatten;
+    flattenDeep: typeof flattenDeep;
+    flattenDepth: typeof flattenDepth;
+    fromPairs: typeof fromPairs;
+    head: typeof head;
+    indexOf: typeof indexOf;
+    initial: typeof initial;
+    intersection: typeof intersection;
+    intersectionBy: typeof intersectionBy;
+    intersectionWith: typeof intersectionWith;
+    join: typeof join;
+    last: typeof last;
+    lastIndexOf: typeof lastIndexOf;
+    nth: typeof nth;
+    pull: typeof pull;
+    pullAll: typeof pullAll;
+    pullAllBy: typeof pullAllBy;
+    pullAllWith: typeof pullAllWith;
+    pullAt: typeof pullAt;
+    remove: typeof remove;
+    reverse: typeof reverse;
+    slice: typeof slice;
+    sortedIndex: typeof sortedIndex;
+    sortedIndexBy: typeof sortedIndexBy;
+    sortedIndexOf: typeof sortedIndexOf;
+    sortedLastIndex: typeof sortedLastIndex;
+    sortedLastIndexBy: typeof sortedLastIndexBy;
+    sortedLastIndexOf: typeof sortedLastIndexOf;
+    sortedUniq: typeof sortedUniq;
+    sortedUniqBy: typeof sortedUniqBy;
+    tail: typeof tail;
+    take: typeof take;
+    takeRight: typeof takeRight;
+    takeRightWhile: typeof takeRightWhile;
+    takeWhile: typeof takeWhile;
+    union: typeof union;
+    unionBy: typeof unionBy;
+    unionWith: typeof unionWith;
+    uniq: typeof uniq;
+    uniqBy: typeof uniqBy;
+    uniqWith: typeof uniqWith;
+    unzip: typeof unzip;
+    unzipWith: typeof unzipWith;
+    without: typeof without;
+    xor: typeof xor;
+    xorBy: typeof xorBy;
+    xorWith: typeof xorWith;
+    zip: typeof zip;
+    zipObject: typeof zipObject;
+    zipObjectDeep: typeof zipObjectDeep;
+    zipWith: typeof zipWith;
+};
+export default defaultExport;

package/types/lodash/ary.d.ts

@@ -0,0 +1,2 @@
+import { ary } from 'lodash';
+export default ary;

package/types/lodash/assign.d.ts

@@ -0,0 +1,2 @@
+import { assign } from 'lodash';
+export default assign;

package/types/lodash/assignIn.d.ts

@@ -0,0 +1,2 @@
+import { assignIn } from 'lodash';
+export default assignIn;

package/types/lodash/assignInWith.d.ts

@@ -0,0 +1,2 @@
+import { assignInWith } from 'lodash';
+export default assignInWith;

package/types/lodash/assignWith.d.ts

@@ -0,0 +1,2 @@
+import { assignWith } from 'lodash';
+export default assignWith;

package/types/lodash/at.d.ts

@@ -0,0 +1,2 @@
+import { at } from 'lodash';
+export default at;

package/types/lodash/attempt.d.ts

@@ -0,0 +1,2 @@
+import { attempt } from 'lodash';
+export default attempt;

package/types/lodash/before.d.ts

@@ -0,0 +1,2 @@
+import { before } from 'lodash';
+export default before;

package/types/lodash/bind.d.ts

@@ -0,0 +1,2 @@
+import { bind } from 'lodash';
+export default bind;

package/types/lodash/bindAll.d.ts

@@ -0,0 +1,2 @@
+import { bindAll } from 'lodash';
+export default bindAll;

package/types/lodash/bindKey.d.ts

@@ -0,0 +1,2 @@
+import { bindKey } from 'lodash';
+export default bindKey;

package/types/lodash/camelCase.d.ts

@@ -0,0 +1,2 @@
+import { camelCase } from 'lodash';
+export default camelCase;

package/types/lodash/capitalize.d.ts

@@ -0,0 +1,2 @@
+import { capitalize } from 'lodash';
+export default capitalize;

package/types/lodash/castArray.d.ts

@@ -0,0 +1,2 @@
+import { castArray } from 'lodash';
+export default castArray;

package/types/lodash/ceil.d.ts

@@ -0,0 +1,2 @@
+import { ceil } from 'lodash';
+export default ceil;

package/types/lodash/chain.d.ts

@@ -0,0 +1,2 @@
+import { chain } from 'lodash';
+export default chain;

package/types/lodash/chunk.d.ts

@@ -0,0 +1,2 @@
+import { chunk } from 'lodash';
+export default chunk;

package/types/lodash/clamp.d.ts

@@ -1,2 +1,2 @@
-declare const clamp: (a: number, min: number, max: number) => number;
+import { clamp } from 'lodash';
 export default clamp;

package/types/lodash/clone.d.ts

@@ -1,2 +1,2 @@
-declare const clone: (obj: any) => any;
+import { clone } from 'lodash';
 export default clone;

package/types/lodash/cloneDeep.d.ts

@@ -0,0 +1,2 @@
+import { cloneDeep } from 'lodash';
+export default cloneDeep;

package/types/lodash/cloneDeepWith.d.ts

@@ -0,0 +1,2 @@
+import { cloneDeepWith } from 'lodash';
+export default cloneDeepWith;

package/types/lodash/cloneWith.d.ts

@@ -0,0 +1,2 @@
+import { cloneWith } from 'lodash';
+export default cloneWith;

package/types/lodash/collection.d.ts

@@ -0,0 +1,29 @@
+import { default as countBy } from './countBy';
+import { default as each } from './each';
+import { default as eachRight } from './eachRight';
+import { default as every } from './every';
+import { default as filter } from './filter';
+import { default as find } from './find';
+import { default as findLast } from './findLast';
+import { default as flatMap } from './flatMap';
+import { default as flatMapDeep } from './flatMapDeep';
+import { default as flatMapDepth } from './flatMapDepth';
+import { default as forEach } from './forEach';
+import { default as forEachRight } from './forEachRight';
+import { default as groupBy } from './groupBy';
+import { default as includes } from './includes';
+import { default as invokeMap } from './invokeMap';
+import { default as keyBy } from './keyBy';
+import { default as map } from './map';
+import { default as orderBy } from './orderBy';
+import { default as partition } from './partition';
+import { default as reduce } from './reduce';
+import { default as reduceRight } from './reduceRight';
+import { default as reject } from './reject';
+import { default as sample } from './sample';
+import { default as sampleSize } from './sampleSize';
+import { default as shuffle } from './shuffle';
+import { default as size } from './size';
+import { default as some } from './some';
+import { default as sortBy } from './sortBy';
+export { default } from './collection.default';

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

@@ -0,0 +1,59 @@
+import { default as countBy } from './countBy';
+import { default as each } from './each';
+import { default as eachRight } from './eachRight';
+import { default as every } from './every';
+import { default as filter } from './filter';
+import { default as find } from './find';
+import { default as findLast } from './findLast';
+import { default as flatMap } from './flatMap';
+import { default as flatMapDeep } from './flatMapDeep';
+import { default as flatMapDepth } from './flatMapDepth';
+import { default as forEach } from './forEach';
+import { default as forEachRight } from './forEachRight';
+import { default as groupBy } from './groupBy';
+import { default as includes } from './includes';
+import { default as invokeMap } from './invokeMap';
+import { default as keyBy } from './keyBy';
+import { default as map } from './map';
+import { default as orderBy } from './orderBy';
+import { default as partition } from './partition';
+import { default as reduce } from './reduce';
+import { default as reduceRight } from './reduceRight';
+import { default as reject } from './reject';
+import { default as sample } from './sample';
+import { default as sampleSize } from './sampleSize';
+import { default as shuffle } from './shuffle';
+import { default as size } from './size';
+import { default as some } from './some';
+import { default as sortBy } from './sortBy';
+declare const defaultExport: {
+    countBy: typeof countBy;
+    each: typeof each;
+    eachRight: typeof eachRight;
+    every: typeof every;
+    filter: typeof filter;
+    find: typeof find;
+    findLast: typeof findLast;
+    flatMap: typeof flatMap;
+    flatMapDeep: typeof flatMapDeep;
+    flatMapDepth: typeof flatMapDepth;
+    forEach: typeof forEach;
+    forEachRight: typeof forEachRight;
+    groupBy: typeof groupBy;
+    includes: typeof includes;
+    invokeMap: typeof invokeMap;
+    keyBy: typeof keyBy;
+    map: typeof map;
+    orderBy: typeof orderBy;
+    partition: typeof partition;
+    reduce: typeof reduce;
+    reduceRight: typeof reduceRight;
+    reject: typeof reject;
+    sample: typeof sample;
+    sampleSize: typeof sampleSize;
+    shuffle: typeof shuffle;
+    size: typeof size;
+    some: typeof some;
+    sortBy: typeof sortBy;
+};
+export default defaultExport;

package/types/lodash/commit.d.ts

@@ -0,0 +1,28 @@
+export default wrapperCommit;
+/**
+ * Executes the chain sequence and returns the wrapped result.
+ *
+ * @name commit
+ * @memberOf _
+ * @since 3.2.0
+ * @category Seq
+ * @returns {Object} Returns the new `lodash` wrapper instance.
+ * @example
+ *
+ * var array = [1, 2];
+ * var wrapped = _(array).push(3);
+ *
+ * console.log(array);
+ * // => [1, 2]
+ *
+ * wrapped = wrapped.commit();
+ * console.log(array);
+ * // => [1, 2, 3]
+ *
+ * wrapped.last();
+ * // => 3
+ *
+ * console.log(array);
+ * // => [1, 2, 3]
+ */
+declare function wrapperCommit(): Object;

package/types/lodash/compact.d.ts

@@ -0,0 +1,2 @@
+import { compact } from 'lodash';
+export default compact;

package/types/lodash/concat.d.ts

@@ -0,0 +1,2 @@
+import { concat } from 'lodash';
+export default concat;

package/types/lodash/cond.d.ts

@@ -0,0 +1,2 @@
+import { cond } from 'lodash';
+export default cond;

package/types/lodash/conforms.d.ts

@@ -0,0 +1,2 @@
+import { conforms } from 'lodash';
+export default conforms;

package/types/lodash/conformsTo.d.ts

@@ -0,0 +1,2 @@
+import { conformsTo } from 'lodash';
+export default conformsTo;

package/types/lodash/constant.d.ts

@@ -0,0 +1,2 @@
+import { constant } from 'lodash';
+export default constant;

package/types/lodash/countBy.d.ts

@@ -0,0 +1,2 @@
+import { countBy } from 'lodash';
+export default countBy;

package/types/lodash/create.d.ts

@@ -0,0 +1,2 @@
+import { create } from 'lodash';
+export default create;

package/types/lodash/curry.d.ts

@@ -0,0 +1,2 @@
+import { curry } from 'lodash';
+export default curry;

package/types/lodash/curryRight.d.ts

@@ -0,0 +1,2 @@
+import { curryRight } from 'lodash';
+export default curryRight;

package/types/lodash/date.d.ts

@@ -0,0 +1,2 @@
+import { default as now } from './now';
+export { default } from './date.default';

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

@@ -0,0 +1,5 @@
+import { default as now } from './now';
+declare const defaultExport: {
+    now: typeof now;
+};
+export default defaultExport;

package/types/lodash/debounce.d.ts

@@ -1,2 +1,3 @@
-declare function debounce(func: Function, wait?: number, immediate?: boolean): () => void;
+import { debounce, DebouncedFunc, DebounceSettings } from 'lodash';
+export { DebouncedFunc, DebounceSettings };
 export default debounce;

package/types/lodash/deburr.d.ts

@@ -0,0 +1,2 @@
+import { deburr } from 'lodash';
+export default deburr;

package/types/lodash/defaultTo.d.ts

@@ -0,0 +1,2 @@
+import { defaultTo } from 'lodash';
+export default defaultTo;

package/types/lodash/defaults.d.ts

@@ -0,0 +1,2 @@
+import { defaults } from 'lodash';
+export default defaults;

package/types/lodash/defaultsDeep.d.ts

@@ -0,0 +1,2 @@
+import { defaultsDeep } from 'lodash';
+export default defaultsDeep;

package/types/lodash/defer.d.ts

@@ -0,0 +1,2 @@
+import { defer } from 'lodash';
+export default defer;

package/types/lodash/delay.d.ts

@@ -0,0 +1,2 @@
+import { delay } from 'lodash';
+export default delay;

package/types/lodash/difference.d.ts

@@ -1,11 +1,2 @@
-/**
- * Flattens `array` a single level deep.
- *
- * @param {Array} arr The array to inspect.
- * @param {Array} values The values to exclude.
- * @return {Array} Returns the new array of filtered values.
- * @example
- * difference([2, 1], [2, 3]);  // => [1]
- */
-declare const difference: <T>(arr: T[], values?: T[]) => T[];
+import { difference } from 'lodash';
 export default difference;

package/types/lodash/differenceBy.d.ts

@@ -0,0 +1,2 @@
+import { differenceBy } from 'lodash';
+export default differenceBy;

package/types/lodash/differenceWith.d.ts

@@ -0,0 +1,2 @@
+import { differenceWith } from 'lodash';
+export default differenceWith;

package/types/lodash/divide.d.ts

@@ -0,0 +1,2 @@
+import { divide } from 'lodash';
+export default divide;

package/types/lodash/drop.d.ts

@@ -0,0 +1,2 @@
+import { drop } from 'lodash';
+export default drop;

package/types/lodash/dropRight.d.ts

@@ -0,0 +1,2 @@
+import { dropRight } from 'lodash';
+export default dropRight;

package/types/lodash/dropRightWhile.d.ts

@@ -0,0 +1,2 @@
+import { dropRightWhile } from 'lodash';
+export default dropRightWhile;