rubico 2.7.5 → 2.7.7

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;

package/reduce.d.ts

@@ -1,166 +0,0 @@
-export = reduce;
-/**
- * @name reduce
- *
- * @synopsis
- * ```coffeescript [specscript]
- * type Foldable = Array|Object|Map|Iterator|AsyncIterator
- *
- * type Reducer = (
- *   accumulator any,
- *   value any,
- *   indexOrKey? number|string,
- *   collection? Foldable,
- * )=>(nextAccumulator Promise|any)
- *
- * type Resolver = (collection Foldable)=>Promise|any
- *
- * reduce(
- *   collection Foldable,
- *   reducer Reducer,
- *   initialValue? Resolver|any
- * ) -> result Promise|any
- *
- * reduce(
- *   reducer Reducer,
- *   initialValue? Resolver|any
- * )(collection Foldable) -> result Promise|any
- * ```
- *
- * @description
- * Transforms a collection based on a reducer function and optional initial value. In a reducing operation, the result is defined in the beginning as either the initial value if supplied or the first element of the collection. The reducing operation then iterates through the remaining elements in the collection, executing the reducer at each iteration to return the result to be used in the next iteration. The final result is the result of the execution of the reducer at the last element of the iteration. `reduce` accepts the following collections:
- *
- *  * `Array`
- *  * `Object`
- *  * `Set`
- *  * `Map`
- *  * `Iterator`/`Generator`
- *  * `AsyncIterator`/`AsyncGenerator`
- *
- * For arrays (type `Array`), `reduce` executes the reducer function for each element of the array in order, returning a new result at each execution to be used in the next execution. On each iteration, the reducer is passed the accumulator, the element of the iteration, the index of the element in the array, and a reference to the original array.
- *
- * ```javascript [playground]
- * const max = (a, b) => a > b ? a : b
- *
- * console.log(
- *   reduce([1, 3, 5, 4, 2], max)
- * ) // 5
- *
- * console.log(
- *   reduce(max)([1, 3, 5, 4, 2])
- * ) // 5
- * ```
- *
- * If an optional initial value is provided, the result starts as the provided initial value rather than the first element of the collection.
- *
- * ```javascript [playground]
- * const add = (a, b) => a + b
- *
- * console.log(reduce([1, 2, 3, 4, 5], add, 0)) // 15
- * console.log(reduce(add, 0)([1, 2, 3, 4, 5])) // 15
- * ```
- *
- * If the initialization parameter is a function, it is treated as a resolver and called with the arguments to resolve the initial value.
- *
- * ```javascript [playground]
- * const concatSquares = (array, value) => array.concat(value ** 2)
- *
- * const contrivedInitializer = array => [`initial length ${array.length}`]
- *
- * const array = [1, 2, 3, 4, 5]
- *
- * console.log(reduce(concatSquares, contrivedInitializer)(array))
- * // ['initial length 5', 1, 4, 9, 16, 25]
- * console.log(reduce(array, concatSquares, contrivedInitializer))
- * // ['initial length 5', 1, 4, 9, 16, 25]
- * ```
- *
- * For objects (type `Object`), `reduce` executes the reducer function for each value of the object. On each iteration, the reducer is passed the accumulator, the object value, the key of the object value, and a reference to the original object.
- *
- * ```javascript [playground]
- * const add = (a, b) => a + b
- *
- * const obj = { a: 1, b: 2, c: 3, d: 4, e: 5 }
- *
- * console.log(
- *   reduce(obj, add)
- * ) // 15
- *
- * console.log(
- *   reduce(add)(obj)
- * ) // 15
- * ```
- *
- * For sets (type `Set`), `reduce` executes the reducer function for each element of the set. On each iteration, the reducer is passed the accumulator and element of the set.
- *
- * ```javascript [playground]
- * const add = (a, b) => a + b
- *
- * const set = new Set([1, 2, 3, 4, 5])
- *
- * console.log(
- *   reduce(set, add)
- * ) // 15
- *
- * console.log(
- *   reduce(add)(set)
- * ) // 15
- * ```
- *
- * For maps (type `Map`), `reduce` executes the reducer function for each value of each entry of the map. On each iteration, the reducer is passed the accumulator, the map element, the key of the map element, and a reference to the original map.
- *
- * ```javascript [playground]
- * const add = (a, b) => a + b
- *
- * const m = new Map([['a', 1], ['b', 2], ['c', 3], ['d', 4], ['e', 5]])
- *
- * console.log(
- *   reduce(m, add)
- * ) // 15
- *
- * console.log(
- *   reduce(add)(m)
- * ) // 15
- * ```
- *
- * For iterators (type `Iterator`) and generators (type `Generator`), `reduce` executes the reducer function for each value of the iterator/generator. On each iteration, the reducer is passed the accumulator and the element of the iteration. The iterator/generator is consumed in the process.
- *
- * ```javascript [playground]
- * const add = (a, b) => a + b
- *
- * const generate12345 = function* () {
- *   yield 1; yield 2; yield 3; yield 4; yield 5
- * }
- *
- * console.log(
- *   reduce(generate12345(), add)
- * ) // 15
- *
- * console.log(
- *   reduce(add)(generate12345())
- * ) // 15
- * ```
- *
- * For asyncIterators (type `AsyncIterator`) and asyncGenerators (type `AsyncGenerator`), `reduce` executes the reducer function for each value of the asyncIterator/asyncGenerator. On each iteration, the reducer is passed the accumulator and the element of the async iteration. The asyncIterator/asyncGenerator is consumed in the process.
- *
- * ```javascript [playground]
- * const asyncAdd = async (a, b) => a + b
- *
- * const asyncGenerate12345 = async function* () {
- *   yield 1; yield 2; yield 3; yield 4; yield 5
- * }
- *
- * reduce(asyncGenerate12345(), asyncAdd).then(console.log) // 15
- *
- * reduce(asyncAdd)(asyncGenerate12345()).then(console.log) // 15
- * ```
- *
- * @execution series
- *
- * @transducing
- *
- * @TODO readerReduce
- *
- * @TODO reduce.concurrent
- */
-declare function reduce(...args: any[]): any;