rubico 2.7.6 → 2.7.7

package/x/heapUsedInLoop.d.ts

@@ -1,53 +0,0 @@
-export = heapUsedInLoop;
-/**
- * @name heapUsedInLoop
- *
- * @catchphrase
- * max and avg heap used in loop
- *
- * @synopsis
- * heapUsedInLoop(
- *   desc string,
- *   loopCount number,
- *   func (loop number)=>any
- * ) -> ()
- *
- * @description
- * **heapUsedInLoop** is a memory usage measurement function. Supply `description`, `loopCount`, and a function `func` for that function to be run `loopCount` times, finally logging average and max heap used per loop in terms of megabytes MiB.
- *
- * ```javascript
- * heapUsedInLoop('my-description', 1e5, function () {
- *   return 1 + 1
- * }) /*
- * 0 5.88 MiB
- * 1 5.92 MiB
- * ...
- * 99997 7.34 MiB
- * 99998 7.34 MiB
- * 99999 7.35 MiB
- * my-description: 1e+5: {
- *   "max": "7.15 MiB",
- *   "avg": "5.50 MiB"
- * }
- * ```
- *
- * @node-only
- */
-declare function heapUsedInLoop(desc: any, loopCount: any, func: any): void;
-declare namespace heapUsedInLoop {
-    function skip(): void;
-    /**
-     * @name heapUsedInLoop.async
-     *
-     * @synopsis
-     * heapUsedInLoop.async(
-     *   desc string,
-     *   loopCount number,
-     *   func (loop number)=>Promise|any
-     * ) -> ()
-     */
-    function async(desc: any, loopCount: any, func: any): Promise<void>;
-    namespace async {
-        function skip(): void;
-    }
-}

package/x/identity.d.ts

@@ -1,21 +0,0 @@
-export = identity;
-/**
- * @name identity
- *
- * @synopsis
- * ```coffeescript [specscript]
- * identity(value any) -> value
- * ```
- *
- * @description
- * Pass a value and receive the same value back.
- *
- * ```javascript [playground]
- * import identity from 'https://unpkg.com/rubico/dist/x/identity.es.js'
- *
- * console.log(
- *   identity(1),
- * ) // 1
- * ```
- */
-declare function identity(value: any): any;

package/x/includes.d.ts

@@ -1,25 +0,0 @@
-export = includes;
-/**
- * @name includes
- *
- * @synopsis
- * ```coffeescript [specscript]
- * includes(value any)(container Array|String|Object) -> boolean
- * ```
- *
- * @description
- * Check if a collection includes another value by [SameValueZero](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero).
- *
- * ```javascript [playground]
- * import includes from 'https://unpkg.com/rubico/dist/x/includes.es.js'
- *
- * console.log(
- *   includes(5)([1, 2, 3, 4, 5])
- * ) // true
- *
- * console.log(
- *   includes(5)([1, 2, 3])
- * ) // false
- * ```
- */
-declare function includes(value: any): (container: any) => any;

package/x/index.d.ts

@@ -1,34 +0,0 @@
-import append = require("./append");
-import callProp = require("./callProp");
-import defaultsDeep = require("./defaultsDeep");
-import differenceWith = require("./differenceWith");
-import filterOut = require("./filterOut");
-import find = require("./find");
-import findIndex = require("./findIndex");
-import first = require("./first");
-import flatten = require("./flatten");
-import groupBy = require("./groupBy");
-import has = require("./has");
-import identity = require("./identity");
-import includes = require("./includes");
-import isDeepEqual = require("./isDeepEqual");
-import isEmpty = require("./isEmpty");
-import isEqual = require("./isEqual");
-import isFunction = require("./isFunction");
-import isObject = require("../_internal/isObject");
-import isString = require("./isString");
-import keys = require("./keys");
-import last = require("./last");
-import maxBy = require("./maxBy");
-import noop = require("./noop");
-import pluck = require("./pluck");
-import prepend = require("./prepend");
-import size = require("./size");
-import trace = require("./trace");
-import unionWith = require("./unionWith");
-import uniq = require("./uniq");
-import unless = require("./unless");
-import values = require("./values");
-import when = require("./when");
-import isIn = require("./isIn");
-export { append, callProp, defaultsDeep, differenceWith, filterOut, find, findIndex, first, flatten, groupBy, has, identity, includes, isDeepEqual, isEmpty, isEqual, isFunction, isObject, isString, keys, last, maxBy, noop, pluck, prepend, size, trace, unionWith, uniq, unless, values, when, isIn };

