rubico 2.7.4 → 2.7.6

package/gte.d.ts

@@ -1,51 +0,0 @@
-export = gte;
-/**
- * @name gte
- *
- * @synopsis
- * ```coffeescript [specscript]
- * gte(leftValue Promise|any, rightValue Promise|any) -> boolean
- *
- * gte(leftValue Promise|any, right function)(...args) -> Promise|boolean
- * gte(...args, leftValue Promise|any, right function) -> Promise|boolean
- *
- * gte(left function, rightValue Promise|any)(...args) -> Promise|boolean
- * gte(...args, left function, rightValue Promise|any) -> Promise|boolean
- *
- * gte(left function, right function)(...args) -> Promise|boolean
- * gte(...args, left function, right function) -> Promise|boolean
- * ```
- *
- * @description
- * Test if a value is greater than or equal (`>=`) to another value.
- *
- * ```javascript [playground]
- * const age = 20
- *
- * const isAdultAge = gte(age, 18)
- *
- * console.log(isAdultAge) // true
- * ```
- *
- * If either of the two values are resolver functions, `gte` returns a function that resolves the values to compare from its arguments.
- *
- * ```javascript [playground]
- * const identity = value => value
- *
- * const isAtLeast100 = gte(identity, 100)
- *
- * console.log(isAtLeast100(99)) // false
- * console.log(isAtLeast100(100)) // true
- * console.log(isAtLeast100(101)) // true
- * ```
- *
- * `gte` supports a lazy API for composability.
- *
- * ```javascript [playground]
- * pipe({ value: 1 }, [
- *   gte(1, get('value')),
- *   console.log, // true
- * ])
- * ```
- */
-declare const gte: (...args: any[]) => any;

package/index.d.ts

@@ -1 +0,0 @@
-export = rubico;

package/lt.d.ts

@@ -1,49 +0,0 @@
-export = lt;
-/**
- * @name lt
- *
- * @synopsis
- * ```coffeescript [specscript]
- * lt(leftValue Promise|any, rightValue Promise|any) -> boolean
- *
- * lt(leftValue Promise|any, right function)(...args) -> Promise|boolean
- * lt(...args, leftValue Promise|any, right function) -> Promise|boolean
- *
- * lt(left function, rightValue Promise|any)(...args) -> Promise|boolean
- * lt(...args, left function, rightValue Promise|any) -> Promise|boolean
- *
- * lt(left function, right function)(...args) -> Promise|boolean
- * lt(...args, left function, right function) -> Promise|boolean
- * ```
- *
- * @description
- * Test if a value is less than (`<`) another value.
- *
- * ```javascript [playground]
- * console.log(lt(1, 3)) // true
- * console.log(lt(3, 3)) // false
- * console.log(lt(4, 3)) // false
- * ```
- *
- * If either of the two values are resolver functions, `lt` returns a function that resolves the values to compare from its arguments.
- *
- * ```javascript [playground]
- * const identity = value => value
- *
- * const isLessThan3 = lt(identity, 3)
- *
- * console.log(isLessThan3(1)) // true
- * console.log(isLessThan3(3)) // false
- * console.log(isLessThan3(5)) // false
- * ```
- *
- * `lt` supports a lazy API for composability.
- *
- * ```javascript [playground]
- * pipe({ value: 1 }, [
- *   lt(0, get('value')),
- *   console.log, // true
- * ])
- * ```
- */
-declare const lt: (...args: any[]) => any;

package/lte.d.ts

