rubico 2.7.4 → 2.7.6

package/curry.d.ts

@@ -1,70 +0,0 @@
-export = curry;
-/**
- * @name curry
- *
- * @synopsis
- * ```coffeescript [specscript]
- * type __ = Symbol(placeholder)
- * type ArgsWithPlaceholder = Array<__|any>
- *
- * args ArgsWithPlaceholder
- * moreArgs ArgsWithPlaceholder
- *
- * curry(
- *   func function,
- *   ...args
- * ) -> curriedFuncOrResult function|any
- *
- * curriedFuncOrResult(...moreArgs) -> anotherCurriedFuncOrResult function|any
- * ```
- *
- * @description
- * Enable partial application of a function's arguments in any order. Provide the placeholder value `__` to specify an argument to be resolved in the partially applied function.
- *
- * ```javascript [playground]
- * const add = (a, b, c) => a + b + c
- *
- * console.log(curry(add, 'a', 'b', 'c')) // 'abc'
- * console.log(curry(add)('a', 'b', 'c')) // 'abc'
- * console.log(curry(add, 'a')('b', 'c')) // 'abc'
- * console.log(curry(add, 'a', 'b')('c')) // 'abc'
- * console.log(curry(add)('a')('b')('c')) // 'abc'
- *
- * console.log(curry(add, __, 'b', 'c')('a')) // abc
- * console.log(curry(add, __, __, 'c')('a', 'b')) // abc
- * console.log(curry(add, __, __, 'c')(__, 'b')('a')) // abc
- * ```
- */
-declare function curry(func: any, ...args: any[]): any;
-declare namespace curry {
-    /**
-     * @name curry.arity
-     *
-     * @synopsis
-     * ```coffeescript [specscript]
-     * type __ = Symbol(placeholder)
-     * type ArgsWithPlaceholder = Array<__|any>
-     *
-     * args ArgsWithPlaceholder
-     * moreArgs ArgsWithPlaceholder
-     *
-     * curry.arity(
-     *   arity number,
-     *   func function,
-     *   ...args
-     * ) -> curriedFuncOrResult function|any
-     *
-     * curriedFuncOrResult(...moreArgs) -> anotherCurriedFuncOrResult function|any
-     * ```
-     *
-     * @description
-     * `curry` with specified arity (number of arguments taken by the function) as the first parameter.
-     *
-     * ```javascript [playground]
-     * const add = (a, b, c = 0) => a + b + c
-     *
-     * console.log(curry.arity(2, add, 1, 2)) // 3
-     * ```
-     */
-    function arity(arity: any, func: any, ...args: any[]): any;
-}

package/eq.d.ts

@@ -1,51 +0,0 @@
-export = eq;
-/**
- * @name eq
- *
- * @synopsis
- * ```coffeescript [specscript]
- * eq(leftValue Promise|any, rightValue Promise|any) -> boolean
- *
- * eq(leftValue Promise|any, right function)(...args) -> Promise|boolean
- * eq(...args, leftValue Promise|any, right function) -> Promise|boolean
- *
- * eq(left function, rightValue Promise|any)(...args) -> Promise|boolean
- * eq(...args, left function, rightValue Promise|any) -> Promise|boolean
- *
- * eq(left function, right function)(...args) -> Promise|boolean
- * eq(...args, left function, right function) -> Promise|boolean
- * ```
- *
- * @description
- * Test for [equality (`==`)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Equality) between two values.
- *
- * ```javascript [playground]
- * const areNamesEqual = eq('Ted', 'John')
- *
- * console.log(areNamesEqual) // false
- * ```
- *
- * If either of the two values are resolver functions, `eq` returns a function that resolves the values to compare from its arguments.
- *
- * ```javascript [playground]
- * const personIsJohn = eq(get('name'), 'John')
- *
- * const person = { name: 'John', likes: 'bananas' }
- *
- * if (personIsJohn(person)) {
- *   console.log('The person is george')
- * }
- * ```
- *
- * `eq` supports a lazy API for composability.
- *
- * ```javascript [playground]
- * pipe({ name: 'John' }, [
- *   eq('John', get('name')),
- *   console.log, // true
- * ])
- * ```
- *
- * @execution concurrent
- */
-declare const eq: (...args: any[]) => any;

