rubico 2.7.5 → 2.7.7

package/set.d.ts

@@ -1,61 +0,0 @@
-export = set;
-/**
- * @name set
- *
- * @synopsis
- * ```coffeescript [specscript]
- * set(
- *   object Promise|Object,
- *   path string|Array<string|number>,
- *   value function|any,
- * ) -> result Promise|Object
- *
- * set(
- *   path string|Array<string|number>,
- *   value function|any,
- * )(object Object) -> result Promise|Object
- * ```
- *
- * @description
- * Sets a property on a new object shallow cloned from the argument object given a path denoted by a string, number, or an array of string or numbers.
- *
- * `set` 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(set({ b: 2 }, 'a', 1)) // { a: 1, b: 2 }
- *
- * const nestedAC2 = { a: { c: 2 } }
- *
- * console.log(set(nestedAC2, 'a.b', 1)) // { a : { b: 1, c: 2 }}
- *
- * const nestedA0BC3 = { a: [{ b: { c: 3 } }] }
- *
- * console.log(set(nestedA0BC3, 'a[0].b.c', 4)) // { a: [{ b: { c: 4 } }] }
- * ```
- *
- * The property value may be a function, in which case it is treated as a resolver and provided the argument object to resolve the value to set.
- *
- * ```javascript [playground]
- * const myObj = { a: 1 }
- *
- * const myNewObj = set('b', obj => obj.a + 2)(myObj)
- *
- * console.log(myNewObj) // { a: 1, b: 3 }
- * ```
- *
- * `set` supports a lazy API for composability.
- *
- * ```javascript [playground]
- * pipe({ a: 1 }, [
- *   set('b', 2),
- *   console.log, // { a: 1, b: 2 }
- * ])
- * ```
- *
- * @since 1.7.0
- */
-declare function set(arg0: any, arg1: any, arg2: any): any;

package/some.d.ts

@@ -1,65 +0,0 @@
-export = some;
-/**
- * @name some
- *
- * @synopsis
- * ```coffeescript [specscript]
- * type Foldable = Array|Iterable|AsyncIterable|{ reduce: function }|Object
- *
- * some(collection Foldable, predicate function) -> Promise|boolean
- *
- * some(predicate function)(collection Foldable) -> Promise|boolean
- * ```
- *
- * @description
- * Test a predicate concurrently across all elements of a collection, returning true if any executions return truthy.
- *
- * ```javascript [playground]
- * const isOdd = number => number % 2 == 1
- *
- * console.log(
- *   some([1, 2, 3, 4, 5], isOdd),
- * ) // true
- * ```
- *
- * The collection can be any iterable, async iterable, or object values iterable collection. Below is an example of `some` accepting an async generator as the collection.
- *
- * ```javascript [playground]
- * const toTodosUrl = id => 'https://jsonplaceholder.typicode.com/todos/' + id
- *
- * const fetchedToJson = fetched => fetched.json()
- *
- * const fetchTodo = pipe([
- *   toTodosUrl,
- *   fetch,
- *   fetchedToJson,
- * ])
- *
- * const todoIDsGenerator = async function* () {
- *   yield 1; yield 2; yield 3; yield 4; yield 5
- * }
- *
- * const promise = some(todoIDsGenerator(), async id => {
- *   const todo = await fetchTodo(id)
- *   return todo.title.startsWith('fugiat')
- * })
- *
- * promise.then(console.log) // true
- * ```
- *
- * `some` supports a lazy API for composability.
- *
- * ```javascript [playground]
- * pipe([1, 2, 3], [
- *   some(number => number < 5),
- *   console.log, // true
- * ])
- * ```
- *
- * @execution concurrent
- *
- * @muxing
- *
- * @related or
- */
-declare function some(...args: any[]): any;

package/switchCase.d.ts