@@ -1,49 +0,0 @@
-export = lte;
-/**
- * @name lte
- *
- * @synopsis
- * ```coffeescript [specscript]
- * lte(leftValue Promise|any, rightValue Promise|any) -> boolean
- *
- * lte(leftValue Promise|any, right function)(...args) -> Promise|boolean
- * lte(...args, leftValue Promise|any, right function) -> Promise|boolean
- *
- * lte(left function, rightValue Promise|any)(...args) -> Promise|boolean
- * lte(...args, left function, rightValue Promise|any) -> Promise|boolean
- *
- * lte(left function, right function)(...args) -> Promise|boolean
- * lte(...args, left function, right function) -> Promise|boolean
- * ```
- *
- * @description
- * Test if a value is less than or equal (`<=`) to another value.
- *
- * ```javascript [playground]
- * console.log(lte(1, 3)) // true
- * console.log(lte(3, 3)) // true
- * console.log(lte(4, 3)) // false
- * ```
- *
- * If either of the two values are resolver functions, `lte` returns a function that resolves the values to compare from its arguments.
- *
- * ```javascript [playground]
- * const identity = value => value
- *
- * const isLessThanOrEqualTo3 = lte(identity, 3)
- *
- * console.log(isLessThanOrEqualTo3(1), true)
- * console.log(isLessThanOrEqualTo3(3), true)
- * console.log(isLessThanOrEqualTo3(5), false)
- * ```
- *
- * `lte` supports a lazy API for composability.
- *
- * ```javascript [playground]
- * pipe({ value: 1 }, [
- *   lte(1, get('value')),
- *   console.log, // true
- * ])
- * ```
- */
-declare const lte: (...args: any[]) => any;

package/map.d.ts