package/es.d.ts

@@ -1,80 +0,0 @@
-export default rubico;
-declare namespace rubico {
-    export { pipe };
-    export { compose };
-    export { tap };
-    export { forEach };
-    export { switchCase };
-    export { tryCatch };
-    export { all };
-    export { assign };
-    export { get };
-    export { set };
-    export { pick };
-    export { omit };
-    export { map };
-    export { filter };
-    export { flatMap };
-    export { reduce };
-    export { transform };
-    export { and };
-    export { or };
-    export { not };
-    export { some };
-    export { every };
-    export { eq };
-    export { gt };
-    export { lt };
-    export { gte };
-    export { lte };
-    export { thunkify };
-    export { always };
-    export { curry };
-    export { __ };
-}
-declare function pipe(...args: any[]): any;
-declare function compose(...args: any[]): any;
-declare function tap(...args: any[]): any;
-declare namespace tap {
-    function _if(predicate: any, func: any): (...args: any[]) => any;
-    export { _if as if };
-}
-declare function forEach(...args: any[]): any;
-declare function switchCase(...args: any[]): any;
-declare function tryCatch(...args: any[]): any;
-declare function all(...args: any[]): any;
-declare namespace all {
-    function series(...args: any[]): any;
-}
-declare function assign(arg0: any, arg1: any): any;
-declare function get(arg0: any, arg1: any, arg2: any): any;
-declare function set(arg0: any, arg1: any, arg2: any): any;
-declare function pick(arg0: any, arg1: any): any;
-declare function omit(arg0: any, arg1: any): any;
-declare function map(...args: any[]): any;
-declare namespace map {
-    function entries(mapper: any): (value: any) => any;
-    function series(mapper: any): (value: any) => any;
-    function pool(concurrencyLimit: any, mapper: any): (value: any) => any[] | Promise<any>;
-}
-declare function filter(...args: any[]): any;
-declare function flatMap(...args: any[]): any;
-declare function reduce(...args: any[]): any;
-declare function transform(...args: any[]): any;
-declare function and(...args: any[]): any;
-declare function or(...args: any[]): any;
-declare function not(...args: any[]): any;
-declare function some(...args: any[]): any;
-declare function every(...args: any[]): any;
-declare function eq(...args: any[]): any;
-declare function gt(...args: any[]): any;
-declare function lt(...args: any[]): any;
-declare function gte(...args: any[]): any;
-declare function lte(...args: any[]): any;
-declare function thunkify(func: any, ...args: any[]): () => any;
-declare function always(value: any): () => any;
-declare function curry(func: any, ...args: any[]): any;
-declare namespace curry {
-    function arity(arity: any, func: any, ...args: any[]): any;
-}
-declare const __: any;

package/every.d.ts