@@ -1,76 +0,0 @@
-export = switchCase;
-/**
- * @name switchCase
- *
- * @synopsis
- * ```coffeescript [specscript]
- * switchCase(conditionalValues Array<boolean|any>) -> Promise|any
- *
- * switchCase(
- *   ...args,
- *   conditionalFuncsOrValues Array<function|boolean|any>
- * ) -> Promise|any
- *
- * switchCase(
- *   conditionalFuncsOrValues Array<function|boolean|any>
- * )(...args) -> Promise|any
- * ```
- *
- * @description
- * Functional equivalent to the [Conditional (ternary) operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_Operator). Accepts an array of conditional functions that specifies cases as pairings of `predicate` and `resolver` functions with the exception of the last, default resolver. All functions are provided with the same arguments and executed in series. The result of a `switchCase` operation is either the result of the execution the last default resolver, or the result of the execution of the first resolver where the associated predicate tested true.
- *
- * ```javascript [playground]
- * const fruitIsYellow = fruit => fruit.color == 'yellow'
- *
- * console.log(
- *   switchCase({ name: 'plantain', color: 'yellow' }, [
- *     fruitIsYellow,
- *     fruit => fruit.name + ' is possibly a banana',
- *     fruit => fruit.name + ' is probably not a banana',
- *   ])
- * ) // plantain is possibly a banana
- * ```
- *
- * For composability `switchCase` supports a lazy API.
- *
- * ```javascript [playground]
- * const fruitIsYellow = fruit => fruit.color == 'yellow'
- *
- * const fruitsGuesser = switchCase([
- *   fruitIsYellow,
- *   fruit => fruit.name + ' is possibly a banana',
- *   fruit => fruit.name + ' is probably not a banana',
- * ])
- *
- * console.log(fruitsGuesser({ name: 'plantain', color: 'yellow' }))
- * // plantain is possibly a banana
- *
- * console.log(fruitsGuesser({ name: 'apple', color: 'red' }))
- * // apple is probably not a banana
- * ```
- *
- * Any function can be replaced with a nonfunction (object or primitive) value to be used directly in the operation.
- *
- * ```javascript [playground]
- * switchCase([
- *   async function asyncIdentity(value) {
- *     return value
- *   },
- *   'something',
- *   'default',
- * ])(false).then(console.log) // default
- * ```
- *
- * If every element in the conditional array is a nonfunction value, `switchCase` executes eagerly.
- *
- * ```javascript [playground]
- * const age = 26
- *
- * const myDrink = switchCase([age >= 21, 'Beer', 'Juice'])
- *
- * console.log(myDrink) // Beer
- * ```
- *
- * @execution series
- */
-declare function switchCase(...args: any[]): any;

package/tap.d.ts

@@ -1,53 +0,0 @@
-export = tap;
-/**
- * @name tap
- *
- * @synopsis
- * ```coffeescript [specscript]
- * tap(...args, func function) -> Promise|args[0]
- * tap(func function)(...args) -> Promise|args[0]
- * ```
- *
- * @description
- * Call a function with any number of arguments, returning the first argument. Promises created by the tapper are resolved before returning the value.
- *
- * ```javascript [playground]
- * const pipeline = pipe([
- *   tap(value => console.log(value)),
- *   tap(value => console.log(value + 'bar')),
- *   tap(value => console.log(value + 'barbaz')),
- * ])
- *
- * pipeline('foo') // 'foo'
- *                 // 'foobar'
- *                 // 'foobarbaz'
- * ```
- */
-declare function tap(...args: any[]): any;
-declare namespace tap {
-    /**
-     * @name tap.if
-     *
-     * @synopsis
-     * ```coffeescript [specscript]
-     * tap.if(predicate function, func function)(...args) -> Promise|args[0]
-     * ```
-     *
-     * @description
-     * A version of `tap` that accepts a predicate function (a function that returns a boolean value) before the function to execute. Only executes the function if the predicate function tests true for the same arguments provided to the execution function.
-     *
-     * ```javascript [playground]
-     * const isOdd = number => number % 2 == 1
-     *
-     * const logIfOdd = tap.if(
-     *   isOdd,
-     *   number => console.log(number, 'is an odd number')
-     * )
-     *
-     * logIfOdd(2)
-     * logIfOdd(3) // 3 is an odd number
-     * ```
-     */
-    function _if(predicate: any, func: any): (...args: any[]) => any;
-    export { _if as if };
-}

package/thunkify.d.ts

@@ -1,21 +0,0 @@
-export = thunkify;
-/**
- * @name thunkify
- *
- * @synopsis
- * ```coffeescript [specscript]
- * thunkify(func function, ...args) -> thunk ()=>func(...args)
- * ```
- *
- * @description
- * Create a thunk function from another function and any number of arguments. The thunk function takes no arguments, and when called, executes the other function with the provided arguments. The other function is said to be "thunkified".
- *
- * ```javascript [playground]
- * const add = (a, b) => a + b
- *
- * const thunkAdd12 = thunkify(add, 1, 2)
- *
- * console.log(thunkAdd12()) // 3
- * ```
- */
-declare function thunkify(func: any, ...args: any[]): () => any;