@@ -1,246 +0,0 @@
-export = map;
-/**
- * @name map
- *
- * @synopsis
- * ```coffeescript [specscript]
- * type Mappable = Array|Object|Set|Map|Iterator|AsyncIterator
- *
- * type Mapper = (
- *   value any,
- *   indexOrKey number|string,
- *   collection Mappable
- * )=>(mappedElement Promise|any)
- *
- * map(value Mappable, mapper Mapper) -> result Promise|Mappable
- * map(mapper Mapper)(value Mappable) -> result Promise|Mappable
- * ```
- *
- * @description
- * Applies a synchronous or asynchronous mapper function concurrently to each element of a collection, returning the results in a new collection of the same type. If order is implied by the collection, it is maintained in the result. `map` accepts the following collections:
- *
- *  * `Array`
- *  * `Object`
- *  * `Set`
- *  * `Map`
- *  * `Iterator`/`Generator`
- *  * `AsyncIterator`/`AsyncGenerator`
- *
- * With arrays (type `Array`), `map` applies the mapper function to each element of the array, returning the transformed results in a new array ordered the same as the original array.
- *
- * ```javascript [playground]
- * const square = number => number ** 2
- *
- * const array = [1, 2, 3, 4, 5]
- *
- * console.log(
- *   map(array, square)
- * ) // [1, 4, 9, 16, 25]
- *
- * console.log(
- *   map(square)(array)
- * ) // [1, 4, 9, 16, 25]
- * ```
- *
- * With objects (type `Object`), `map` applies the mapper function to each value of the object, returning the transformed results as values in a new object ordered by the keys of the original object
- *
- * ```javascript [playground]
- * const square = number => number ** 2
- *
- * const obj = { a: 1, b: 2, c: 3, d: 4, e: 5 }
- *
- * console.log(
- *   map(square)(obj)
- * ) // { a: 1, b: 4, c: 9, d: 16, e: 25 }
- *
- * console.log(
- *   map(obj, square)
- * ) // { a: 1, b: 4, c: 9, d: 16, e: 25 }
- * ```
- *
- * With sets (type `Set`), `map` applies the mapper function to each value of the set, returning the transformed results unordered in a new set.
- *
- * ```javascript [playground]
- * const square = number => number ** 2
- *
- * const set = new Set([1, 2, 3, 4, 5])
- *
- * console.log(
- *   map(set, square)
- * ) // [1, 4, 9, 16, 25]
- *
- * console.log(
- *   map(square)(set)
- * ) // [1, 4, 9, 16, 25]
- * ```
- *
- * With maps (type `Map`), `map` applies the mapper function to each value of the map, returning the results at the same keys in a new map. The entries of the resulting map are in the same order as those of the original map
- *
- * ```javascript [playground]
- * const square = number => number ** 2
- *
- * const m = new Map([['a', 1], ['b', 2], ['c', 3], ['d', 4], ['e', 5]])
- *
- * console.log(
- *   map(square)(m)
- * ) // Map { 'a' => 1, 'b' => 4, 'c' => 9, 'd' => 16, 'e' => 25 }
- *
- * console.log(
- *   map(m, square)
- * ) // Map { 'a' => 1, 'b' => 4, 'c' => 9, 'd' => 16, 'e' => 25 }
- * ```
- *
- * With iterators (type `Iterator`) or generators (type `Generator`), `map` applies the mapper function lazily to each value of the iterator/generator, creating a new iterator with transformed iterations.
- *
- * ```javascript [playground]
- * const capitalize = string => string.toUpperCase()
- *
- * const abcGeneratorFunc = function* () {
- *   yield 'a'; yield 'b'; yield 'c'
- * }
- *
- * const abcGenerator = abcGeneratorFunc()
- * const ABCGenerator = map(abcGeneratorFunc(), capitalize)
- * const ABCGenerator2 = map(capitalize)(abcGeneratorFunc())
- *
- * console.log([...abcGenerator]) // ['a', 'b', 'c']
- *
- * console.log([...ABCGenerator]) // ['A', 'B', 'C']
- *
- * console.log([...ABCGenerator2]) // ['A', 'B', 'C']
- * ```
- *
- * With asyncIterators (type `AsyncIterator`, or `AsyncGenerator`), `map` applies the mapper function lazily to each value of the asyncIterator, creating a new asyncIterator with transformed iterations
- *
- * ```javascript [playground]
- * const capitalize = string => string.toUpperCase()
- *
- * const abcAsyncGeneratorFunc = async function* () {
- *   yield 'a'; yield 'b'; yield 'c'
- * }
- *
- * const abcAsyncGenerator = abcAsyncGeneratorFunc()
- * const ABCGenerator = map(abcAsyncGeneratorFunc(), capitalize)
- * const ABCGenerator2 = map(capitalize)(abcAsyncGeneratorFunc())
- *
- * ;(async function () {
- *   for await (const letter of abcAsyncGenerator) {
- *     console.log(letter)
- *     // a
- *     // b
- *     // c
- *   }
- *
- *   for await (const letter of ABCGenerator) {
- *     console.log(letter)
- *     // A
- *     // B
- *     // C
- *   }
- *
- *   for await (const letter of ABCGenerator2) {
- *     console.log(letter)
- *     // A
- *     // B
- *     // C
- *   }
- * })()
- * ```
- *
- * @execution concurrent
- *
- * @TODO streamMap
- */
-declare function map(...args: any[]): any;
-declare namespace map {
-    /**
-     * @name map.entries
-     *
-     * @synopsis
-     * ```coffeescript [specscript]
-     * map.entries(
-     *   mapper ([key any, value any])=>Promise|[any, any],
-     * )(value Map|Object) -> Promise|Map|Object
-     * ```
-     *
-     * @description
-     * `map` over the entries rather than the values of a collection. Accepts collections of type `Map` or `Object`.
-     *
-     * ```javascript [playground]
-     * const upperCaseKeysAndSquareValues =
-     *   map.entries(([key, value]) => [key.toUpperCase(), value ** 2])
-     *
-     * console.log(upperCaseKeysAndSquareValues({ a: 1, b: 2, c: 3 }))
-     * // { A: 1, B: 4, C: 9 }
-     *
-     * console.log(upperCaseKeysAndSquareValues(new Map([['a', 1], ['b', 2], ['c', 3]])))
-     * // Map(3) { 'A' => 1, 'B' => 4, 'C' => 9 }
-     * ```
-     *
-     * @since v1.7.0
-     */
-    function entries(mapper: any): (value: any) => any;
-    /**
-     * @name map.series
-     *
-     * @synopsis
-     * ```coffeescript [specscript]
-     * map.series(
-     *   mapperFunc (value any, index number)=>Promise|any,
-     * )(array Array) -> Promise|Array
-     * ```
-     *
-     * @description
-     * `map` with serial execution.
-     *
-     * ```javascript [playground]
-     * const delayedLog = number => new Promise(function (resolve) {
-     *   setTimeout(function () {
-     *     console.log(number)
-     *     resolve()
-     *   }, 1000)
-     * })
-     *
-     * console.log('start')
-     * map.series(delayedLog)([1, 2, 3, 4, 5])
-     * ```
-     *
-     * @execution series
-     */
-    function series(mapper: any, index: number): (value: any) => any;
-    /**
-     * @name map.pool
-     *
-     * @synopsis
-     * ```coffeescript [specscript]
-     * map.pool(
-     *   maxConcurrency number,
-     *   mapper (value any)=>Promise|any,
-     * )(array Array) -> result Promise|Array
-     * ```
-     *
-     * @description
-     * `map` that specifies the maximum concurrency (number of ongoing promises at any time) of the execution. Only works for arrays.
-     *
-     * ```javascript [playground]
-     * const ids = [1, 2, 3, 4, 5]
-     *
-     * const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
-     *
-     * const delayedIdentity = async value => {
-     *   await sleep(1000)
-     *   return value
-     * }
-     *
-     * map.pool(2, pipe([
-     *   delayedIdentity,
-     *   console.log,
-     * ]))(ids)
-     * ```
-     *
-     * @TODO objectMapPool
-     *
-     * @execution concurrent
-     */
-    function pool(concurrencyLimit: any, mapper: any): (value: any) => any[] | Promise<any>;
-}