@@ -1,52 +0,0 @@
-export = every;
-/**
- * @name every
- *
- * @synopsis
- * ```coffeescript [specscript]
- * type Foldable = Array|Iterable|AsyncIterable|{ reduce: function }|Object
- *
- * every(collection Foldable, predicate function) -> result Promise|boolean
- *
- * every(predicate function)(collection Foldable) -> result Promise|boolean
- * ```
- *
- * @description
- * Test a predicate concurrently across all elements of a collection, returning true if all predications are truthy.
- *
- * ```javascript [playground]
- * const isOdd = number => number % 2 == 1
- *
- * console.log(
- *   every([1, 2, 3, 4, 5], isOdd),
- * ) // false
- *
- * console.log(
- *   every([1, 3, 5], isOdd),
- * ) // true
- * ```
- *
- * The collection can be any iterable, async iterable, or object values iterable collection. Below is an example of `every` accepting an async generator as the collection.
- *
- * ```javascript [playground]
- * const asyncNumbers = async function* () {
- *   yield 1; yield 2; yield 3; yield 4; yield 5
- * }
- *
- * every(asyncNumbers(), async number => number < 6).then(console.log) // true
- * ```
- *
- * `every` supports a lazy API for composability.
- *
- * ```javascript [playground]
- * pipe([1, 2, 3], [
- *   every(number => number < 5),
- *   console.log, // true
- * ])
- * ```
- *
- * @execution concurrent
- *
- * @muxing
- */
-declare function every(...args: any[]): any;

package/filter.d.ts