package/transform.d.ts

@@ -1,131 +0,0 @@
-export = transform;
-/**
- * @name transform
- *
- * @synopsis
- * ```coffeescript [specscript]
- * type Foldable = Iterable|AsyncIterable|Object<value any>
- *
- * type Reducer = (
- *   accumulator any,
- *   value any,
- *   indexOrKey? number|string,
- *   collection? Foldable,
- * )=>(nextAccumulator Promise|any)
- *
- * type Transducer = Reducer=>Reducer
- *
- * type Transformable =
- *   Array|String|Set|TypedArray|{ concat: function }|{ write: function }|Object
- *
- * type TransformableResolver = (collection Foldable)=>Promise|Transformable
- *
- * transform(
- *   collection Foldable,
- *   transducer Transducer,
- *   initialValue? Transformable|TransformableResolver,
- * ) -> result Promise|Transformable
- *
- * transform(
- *   transducer Transducer,
- *   initialValue? Transformable|TransformableResolver,
- * )(collection Foldable) -> result Promise|Transformable
- * ```
- *
- * @description
- * Transforms a transformable collection into any other transformable collection. The type of transformation depends on the collection provided by the initial value. If the initial is a function it is used as a resolver for the provided collection. `transform` accepts transformable collections, or collections that support a concatenation operation:
- *
- *  * `Array`; concatenation defined by `result.concat(values)`
- *  * `string`; concatenation defined by `result + values`
- *  * `Set`; concatenation defined by `result.add(...values)`
- *  * `TypedArray`; concatenation defined by `result.set(prevResult); result.set(values, offset)`
- *  * `{ concat: function }`; concatenation defined by `result.concat(values)`
- *  * `{ write: function }`; concatenation defined by `result.write(element)`
- *  * `Object`; concatenation defined by `({ ...result, ...values })`
- *
- * `transform` can transform any of the above collections into any of the other above collections.
- *
- * ```javascript [playground]
- * const square = number => number ** 2
- *
- * const isOdd = number => number % 2 == 1
- *
- * const squaredOdds = compose([
- *   Transducer.filter(isOdd),
- *   Transducer.map(square),
- * ])
- *
- * // transform arrays into arrays
- * console.log(
- *   transform(squaredOdds, [])([1, 2, 3, 4, 5])
- * ) // [1, 9, 25]
- *
- * // transform arrays into strings
- * console.log(
- *   transform(squaredOdds, '')([1, 2, 3, 4, 5])
- * ) // '1925'
- *
- * // transform arrays into sets
- * console.log(
- *   transform(squaredOdds, new Set())([1, 2, 3, 4, 5])
- * ) // Set (3) { 1, 9, 25 }
- *
- * // transform arrays into typed arrays
- * console.log(
- *   transform(squaredOdds, new Uint8Array())([1, 2, 3, 4, 5]),
- * ) // Uint8Array(3) [ 1, 9, 25 ]
- * ```
- *
- * `transform` arrays into objects that implement `.concat`.
- *
- * ```javascript [playground]
- * const square = number => number ** 2
- *
- * const Stdout = {
- *   concat(...args) {
- *     console.log(...args)
- *     return this
- *   },
- * }
- *
- * transform(Transducer.map(square), Stdout)([1, 2, 3, 4, 5])
- * // 1
- * // 4
- * // 9
- * // 16
- * // 25
- * ```
- *
- * `transform` an async generator into `process.stdout`, a Node.js writable stream that implements `.write`.
- *
- * ```javascript [node]
- * // this example is duplicated in rubico/examples/transformStreamRandomInts.js
- *
- * const { pipe, map, transform } = require('rubico')
- *
- * const square = number => number ** 2
- *
- * const toString = value => value.toString()
- *
- * const randomInt = () => Math.ceil(Math.random() * 100)
- *
- * const streamRandomInts = async function* () {
- *   while (true) {
- *     yield randomInt()
- *   }
- * }
- *
- * transform(
- *   streamRandomInts(),
- *   Transducer.map(pipe([square, toString])),
- *   process.stdout,
- * ) // 9216576529289484980147613249169774446246768649...
- * ```
- *
- * @execution series
- *
- * @transducing
- *
- * TODO explore Semigroup = Iterator|AsyncIterator
- */
-declare function transform(...args: any[]): any;