package/not.d.ts

@@ -1,34 +0,0 @@
-export = not;
-/**
- * @name not
- *
- * @synopsis
- * ```coffeescript [specscript]
- * not(value boolean) -> negated boolean
- *
- * not(...args, predicate function) -> negated boolean
- *
- * not(predicate function)(...args) -> negated boolean
- * ```
- *
- * @description
- * Negate a value like the [logical NOT (`!`)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_NOT) operator.
- *
- * ```javascript [playground]
- * const myObj = { a: 1 }
- *
- * console.log(not('a' in myObj)) // false
- * console.log(not('b' in myObj)) // true
- * ```
- *
- * If provided a predicate function, `not` returns a logically inverted predicate that returns true everywhere the original predicate would have returned false.
- *
- * ```javascript [playground]
- * const isOdd = number => number % 2 == 1
- *
- * console.log(
- *   not(isOdd)(3),
- * ) // false
- * ```
- */
-declare function not(...args: any[]): any;

package/omit.d.ts

@@ -1,50 +0,0 @@
-export = omit;
-/**
- * @name omit
- *
- * @synopsis
- * ```coffeescript [specscript]
- * omit(paths Array<string>)(source Object) -> omitted Object
- *
- * omit(source Object, paths Array<string>) -> omitted Object
- * ```
- *
- * @description
- * Create a new object by excluding provided paths on a source object.
- *
- * ```javascript [playground]
- * console.log(
- *   omit({ _id: '1', name: 'John' }, ['_id']),
- * ) // { name: 'John' }
- * ```
- *
- * `omit` 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]
- * console.log(
- *   omit(['a.b.d'])({
- *     a: {
- *       b: {
- *         c: 'hello',
- *         d: 'goodbye',
- *       },
- *     },
- *   }),
- * ) // { a: { b: { c: 'hello' } } }
- * ```
- *
- * Compose `omit` inside a `pipe` with its lazy API
- *
- * ```javascript [playground]
- * pipe({ a: 1, b: 2, c: 3 }, [
- *   map(number => number ** 2),
- *   omit(['a', 'b']),
- *   console.log, // { c: 9 }
- * ])
- * ```
- */
-declare function omit(arg0: any, arg1: any): any;

package/or.d.ts