package/x/is.d.ts

@@ -1,2 +0,0 @@
-export = is;
-declare function is(constructor: any): (x: any) => boolean;

package/x/isDeepEqual.d.ts

@@ -1,42 +0,0 @@
-export = isDeepEqual;
-/**
- * @name isDeepEqual
- *
- * @synopsis
- * ```coffeescript [specscript]
- * Nested<T> = Array<Array<T>|Object<T>|Iterable<T>|T>|Object<Array<T>|Object<T>|Iterable<T>|T>
- *
- * var left Nested,
- *   right Nested
- *
- * isDeepEqual(left, right) -> boolean
- * ```
- *
- * @description
- * Check two values for deep [SameValueZero](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) equality.
- *
- * ```javascript [playground]
- * import isDeepEqual from 'https://unpkg.com/rubico/dist/x/isDeepEqual.es.js'
- *
- * console.log(
- *   isDeepEqual({ a: 1, b: 2, c: [3] }, { a: 1, b: 2, c: [3] }),
- * ) // true
- *
- * console.log(
- *   isDeepEqual({ a: 1, b: 2, c: [3] }, { a: 1, b: 2, c: [5] }),
- * ) // false
- * ```
- *
- * When passed a resolver function as the left or right argument or resolvers as both arguments, returns a function that resolves the value by the resolver before performing the deep equal comparison.
- *
- * ```javascript [playground]
- * import isDeepEqual from 'https://unpkg.com/rubico/dist/x/isDeepEqual.es.js'
- *
- * const isPropADeepEqualTo123Array = isDeepEqual(object => object.a, [1, 2, 3])
- *
- * console.log(
- *   isPropADeepEqualTo123Array({ a: [1, 2, 3] }),
- * ) // true
- * ```
- */
-declare function isDeepEqual(left: any, right: any): any;

package/x/isEmpty.d.ts

@@ -1,24 +0,0 @@
-export = isEmpty;
-/**
- * @name isEmpty
- *
- * @synopsis
- * ```coffeescript [specscript]
- * isEmpty(value any) -> boolean
- * ```
- *
- * @description
- * Check if a value is empty.
- *
- * ```javascript [playground]
- * import isEmpty from 'https://unpkg.com/rubico/dist/x/isEmpty.es.js'
- *
- * console.log('', isEmpty('')) // true
- * console.log([], isEmpty([])) // true
- * console.log({}, isEmpty({})) // true
- * console.log([1, 2, 3], isEmpty([1, 2, 3])) // false
- * console.log(new Set([1, 2, 3]), isEmpty(new Set([1, 2, 3]))) // false
- * console.log({ a: 1, b: 2, c: 3 }, isEmpty({ a: 1, b: 2, c: 3 })) // false
- * ```
- */
-declare function isEmpty(value: any): boolean;

package/x/isEqual.d.ts

@@ -1,2 +0,0 @@
-export = isEqual;
-declare function isEqual(a: any, b: any): boolean;

package/x/isFunction.d.ts

@@ -1,23 +0,0 @@
-export = isFunction;
-/**
- * @name isFunction
- *
- * @synopsis
- * ```coffeescript [specscript]
- * isFunction(value any) -> boolean
- * ```
- *
- * @description
- * Determine whether a value is a function.
- *
- * ```javascript [playground]
- * import isFunction from 'https://unpkg.com/rubico/dist/x/isFunction.es.js'
- *
- * const add = (a, b) => a + b
- *
- * console.log(
- *   isFunction(add),
- * ) // true
- * ```
- */
-declare function isFunction(value: any): boolean;

package/x/isIn.d.ts