@@ -1,148 +0,0 @@
-export = filter;
-/**
- * @name filter
- *
- * @synopsis
- * ```coffeescript [specscript]
- * type Filterable = Array|Object|Set|Map|Iterator|AsyncIterator
- *
- * type Predicate = (
- *   value any,
- *   indexOrKey number|string,
- *   collection Filterable,
- * )=>boolean
- *
- * filter(collection Filterable, predicate Predicate) -> result Promise|Filterable
- * filter(predicate Predicate)(collection Filterable) -> result Promise|Filterable
- * ```
- *
- * @description
- * Filter out elements from a collection based on the results of their concurrent executions with a synchronous or asynchronous predicate function. `filter` accepts the following collections:
- *
- *  * `Array`
- *  * `Object`
- *  * `Set`
- *  * `Map`
- *  * `Iterator`/`Generator`
- *  * `AsyncIterator`/`AsyncGenerator`
- *
- * For arrays (type `Array`), `filter` applies the predicate function to each element of the array, returning a new array containing only the elements that tested truthy by the predicate. The order of the elements is preserved. On each iteration, the predicate is passed the element, the index of the element, and a reference to the array.
- *
- * ```javascript [playground]
- * const isOdd = number => number % 2 == 1
- *
- * const array = [1, 2, 3, 4, 5]
- *
- * console.log(filter(isOdd)(array)) // [1, 3, 5]
- * console.log(filter(array, isOdd)) // [1, 3, 5]
- * ```
- *
- * For objects (type `Object`), `filter` applies the predicate function to each value of the object, returning a new object containing only the values that tested truthy by the predicate. On each iteration, the predicate is passed the object value, the key of the object value, and a reference to the object.
- *
- * ```javascript [playground]
- * const isOdd = number => number % 2 == 1
- *
- * const obj = { a: 1, b: 2, c: 3, d: 4, e: 5 }
- *
- * console.log(filter(isOdd)(obj)) // { a: 1, c: 3, e: 5 }
- * console.log(filter(obj, isOdd)) // { a: 1, c: 3, e: 5 }
- * ```
- *
- * For sets (type `Set`), `filter` applies the predicate function to each element in the set, returning a new set containing only the elements that tested truthy by the predicate. On each iteration, the predicate is passed the element, the same element as the key argument, and a reference to the set.
- *
- * ```javascript [playground]
- * const isOdd = number => number % 2 == 1
- *
- * const set = new Set([1, 2, 3, 4, 5])
- *
- * console.log(filter(isOdd)(set)) // Set { 1, 3, 5 }
- * console.log(filter(set, isOdd)) // Set { 1, 3, 5 }
- * ```
- *
- * For maps (type `Map`), `filter` applies the predicate function to the value of each entry of the map, returning a new map containing only the entries where the values tested truthy by the predicate. The order of the entries are preserved. On each iteration, the predicate is passed the map value, the key of the value, and a reference to the map.
- *
- * ```javascript [playground]
- * const isOdd = number => number % 2 == 1
- *
- * const obj = { a: 1, b: 2, c: 3, d: 4, e: 5 }
- * const m = new Map([['a', 1], ['b', 2], ['c', 3], ['d', 4], ['e', 5]])
- *
- * console.log(filter(isOdd)(m)) // Map(3) { 'a' => 1, 'c' => 3, 'e' => 5 }
- * console.log(filter(m, isOdd)) // Map(3) { 'a' => 1, 'c' => 3, 'e' => 5 }
- * ```
- *
- * For iterators (type `Iterator`) or generators (type `Generator`), `filter` returns a lazily filtered iterator/generator; all values that are normally yielded by the iterator/generator that test falsy by the predicate function are skipped by the lazily filtered iterator/generator. On each iteration, the predicate is passed the iteration value only.
- *
- * ```javascript [playground]
- * const isOdd = number => number % 2 == 1
- *
- * const numbersGeneratorFunction = function* () {
- *   yield 1; yield 2; yield 3; yield 4; yield 5
- * }
- *
- * const numbersGenerator = numbersGeneratorFunction()
- * const oddNumbersGenerator = filter(numbersGeneratorFunction(), isOdd)
- * const oddNumbersGenerator2 = filter(isOdd)(numbersGeneratorFunction())
- *
- * for (const number of numbersGenerator) {
- *   console.log(number) // 1
- *                       // 2
- *                       // 3
- *                       // 4
- *                       // 5
- * }
- *
- * for (const number of oddNumbersGenerator) {
- *   console.log(number) // 1
- *                       // 3
- *                       // 5
- * }
- *
- * for (const number of oddNumbersGenerator2) {
- *   console.log(number) // 1
- *                       // 3
- *                       // 5
- * }
- * ```
- *
- * With asyncIterators (type `AsyncIterator`) or asyncGenerators (type `AsyncGenerator`), `filter` returns a lazily filtered asyncIterator/asyncGenerator; all values that are normally yielded by the asyncIterator/asyncGenerator that test falsy by the predicate function are skipped by the lazily filtered asyncIterator/asyncGenerator. On each iteration, the predicate is passed the iteration value only.
- *
- * ```javascript [playground]
- * const asyncIsOdd = async number => number % 2 == 1
- *
- * const asyncNumbersGeneratorFunction = async function* () {
- *   yield 1; yield 2; yield 3; yield 4; yield 5
- * }
- *
- * const asyncNumbersGenerator = asyncNumbersGeneratorFunction()
- *
- * const asyncOddNumbersGenerator = filter(asyncNumbersGeneratorFunction(), asyncIsOdd)
- *
- * const asyncOddNumbersGenerator2 = filter(asyncIsOdd)(asyncNumbersGeneratorFunction())
- *
- * for await (const number of asyncNumbersGenerator) {
- *   console.log(number) // 1
- *                       // 2
- *                       // 3
- *                       // 4
- *                       // 5
- * }
- *
- * for await (const number of asyncOddNumbersGenerator) {
- *   console.log(number) // 1
- *                       // 3
- *                       // 5
- * }
- *
- * for await (const number of asyncOddNumbersGenerator2) {
- *   console.log(number) // 1
- *                       // 3
- *                       // 5
- * }
- * ```
- *
- * @execution concurrent
- *
- * @transducing
- */
-declare function filter(...args: any[]): any;

package/flatMap.d.ts

