rubico 2.2.3 → 2.3.1

package/x/index.d.ts

@@ -0,0 +1,34 @@
+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

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

package/x/isDeepEqual.d.ts

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,24 @@
+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

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

package/x/isFunction.d.ts

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,61 @@
+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

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

package/x/isString.benchmarks.d.ts

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

package/x/isString.d.ts

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,22 @@
+export = last;
+/**
+ * @name last
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * var value Array|string
+ *
+ * last(value) -> any
+ * ```
+ *
+ * @description
+ * Get the last item 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

@@ -0,0 +1,41 @@
+export = maxBy;
+/**
+ * @name maxBy
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * maxBy(array Array, path string) -> maxItemByPath any
+ *
+ * maxBy(path string)(array Array) -> maxItemByPath any
+ * ```
+ *
+ * @description
+ * Finds the item 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 maxItem = maxBy(array, 'a')
+ *
+ * console.log(maxItem) // { a: 3 }
+ * ```
+ *
+ * `maxBy` composes in a pointfree way.
+ *
+ * ```javascript [playground]
+ * import maxBy from 'https://unpkg.com/rubico/dist/x/maxBy.es.js'
+ *
+ * const numbers = [1, 2, 3]
+ *
+ * const maxItem = pipe(numbers, [
+ *   map(number => number ** 2),
+ *   map(number => ({ a: { b: { c: number } } })),
+ *   maxBy('a.b.c')
+ * ])
+ *
+ * console.log(maxItem) // { a: { b: { c: 9 } } }
+ * ```
+ */
+declare function maxBy(...args: any[]): any;

package/x/noop.d.ts

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,35 @@
+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: 'George', age: 33 },
+ *   { name: 'Jane', age: 51 },
+ *   { name: 'Jim', age: 22 },
+ * ]
+ *
+ * const usernames = pluck(users, 'name')
+ *
+ * console.log(usernames) // ['George', 'Jane', 'Jim']
+ * ```
+ */
+declare function pluck(...args: any[]): any;

package/x/prepend.d.ts

@@ -0,0 +1,38 @@
+export = prepend;
+/**
+ * @name prepend
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * prepend(
+ *   item 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(item: any): (value: any) => string | any[];

package/x/size.d.ts

@@ -0,0 +1,21 @@
+export = size;
+/**
+ * @name size
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * size(value any) -> number
+ * ```
+ *
+ * @description
+ * Get the count of items 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

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

package/x/timeInLoop.d.ts

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,30 @@
+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

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

package/x/unionWith.d.ts

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,24 @@
+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[];

package/x/unless.d.ts

@@ -0,0 +1,28 @@
+export = unless;
+/**
+ * @name unless
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * unless(
+ *   predicate any=>Promise|boolean,
+ *   func function,
+ * )(value any) -> Promise|any
+ * ```
+ *
+ * @description
+ * Execute a function and return the result unless a condition is true, otherwise return the original value.
+ *
+ * ```javascript [playground]
+ * import unless from 'https://unpkg.com/rubico/dist/x/unless.es.js'
+ *
+ * const isEven = num => num % 2 === 0
+ * const doubleIfOdd = unless(isEven, num => num * 2)
+ *
+ * console.log(doubleIfOdd(100)) // 100
+ * console.log(doubleIfOdd(101)) // 202
+ * ```
+ *
+ * @since 1.7.3
+ */
+declare function unless(predicate: any, func: any): (value: any) => any;

package/x/values.d.ts

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

package/x/when.d.ts

@@ -0,0 +1,28 @@
+export = when;
+/**
+ * @name when
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * when(
+ *   predicate any=>Promise|boolean,
+ *   func function,
+ * )(value any) -> Promise|any
+ * ```
+ *
+ * @description
+ * Execute a function and return the result when a condition is true, otherwise return the original value.
+ *
+ * ```javascript [playground]
+ * import when from 'https://unpkg.com/rubico/dist/x/when.es.js'
+ *
+ * const isEven = num => num % 2 === 0
+ * const doubleIfEven = when(isEven, num => num * 2)
+ *
+ * console.log(doubleIfEven(100)) // 200
+ * console.log(doubleIfEven(101)) // 101
+ * ```
+ *
+ * @since 1.7.1
+ */
+declare function when(predicate: any, func: any): (value: any) => any;