@@ -1,61 +0,0 @@
-export = isIn;
-/**
- * @name isIn
- *
- * @synopsis
- * ```coffeescript [specscript]
- * isIn(container Array|Object|String|Set|Map)(value any) -> boolean
- * ```
- *
- * @description
- * Counterpart to includes. Check if a collection includes another value.
- *
- * ```javascript [playground]
- * import isIn from 'https://unpkg.com/rubico/dist/x/isIn.es.js'
- *
- * console.log(
- *   isIn([1, 2, 3](1)
- * ) // true
- *
- * console.log(
- *   isIn([1, 2, 3](4)
- * ) // false
- *
- * console.log(
- *   isIn({ a: 1 })(1)
- * ) // true
- *
- * console.log(
- *   isIn({ a: 1 })(2)
- * ) // true
- *
- * console.log(
- *   isIn('abc')('a')
- * ) // true
- *
- * console.log(
- *   isIn('abc')('ab')
- * ) // true
- *
- * console.log(
- *   isIn('abc')('d')
- * ) // false
- *
- * console.log(
- *   isIn(new Set([1, 2, 3]))(1)
- * ) // true
- *
- * console.log(
- *   isIn(new Set([1, 2, 3]))(4)
- * ) // false
- *
- * console.log(
- *   isIn(new Map([[1, 1], [2, 2], [3, 3]]))(1)
- * ) // true
- *
- * console.log(
- *   isIn(new Map([[1, 1], [2, 2], [3, 3]]))(4)
- * ) // false
- * ```
- */
-declare function isIn(...args: any[]): any;

package/x/isObject.d.ts

@@ -1,2 +0,0 @@
-export = isObject;
-import isObject = require("../_internal/isObject");

package/x/isString.benchmarks.d.ts

@@ -1 +0,0 @@
-export {};

package/x/isString.d.ts

@@ -1,21 +0,0 @@
-export = isString;
-/**
- * @name isString
- *
- * @synopsis
- * ```coffeescript [specscript]
- * isString(value any) -> boolean
- * ```
- *
- * @description
- * Determine whether a value is a string.
- *
- * ```javascript [playground]
- * import isString from 'https://unpkg.com/rubico/dist/x/isString.es.js'
- *
- * console.log(
- *   isString('hey'),
- * ) // true
- * ```
- */
-declare function isString(value: any): boolean;

package/x/keys.d.ts

@@ -1,23 +0,0 @@
-export = keys;
-/**
- * @name keys
- *
- * @synopsis
- * ```coffeescript [specscript]
- * keys(value string|Array|Set|Map|object) -> Array<key number|string>
- * ```
- *
- * @description
- * Get an array of keys from an instance.
- *
- * ```javascript [playground]
- * import keys from 'https://unpkg.com/rubico/dist/x/keys.es.js'
- *
- * console.log(keys({ a: 1, b: 2, c: 3 })) // ['a', 'b', 'c']
- * console.log(keys(['hello', 'world'])) // [0, 1]
- * console.log(keys(new Map([['hello', 1], ['world', 2]]))) // ['hello', 'world']
- * ```
- *
- * @since 1.6.25
- */
-declare function keys(object: any): any[];

package/x/last.d.ts

@@ -1,22 +0,0 @@
-export = last;
-/**
- * @name last
- *
- * @synopsis
- * ```coffeescript [specscript]
- * var value Array|string
- *
- * last(value) -> any
- * ```
- *
- * @description
- * Get the last element of a collection
- *
- * ```javascript [playground]
- * import last from 'https://unpkg.com/rubico/dist/x/last.es.js'
- *
- * console.log(last([1, 2, 3])) // 3
- * console.log(last([])) // undefined
- * ```
- */
-declare function last(value: any): any;

package/x/maxBy.d.ts