@@ -1,43 +0,0 @@
-export = or;
-/**
- * @name or
- *
- * @synopsis
- * ```coffeescript [specscript]
- * or(values Array<boolean>) -> result boolean
- *
- * or(...args, predicatesOrValues Array<function|boolean>) -> Promise|boolean
- *
- * or(predicatesOrValues Array<function|boolean>)(...args) -> Promise|boolean
- * ```
- *
- * @description
- * Tests an array of boolean values, returning true if any boolean values are truthy.
- *
- * ```javascript [playground]
- * const oneIsLessThanZero = 1 < 0
- * const oneIsGreaterThanTwo = 1 > 2
- * const threeIsNotEqualToThree = 3 !== 3
- *
- * console.log(
- *   or([oneIsLessThanZero, oneIsGreaterThanTwo, threeIsNotEqualToThree]),
- * ) // false
- * ```
- *
- * If any values in the array are synchronous or asynchronous predicate functions, `or` takes another argument to test concurrently against the predicate functions, returning true if any array values or resolved values from the predicates are truthy.
- *
- * ```javascript [playground]
- * const isOdd = number => number % 2 == 1
- *
- * const isEven = number => number % 2 == 0
- *
- * console.log(
- *   or([isOdd, isEven])(0),
- * ) // true
- * ```
- *
- * @execution series
- *
- * @note ...args slows down here by an order of magnitude
- */
-declare function or(...args: any[]): any;

package/pick.d.ts

@@ -1,43 +0,0 @@
-export = pick;
-/**
- * @name pick
- *
- * @synopsis
- * ```coffeescript [specscript]
- * pick(object Object, keys Array<string>) -> result Object
- *
- * pick(keys Array<string>)(object Object) -> result Object
- * ```
- *
- * @description
- * Creates a new object from a source object by selecting provided keys. If a provided key does not exist on the source object, excludes it from the resulting object.
- *
- * ```javascript [playground]
- * console.log(
- *   pick({ goodbye: 1, world: 2 }, ['hello', 'world']),
- * ) // { world: 2 }
- * ```
- *
- * `pick` 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]
- * const nested = { a: { b: { c: { d: 1, e: [2, 3] } } } }
- *
- * console.log(pick(['a.b.c.d'])(nested)) // { a: { b: { c: { d: 1 } } } }
- * ```
- *
- * Compose `pick` inside a `pipe` with its lazy API.
- *
- * ```javascript [playground]
- * pipe({ a: 1, b: 2, c: 3 }, [
- *   map(number => number ** 2),
- *   pick(['a', 'c']),
- *   console.log, // { a: 1, c: 9 }
- * ])
- * ```
- */
-declare function pick(arg0: any, arg1: any): any;

package/pipe.d.ts

@@ -1,49 +0,0 @@
-export = pipe;
-/**
- * @name pipe
- *
- * @synopsis
- * ```coffeescript [specscript]
- * pipe(funcs Array<function>)(...args) -> result Promise|any
- *
- * pipe(...args, funcs Array<function>) -> result Promise|any
- * ```
- *
- * @description
- * Creates a function pipeline from an array of functions, where each function passes its return value as a single argument to the next function until all functions have executed. The first function is called with the arguments to the pipeline, while the result of the pipeline execution is the return of its last function. If any function of the pipeline is asynchronous, the result of the execution is a Promise.
- *
- * ```javascript [playground]
- * const syncAdd123 = pipe([
- *   number => number + 1,
- *   number => number + 2,
- *   number => number + 3,
- * ])
- *
- * console.log(syncAdd123(5)) // 11
- *
- * const asyncAdd123 = pipe([
- *   async number => number + 1,
- *   async number => number + 2,
- *   async number => number + 3,
- * ])
- *
- * asyncAdd123(5).then(console.log) // 11
- * ```
- *
- * When passed any amount of arguments before the array of functions, `pipe` executes eagerly; the array of functions is immediately invoked with the supplied arguments.
- *
- * ```javascript [playground]
- * pipe(1, 2, 3, [
- *   Array.of,
- *   map(number => number * 3),
- *   console.log, // [3, 6, 9]
- * ])
- * ```
- *
- * @execution series
- *
- * @transducing
- *
- * @since 1.6.0
- */
-declare function pipe(...args: any[]): any;