package/tryCatch.d.ts

@@ -1,47 +0,0 @@
-export = tryCatch;
-/**
- * @name tryCatch
- *
- * @synopsis
- * ```coffeescript [specscript]
- * tryCatch(tryer function, catcher function)(...args) -> Promise|any
- *
- * tryCatch(...args, tryer function, catcher function) -> Promise|any
- * ```
- *
- * @description
- * Handles errors with a `tryer` and a `catcher` function. Calls the `tryer` function with the provided arguments and catches any errors thrown by the `tryer` function with the `catcher` function. If the `tryer` function is asynchronous and returns a rejected promise, the `catcher` function will execute with the value of the rejected promise. The `catcher` function is called with the error and all arguments supplied to the `tryer` function.
- *
- * ```javascript [playground]
- * const throwsIfOdd = number => {
- *   if (number % 2 == 1) {
- *     throw new Error(`${number} is odd`)
- *   }
- *   console.log('did not throw for', number)
- * }
- *
- * const errorHandler = tryCatch(throwsIfOdd, (error, number) => {
- *   console.log('caught error from number', number)
- *   console.log(error)
- * })
- *
- * errorHandler(2) // did not throw for 2
- * errorHandler(3) // caught error from number 3
- *                 // Error: 3 is odd
- *
- * ```
- *
- * `tryCatch` behaves eagerly (executes immediately with a single call and not with multiple calls like a higher order function) when passed any amount of nonfunction (primitive or object) arguments before the `tryer` and `catcher` functions.
- *
- * ```javascript [playground]
- * const add = (a, b) => a + b
- *
- * tryCatch(1, 2, 3, function throwSum(...numbers) {
- *   const sum = numbers.reduce(add)
- *   throw new Error(`the sum is ${sum}`)
- * }, function logErrorMessage(error) {
- *   console.error(error.message) // the sum is 6
- * })
- * ```
- */
-declare function tryCatch(...args: any[]): any;

package/x/append.d.ts

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

package/x/callProp.d.ts

@@ -1,20 +0,0 @@
-export = callProp;
-/**
- * @name callProp
- *
- * @synopsis
- * ```coffeescript [specscript]
- * callProp(property string, ...args)(object) -> object[property](...args)
- * ```
- *
- * @description
- * Calls a property on an object with arguments.
- *
- * ```javascript [playground]
- * import callProp from 'https://unpkg.com/rubico/dist/x/callProp.es.js'
- *
- * const priceRoundedDown = callProp('toFixed', 2)(5.992)
- * console.log('priceRoundedDown:', priceRoundedDown) // '5.99'
- * ```
- */
-declare function callProp(property: any, ...args: any[]): (object: any) => any;

package/x/defaultsDeep.d.ts

@@ -1,42 +0,0 @@
-export = defaultsDeep;
-/**
- * @name defaultsDeep
- *
- * @synopsis
- * ```coffeescript [specscript]
- * var defaultCollection Array|Object,
- *   value Array|Object
- *
- * defaultsDeep(defaultCollection)(value) -> Array|Object
- * ```
- *
- * @description
- * Deeply assign default values to an array or object by an array or object of possibly nested default values.
- *
- * ```javascript [playground]
- * import defaultsDeep from 'https://unpkg.com/rubico/dist/x/defaultsDeep.es.js'
- *
- * const defaultUser = defaultsDeep({
- *   name: 'placeholder',
- *   images: [
- *     { url: 'https://via.placeholder.com/150' },
- *     { url: 'https://via.placeholder.com/150' },
- *     { url: 'https://via.placeholder.com/150' },
- *   ],
- * })
- *
- * console.log(defaultUser({
- *   name: 'John',
- *   images: [{ url: 'https://via.placeholder.com/150/0000FF/808080%20?Text=Digital.com' }],
- * }))
- * // {
- * //   name: 'John',
- * //   images: [
- * //    { url: 'https://via.placeholder.com/150/0000FF/808080%20?Text=Digital.com' },
- * //    { url: 'https://via.placeholder.com/150' },
- * //    { url: 'https://via.placeholder.com/150' },
- * //   ],
- * // }
- * ```
- */
-declare function defaultsDeep(defaultCollection: any): (value: any) => any;

package/x/differenceWith.d.ts