@@ -1,41 +0,0 @@
-export = maxBy;
-/**
- * @name maxBy
- *
- * @synopsis
- * ```coffeescript [specscript]
- * maxBy(array Array, path string) -> maxElementByPath any
- *
- * maxBy(path string)(array Array) -> maxElementByPath any
- * ```
- *
- * @description
- * Finds the element that is the max by a property denoted by path.
- *
- * ```javascript [playground]
- * import maxBy from 'https://unpkg.com/rubico/dist/x/maxBy.es.js'
- *
- * const array = [{ a: 1 }, { a: 2 }, { a: 3 }]
- *
- * const maxElement = maxBy(array, 'a')
- *
- * console.log(maxElement) // { a: 3 }
- * ```
- *
- * `maxBy` composes in a lazy way.
- *
- * ```javascript [playground]
- * import maxBy from 'https://unpkg.com/rubico/dist/x/maxBy.es.js'
- *
- * const numbers = [1, 2, 3]
- *
- * const maxElement = pipe(numbers, [
- *   map(number => number ** 2),
- *   map(number => ({ a: { b: { c: number } } })),
- *   maxBy('a.b.c')
- * ])
- *
- * console.log(maxElement) // { a: { b: { c: 9 } } }
- * ```
- */
-declare function maxBy(...args: any[]): any;

package/x/noop.d.ts

@@ -1,21 +0,0 @@
-export = noop;
-/**
- * @name noop
- *
- * @synopsis
- * ```coffeescript [specscript]
- * noop() -> undefined
- * ```
- *
- * @description
- * Doesn't do anything.
- *
- * ```javascript [playground]
- * import noop from 'https://unpkg.com/rubico/dist/x/noop.es.js'
- *
- * console.log(
- *   noop(),
- * ) // undefined
- * ```
- */
-declare function noop(): void;

package/x/pluck.d.ts

@@ -1,35 +0,0 @@
-export = pluck;
-/**
- * @name pluck
- *
- * @synopsis
- * ```coffeescript [specscript]
- * pluck(path string)(array Array) -> result Array
- *
- * pluck(array Array, path string) -> result Array
- * ```
- *
- * @description
- * Creates an array of picked properties denoted by a path from another array.
- *
- * `pluck` supports three types of path patterns for nested property access.
- *
- *  * dot delimited - `'a.b.c'`
- *  * bracket notation - `'a[0].value'`
- *  * an array of keys or indices - `['a', 0, 'value']`
- *
- * ```javascript [playground]
- * import pluck from 'https://unpkg.com/rubico/dist/x/pluck.es.js'
- *
- * const users = [
- *   { name: 'John', age: 33 },
- *   { name: 'Jane', age: 51 },
- *   { name: 'Jim', age: 22 },
- * ]
- *
- * const usernames = pluck(users, 'name')
- *
- * console.log(usernames) // ['John', 'Jane', 'Jim']
- * ```
- */
-declare function pluck(...args: any[]): any;

package/x/prepend.d.ts

@@ -1,38 +0,0 @@
-export = prepend;
-/**
- * @name prepend
- *
- * @synopsis
- * ```coffeescript [specscript]
- * prepend(
- *   element string|Array,
- * )(value string|Array) -> string|array
- * ```
- *
- * @description
- * Prepend a string or an array.
- *
- * ```javascript [playground]
- * import prepend from 'https://unpkg.com/rubico/dist/x/prepend.es.js'
- *
- * const myArray = ['orange', 'apple']
- *
- * {
- *   const result = prepend(['ananas'])(myArray)
- *   console.log(result) // ['ananas', 'orange', 'apple']
- * }
- *
- * {
- *   const result = prepend('ananas')(myArray)
- *   console.log(result) // ['ananas', 'orange', 'apple']
- * }
- *
- * {
- *   const result = prepend('hello ')('world')
- *   console.log(result) // 'hello world'
- * }
- * ```
- *
- * @since 1.7.3
- */
-declare function prepend(element: any): (value: any) => string | any[];

package/x/size.d.ts

@@ -1,21 +0,0 @@
-export = size;
-/**
- * @name size
- *
- * @synopsis
- * ```coffeescript [specscript]
- * size(value any) -> number
- * ```
- *
- * @description
- * Get the count of elements in a value.
- *
- * ```javascript [playground]
- * import size from 'https://unpkg.com/rubico/dist/x/size.es.js'
- *
- * console.log(size([1, 2, 3])) // 3
- * console.log(size('hey')) // 3
- * console.log(size(new Set([1, 2, 3]))) // 3
- * ```
- */
-declare function size(value: any): any;