@@ -1,109 +0,0 @@
-export = flatMap;
-/**
- * @name flatMap
- *
- * @synopsis
- * ```coffeescript [specscript]
- * type FlatMappable = Array|String|Set|Iterator|AsyncIterator
- *
- * type Iterable = Iterable|AsyncIterable|Object<value any>
- *
- * type FlatMapper = (
- *   element any,
- *   indexOrKey string,
- *   collection FlatMappable
- * )=>Promise|FlatMappable
- *
- * flatMap(collection FlatMappable, flatMapper FlatMapper) -> result Promise|FlatMappable
- * flatMap(flatMapper FlatMapper)(collection FlatMappable) -> result Promise|FlatMappable
- * ```
- *
- * @description
- * Applies a flatMapper function concurrently to each element of a collection, creating a new collection of the same type. A flatMapping operation iterates through each element of a collection and applies the flatMapper function to each element, flattening the result of the execution into the result collection. The result of an individual execution can be any iterable, async iterable, or object values iterable collection. The flatMapper function may be asynchronous.
- *
- *  * `Iterable` - the execution result is iterated and each element is added to the result collection
- *  * `AsyncIterable` - the execution result is asynchronously iterated and each element is added to the result collection
- *  * `Object` - the execution result values are added to the result collection
- *
- * The following example demonstrates various execution results being flattened into the same array.
- *
- * ```javascript [playground]
- * const identity = value => value
- *
- * flatMap(identity)([
- *   [1, 1], // array
- *   new Set([2, 2]), // set
- *   (function* () { yield 3; yield 3 })(), // generator
- *   (async function* () { yield 7; yield 7 })(), // asyncGenerator
- *   { a: 5, b: 5 }, // object
- *   new Uint8Array([8]), // typedArray
- * ]).then(console.log)
- * // [1, 1, 2, 3, 3, 5, 5, 8, 7, 7]
- * ```
- *
- * A flatMapping operation concatenates onto the resulting collection synchronous values and muxes any asynchronous values. Muxing, or asynchronously "mixing", is the process of combining multiple asynchronous sources into one source, with order determined by the asynchronous resolution of the individual elements.
- *
- * ```javascript [playground]
- * const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
- *
- * const repeat3 = function* (message) {
- *   yield message; yield message; yield message
- * }
- *
- * console.log( // sync is concatenated
- *   flatMap(['foo', 'bar', 'baz'], repeat3),
- * ) // ['foo', 'foo', 'foo', 'bar', 'bar', 'bar', 'baz', 'baz', 'baz']
- *
- * const asyncRepeat3 = async function* (message) {
- *   yield message
- *   await sleep(100)
- *   yield message
- *   await sleep(1000)
- *   yield message
- * }
- *
- * // async is muxed
- * flatMap(['foo', 'bar', 'baz'], asyncRepeat3).then(console.log)
- * // ['foo', 'bar', 'baz', 'foo', 'bar', 'baz', 'foo', 'bar', 'baz']
- * ```
- *
- * For arrays (type `Array`), `flatMap` applies the flatMapper function to each element, pushing (`.push`) the elements of each execution into a new array.
- *
- * ```javascript [playground]
- * const duplicate = value => [value, value]
- *
- * console.log(
- *   flatMap([1, 2, 3, 4, 5], duplicate)
- * ) // [1, 1, 2, 2, 3, 3, 4, 4, 5, 5]
- * ```
- *
- * For strings (type `String`), `flatMap` applies the flatMapper function to each character, adding (`+`) the elements of each execution into a new string
- *
- * ```javascript [playground]
- * const duplicate = value => [value, value]
- *
- * console.log(
- *   flatMap('12345', duplicate)
- * ) // 1122334455
- * ```
- *
- * For sets (type `Set`), `flatMap` applies the flatMapper function to each element, adding (`.add`) the elements of each execution into a new set
- *
- * ```javascript [playground]
- * const pairPlus100 = value => [value, value + 100]
- *
- * console.log(
- *   flatMap(new Set([1, 2, 3, 4, 5]), pairPlus100)
- * ) // Set(10) { 1, 101, 2, 102, 3, 103, 4, 104, 5, 105 }
- * ```
- *
- * @execution concurrent
- *
- * @transducing
- *
- * @archive
- *  * For typed arrays (type [`TypedArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#typedarray_objects)) and Node.js buffers (type [`Buffer`](https://nodejs.org/api/buffer.html)), `flatMap` applies a flatMapper function to each value of the typed array/buffer, joining the result of each execution with `.set` into the resulting typed array
- *
- *  * For Node.js duplex streams (type [Stream](https://nodejs.org/api/stream.html#class-streamduplex)), `flatMap` applies a flatMapper function to each element of the stream, writing (`.write`) each element of each execution into the duplex stream
- */
-declare function flatMap(...args: any[]): any;