@@ -1,25 +0,0 @@
-export = differenceWith;
-/**
- * @name differenceWith
- *
- * @synopsis
- * ```coffeescript [specscript]
- * differenceWith(
- *   comparator (any, any)=>Promise|boolean,
- *   allValues Array,
- * )(values Array) -> someOrAllValues Array
- * ```
- *
- * @description
- * Create an array of all the values in an array that are not in another array as dictated by a comparator.
- *
- * ```javascript [playground]
- * import differenceWith from 'https://unpkg.com/rubico/dist/x/differenceWith.es.js'
- * import isDeepEqual from 'https://unpkg.com/rubico/dist/x/isDeepEqual.es.js'
- *
- * console.log(
- *   differenceWith(isDeepEqual, [{ a: 1 }, { b: 2 }, { c: 3 }])([{ b: 2 }]),
- * ) // [{ a: 1 }, { c: 3 }]
- * ```
- */
-declare function differenceWith(comparator: any, allValues: any): (values: any) => any;

package/x/filterOut.d.ts

@@ -1,39 +0,0 @@
-export = filterOut;
-/**
- * @name filterOut
- *
- * @synopsis
- * ```coffeescript [specscript]
- * filterOut(
- *   arrayPredicate (value any, index number, array Array)=>Promise|boolean
- * )(array) -> rejectedArray Promise|Array
- *
- * filterOut(
- *   objectPredicate (value any, key string, object Object)=>Promise|boolean
- * )(object) -> rejectedObject Promise|Object
- *
- * filterOut(
- *   setPredicate (value any, value, set Set)=>Promise|boolean
- * )(set) -> rejectedSet Promise|Set
- *
- * filterOut(
- *   mapPredicate (value any, key any, map Map)=>Promise|boolean
- * )(map) -> rejectedMap Promise|Map
- *
- * filterOut(
- *   predicate (value any)=>Promise|boolean
- * )(generatorFunction GeneratorFunction) -> rejectingGeneratorFunction GeneratorFunction
- *
- * filterOut(
- *   predicate (value any)=>Promise|boolean
- * )(asyncGeneratorFunction AsyncGeneratorFunction) -> rejectingAsyncGeneratorFunction AsyncGeneratorFunction
- *
- * filterOut(
- *   predicate (value any)=>Promise|boolean
- * )(reducer Reducer) -> rejectingReducer Reducer
- * ```
- *
- * @description
- * The inverse of `filter`. Values that test true by the predicate are filtered out, or "rejected".
- */
-declare function filterOut(predicate: any): any;

package/x/find.d.ts

@@ -1,34 +0,0 @@
-export = find;
-/**
- * @name find
- *
- * @synopsis
- * ```coffeescript [specscript]
- * Foldable<T> = Iterable<T>|AsyncIterable<T>|{ reduce: (any, T)=>any }|Object<T>
- *
- * var T any,
- *   predicate T=>Promise|boolean,
- *   foldable Foldable<T>,
- *   result Promise|T|undefined
- *
- * find(predicate)(foldable) -> result
- * ```
- *
- * @description
- * Get the first element in a foldable collection that matches a predicate.
- *
- * ```javascript [playground]
- * import find from 'https://unpkg.com/rubico/dist/x/find.es.js'
- *
- * const users = [
- *   { name: 'John', age: 16 },
- *   { name: 'Jill', age: 32 },
- *   { name: 'John', age: 51 },
- * ]
- *
- * console.log(
- *   find(user => user.age > 50)(users),
- * ) // { name: 'John', age: 51 }
- * ```
- */
-declare function find(predicate: any): (value: any) => any;

package/x/findIndex.d.ts

@@ -1,25 +0,0 @@
-export = findIndex;
-/**
- * @name findIndex
- *
- * @synopsis
- * ```coffeescript [specscript]
- * findIndex(predicate function)(array Array) -> index Promise|number
- * ```
- *
- * @description
- * Returns the index of the first element in an array that satisfies the predicate. Returns -1 if no element satisfies the predicate.
- *
- * ```javascript [playground]
- * import findIndex from 'https://unpkg.com/rubico/dist/x/findIndex.es.js'
- *
- * const oddNumberIndex = findIndex(function isOdd(number) {
- *   return number % 2 == 1
- * })([2, 3, 5])
- *
- * console.log(oddNumberIndex) // 1
- * ```
- *
- * @since 1.6.26
- */
-declare function findIndex(predicate: any): (array: any) => any;