package/x/test.d.ts

@@ -1 +0,0 @@
-export {};

package/x/timeInLoop.d.ts

@@ -1,21 +0,0 @@
-export = timeInLoop;
-/**
- * @name timeInLoop
- *
- * @synopsis
- * timeInLoop(desc string, loopCount number, fn function) -> undefined
- *
- * @description
- * Logs the amount of time required for a function to run a certain number of times
- *
- * ```coffeescript [specscript]
- * timeInLoop('hello', 1e6, () => 'hello') // hello: 1e+6: 3.474ms
- * ```
- *
- * Reference: https://gist.github.com/funfunction/91b5876a5f562e1e352aed0fcabc3858
- */
-declare const timeInLoop: (description: any, loopCount: any, fn: any, options?: {}) => {
-    description: any;
-    loopCount: any;
-    duration: number;
-};

package/x/trace.d.ts

@@ -1,30 +0,0 @@
-export = trace;
-/**
- * @name trace
- *
- * @synopsis
- * ```coffeescript [specscript]
- * var args ...any,
- *   resolved any,
- *   resolver ...args=>resolved
- *
- * trace(...args) -> args[0]
- *
- * trace(resolver)(...args) -> resolved
- * ```
- *
- * @description
- * Log a value out to the console, returning the value. If the value is a function, treat it as a resolver.
- *
- * ```javascript [playground]
- * import trace from 'https://unpkg.com/rubico/dist/x/trace.es.js'
- *
- * pipe([
- *   trace,
- *   trace(value => value.toUpperCase()),
- * ])('hey') // hey
- *           // HEY
- * console.log('check your console')
- * ```
- */
-declare function trace(...args: any[]): any;

package/x/tracef.d.ts

@@ -1,7 +0,0 @@
-export = tracef;
-/**
- * @name tracef
- *
- * @DEPRECATED
- */
-declare function tracef(f: any): any;

package/x/unionWith.d.ts

@@ -1,31 +0,0 @@
-export = unionWith;
-/**
- * @name unionWith
- *
- * @synopsis
- * ```coffeescript [specscript]
- * var T any,
- *   arrayOfArrays Array<Array<T>>,
- *   comparator (T, T)=>Promise|boolean
- *
- * unionWith(comparator)(arrayOfArrays) -> Array<T>
- * ```
- *
- * @description
- * Create an array of unique values from an array of arrays with uniqueness determined by a comparator. The comparator is a function that returns a boolean value, `true` if two given values are distinct.
- *
- * ```javascript [playground]
- * import isDeepEqual from 'https://unpkg.com/rubico/dist/x/isDeepEqual.es.js'
- * import unionWith from 'https://unpkg.com/rubico/dist/x/unionWith.es.js'
- *
- * console.log(
- *   unionWith(isDeepEqual)([
- *     [{ a: 1 }, { b: 2 }, { a: 1 }],
- *     [{ b: 2 }, { b: 2 }, { b: 2 }],
- *   ]),
- * ) // [{ a: 1 }, { b: 2 }]
- * ```
- *
- * @TODO setUnionWith
- */
-declare function unionWith(comparator: any): (value: any) => any;

package/x/uniq.d.ts

@@ -1,24 +0,0 @@
-export = uniq;
-/**
- * @name uniq
- *
- * @synopsis
- * ```coffeescript [specscript]
- * var T any,
- *   array Array<T>
- *
- * uniq(array) -> Array
- * ```
- *
- * @description
- * Get an array of unique values from an array.
- *
- * ```javascript [playground]
- * import uniq from 'https://unpkg.com/rubico/dist/x/uniq.es.js'
- *
- * console.log(
- *   uniq([1, 2, 2, 3]),
- * ) // [1, 2, 3]
- * ```
- */
-declare function uniq(arr: any): any[];