package/forEach.d.ts

@@ -1,35 +0,0 @@
-export = forEach;
-/**
- * @name forEach
- *
- * @synopsis
- * ```coffeescript [specscript]
- * type Collection = Array|Iterable|AsyncIterable|{ forEach: function }|Object
- *
- * forEach(collection Collection, callback function) -> collection Collection
- *
- * forEach(callback function)(collection Collection) -> collection Collection
- * ```
- *
- * @description
- * Execute a callback for each element of a collection, returning a Promise if the execution is asynchronous.
- *
- * ```javascript [playground]
- * forEach([1, 2, 3, 4, 5l], console.log) // 1 2 3 4 5
- *
- * forEach({ a: 1, b: 2, c: 3 }, console.log) // 1 2 3
- * ```
- *
- * Omit the data argument for a composable API
- *
- * ```javascript [playground]
- * pipe([1, 2, 3, 4, 5], [
- *   filter(number => number % 2 == 1),
- *   map(number => number ** 2),
- *   forEach(console.log), // 1
- *                         // 9
- *                         // 25
- * ])
- * ```
- */
-declare function forEach(...args: any[]): any;

package/get.d.ts

@@ -1,70 +0,0 @@
-export = get;
-/**
- * @name get
- *
- * @synopsis
- * ```coffeescript [specscript]
- * get(
- *   object Promise|Object,
- *   path string|number|Array<string|number>,
- *   defaultValue? function|any
- * ) -> result Promise|Object
- *
- * get(
- *   path string|number|Array<string|number>,
- *   defaultValue? function|any
- * )(object Object) -> result Promise|Object
- * ```
- *
- * @description
- * Accesses a property of an object given a path denoted by a string, number, or an array of string or numbers.
- *
- * ```javascript [playground]
- * const obj = { hello: 'world' }
- *
- * console.log(get(obj, 'hello')) // world
- * ```
- *
- * `get` supports a lazy API for composability
- *
- * ```javascript [playground]
- * const obj = { hello: 'world' }
- *
- * const getHello = get('hello')
- *
- * console.log(getHello({ hello: 'world' })) // world
- * ```
- *
- * If the value at the end of the path is not found on the object, returns an optional default value. The default value can be a function resolver that takes the object as an argument. If no default value is provided, returns `undefined`. The function resolver may be asynchronous (returns a promise).
- *
- * ```javascript [playground]
- * const getHelloWithDefaultValue = get('hello', 'default')
- *
- * console.log(getHelloWithDefaultValue({ foo: 'bar' })) // default
- *
- * const getHelloWithDefaultResolver = get('hello', object => object.foo)
- *
- * console.log(getHelloWithDefaultResolver({ foo: 'bar' })) // bar
- * ```
- *
- * `get` 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 getABC0 = get('a.b.c[0]')
- *
- * console.log(getABC0({ a: { b: { c: ['hello'] } } })) // hello
- *
- * const get00000DotNotation = get('0.0.0.0.0')
- * const get00000BracketNotation = get('[0][0][0][0][0]')
- * const get00000ArrayNotation = get([0, 0, 0, 0, 0])
- *
- * console.log(get00000DotNotation([[[[['foo']]]]])) // foo
- * console.log(get00000BracketNotation([[[[['foo']]]]])) // foo
- * console.log(get00000ArrayNotation([[[[['foo']]]]])) // foo
- * ```
- */
-declare function get(arg0: any, arg1: any, arg2: any): any;

package/global.d.ts

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

package/gt.d.ts

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