rubico 2.7.5 → 2.7.7

package/_internal/streamExtend.d.ts

@@ -1,17 +0,0 @@
-export = streamExtend;
-/**
- * @name streamExtend
- *
- * @synopsis
- * ```coffeescript [specscript]
- * Stream = { read: function, write: function }
- *
- * streamExtend<
- *   stream Stream,
- *   values Stream|any,
- * >(stream, values) -> Promise|stream
- * ```
- *
- * @TODO maybe support `.read`
- */
-declare function streamExtend(stream: any, values: any): any;

package/_internal/stringFilter.d.ts

@@ -1,17 +0,0 @@
-export = stringFilter;
-/**
- * @name stringMap
- *
- * @synopsis
- * ```coffeescript [specscript]
- * stringMap<
- *   character string,
- *   str String<character>,
- *   mapper character=>Promise|string|any,
- * >(str, mapper) -> stringWithCharactersMapped string
- * ```
- *
- * @description
- * Filter a string's characters by predicate.
- */
-declare function stringFilter(string: any, predicate: any): any;

package/_internal/stringFlatMap.d.ts

@@ -1,22 +0,0 @@
-export = stringFlatMap;
-/**
- * @name stringFlatMap
- *
- * @synopsis
- * ```coffeescript [specscript]
- * Stream<T> = { read: ()=>T, write: T=>() }
- * Monad<T> = Array<T>|String<T>|Set<T>
- *   |TypedArray<T>|Stream<T>|Iterator<Promise|T>
- *   |{ chain: T=>Monad<T> }|{ flatMap: T=>Monad<T> }|Object<T>
- * Reducer<T> = (any, T)=>Promise|any
- * Foldable<T> = Iterable<T>|AsyncIterable<T>|{ reduce: Reducer<T> }|Object<T>
- *
- * stringFlatMap<T>(
- *   string String<T>,
- *   flatMapper T=>Promise|Monad<T>|Foldable<T>|T,
- * ) -> Promise|String<T>
- * ```
- *
- * @related arrayFlatMap
- */
-declare function stringFlatMap(string: any, flatMapper: any): any;

package/_internal/stringMap.d.ts

@@ -1,19 +0,0 @@
-export = stringMap;
-/**
- * @name stringMap
- *
- * @synopsis
- * ```coffeescript [specscript]
- * stringMap<
- *   character string,
- *   str String<character>,
- *   mapper character=>Promise|string|any,
- * >(str, mapper) -> stringWithCharactersMapped string
- * ```
- *
- * @description
- * Apply a mapper concurrently to each character of a string, returning a string result. `mapper` may be asynchronous.
- *
- * @related stringFlatMap
- */
-declare function stringMap(string: any, mapper: any): any;

package/_internal/symbolAsyncIterator.d.ts

@@ -1,11 +0,0 @@
-export = symbolAsyncIterator;
-/**
- * @name symbolAsyncIterator
- *
- * @synopsis
- * symbolAsyncIterator = Symbol.asyncIterator
- *
- * @description
- * Dereferenced `Symbol.asyncIterator`
- */
-declare const symbolAsyncIterator: any;

package/_internal/symbolIterator.d.ts

@@ -1,11 +0,0 @@
-export = symbolIterator;
-/**
- * @name symbolIterator
- *
- * @synopsis
- * symbolIterator = Symbol.iterator
- *
- * @description
- * Dereferenced `Symbol.iterator`
- */
-declare const symbolIterator: any;

package/_internal/tapSync.d.ts

@@ -1,16 +0,0 @@
-export = tapSync;
-/**
- * @name tapSync
- *
- * @synopsis
- * ```coffeescript [specscript]
- * tapSync<
- *   tapper function,
- *   args ...any,
- * >(tapper)(...args) -> args[0]
- * ```
- *
- * @description
- * Call a function with arguments, returning the first argument. Promises are not handled.
- */
-declare function tapSync(func: any): (...args: any[]) => any;

package/_internal/thunkConditional.d.ts

@@ -1,17 +0,0 @@
-export = thunkConditional;
-/**
- * @name thunkConditional
- *
- * @synopsis
- * ```coffeescript [specscript]
- * thunkConditional<
- *   conditionalExpression boolean,
- *   thunkOnTruthy ()=>any,
- *   thunkOnFalsy ()=>any,
- * >(conditionalExpression, thunkOnTruthy, thunkOnFalsy) -> any
- * ```
- *
- * @description
- * Like the conditional operator `a ? b : c` but for thunks.
- */
-declare function thunkConditional(conditionalExpression: any, thunkOnTruthy: any, thunkOnFalsy: any): any;

package/_internal/thunkify1.d.ts

@@ -1,16 +0,0 @@
-export = thunkify1;
-/**
- * @name thunkify1
- *
- * @synopsis
- * ```coffeescript [specscript]
- * thunkify1<
- *   arg0 any,
- *   func arg0=>any,
- * >(func, arg0) -> thunk ()=>func(arg0)
- * ```
- *
- * @description
- * Create a thunk from a function and one argument.
- */
-declare function thunkify1(func: any, arg0: any): () => any;

package/_internal/thunkify2.d.ts

@@ -1,17 +0,0 @@
-export = thunkify2;
-/**
- * @name thunkify2
- *
- * @synopsis
- * ```coffeescript [specscript]
- * thunkify2<
- *   arg0 any,
- *   arg1 any,
- *   func (arg0, arg1)=>any,
- * >(func, arg0, arg1) -> thunk ()=>func(arg0, arg1)
- * ```
- *
- * @description
- * Create a thunk from a function and two arguments.
- */
-declare function thunkify2(func: any, arg0: any, arg1: any): () => any;

package/_internal/thunkify3.d.ts

@@ -1,18 +0,0 @@
-export = thunkify3;
-/**
- * @name thunkify3
- *
- * @synopsis
- * ```coffeescript [specscript]
- * thunkify3<
- *   arg0 any,
- *   arg1 any,
- *   arg2 any,
- *   func (arg0, arg1, arg2)=>any,
- * >(func, arg0, arg1, arg2) -> thunk ()=>func(arg0, arg1, arg2)
- * ```
- *
- * @description
- * Create a thunk from a function and three arguments.
- */
-declare function thunkify3(func: any, arg0: any, arg1: any, arg2: any): () => any;

package/_internal/thunkify4.d.ts

@@ -1,19 +0,0 @@
-export = thunkify4;
-/**
- * @name thunkify4
- *
- * @synopsis
- * ```coffeescript [specscript]
- * thunkify4<
- *   arg0 any,
- *   arg1 any,
- *   arg2 any,
- *   arg3 any,
- *   func (arg0, arg1, arg2, arg3)=>any,
- * >(func, arg0, arg1, arg2, arg3) -> thunk ()=>func(arg0, arg1, arg2, arg3)
- * ```
- *
- * @description
- * Create a thunk from a function and four arguments.
- */
-declare function thunkify4(func: any, arg0: any, arg1: any, arg2: any, arg3: any): () => any;

package/_internal/thunkify5.d.ts

@@ -1,20 +0,0 @@
-export = thunkify5;
-/**
- * @name thunkify5
- *
- * @synopsis
- * ```coffeescript [specscript]
- * thunkify5<
- *   arg0 any,
- *   arg1 any,
- *   arg2 any,
- *   arg3 any,
- *   arg4 any,
- *   func (arg0, arg1, arg2, arg3, arg4)=>any,
- * >(func, arg0, arg1, arg2, arg3, arg4) -> thunk ()=>func(arg0, arg1, arg2, arg3, arg4)
- * ```
- *
- * @description
- * Create a thunk from a function and five arguments.
- */
-declare function thunkify5(func: any, arg0: any, arg1: any, arg2: any, arg3: any, arg4: any): () => any;

package/_internal/thunkifyArgs.d.ts

@@ -1,13 +0,0 @@
-export = thunkifyArgs;
-/**
- * @name thunkifyArgs
- *
- * @synopsis
- * ```coffeescript [specscript]
- * thunkifyArgs(func function, args Array) -> ()=>func(...args)
- * ```
- *
- * @synopsis
- * Create a thunk from a function and an arguments array.
- */
-declare function thunkifyArgs(func: any, args: any): () => any;

package/_internal/timeInLoop.d.ts

@@ -1,25 +0,0 @@
-export = timeInLoop;
-/**
- * @name timeInLoop
- *
- * @synopsis
- * ```coffeescript [specscript]
- * timeInLoop(description string, loopCount number, fn function, options? {
- *   silent?: boolean,
- * }) -> undefined
- * ```
- *
- * @description
- * Logs the amount of time required for a function to run a certain number of times
- *
- * ```js
- * timeInLoop('hello', 1e6, () => 'hello') // hello: 1e+6: 3.474ms
- * ```
- *
- * Reference: https://gist.github.com/funfunction/91b5876a5f562e1e352aed0fcabc3858
- */
-declare function timeInLoop(description: any, loopCount: any, fn: any, options?: {}): {
-    description: any;
-    loopCount: any;
-    duration: number;
-};

package/_internal/timeInLoopAsync.d.ts

@@ -1,23 +0,0 @@
-export = timeInLoopAsync;
-/**
- * @name timeInLoopAsync
- *
- * @synopsis
- * ```coffeescript [specscript]
- * timeInLoop.async(description string, loopCount number, fn function, options? {
- *   silent?: boolean,
- * }) -> undefined
- * ```
- *
- * @description
- * Like timeInLoop, but every call is awaited
- *
- * ```js
- * timeInLoop.async('async hello', 1e6, async () => 'hello') // async hello: 1e+6: 116.006ms
- * ```
- */
-declare function timeInLoopAsync(description: any, loopCount: any, fn: any, options?: {}): Promise<{
-    description: any;
-    loopCount: any;
-    duration: number;
-}>;

package/all.d.ts

@@ -1,100 +0,0 @@
-export = all;
-/**
- * @name all
- *
- * @synopsis
- * ```coffeescript [specscript]
- * all(...args, funcsArray Array<function>) -> result Promise|Array
- *
- * all(funcsArray Array<function>)(...args) -> result Promise|Array
- *
- * all(...args, funcsObject Object<function>) -> result Promise|Object
- *
- * all(funcsObject Object<function>)(...args) -> result Promise|Object
- * ```
- *
- * @description
- * Function executor and composer. Accepts either an array of functions or an object of functions as the values. Calls each function of the provided array or object in parallel with the provided arguments. Returns either an array or object of the results of the function executions.
- *
- * ```javascript [playground]
- * const createArrayOfGreetingsFor = all([
- *   name => `Hi ${name}`,
- *   name => `Hey ${name}`,
- *   name => `Hello ${name}`,
- * ])
- *
- * const arrayOfGreetingsForFred = createArrayOfGreetingsFor('Fred')
- *
- * console.log(arrayOfGreetingsForFred)
- * // ['Hi Fred', 'Hey Fred', 'Hello Fred']
- *
- * const createObjectOfGreetingsFor = all({
- *   hi: name => `Hi ${name}`,
- *   hey: name => `Hey ${name}`,
- *   hello: name => `Hello ${name}`,
- * })
- *
- * const objectOfGreetingsForJane = createObjectOfGreetingsFor('Jane')
- *
- * console.log(objectOfGreetingsForJane)
- * // { hi: 'Hi Jane', hey: 'Hey Jane', hello: 'Hello Jane' }
- * ```
- *
- * `all` can simultaneously compose objects and handle promises.
- *
- * ```javascript [playground]
- * const identity = value => value
- *
- * const userbase = new Map()
- * userbase.set('1', { _id: 1, name: 'John' })
- *
- * const getUserByID = async id => userbase.get(id)
- *
- * const getAndLogUserById = pipe([
- *   all({
- *     id: identity,
- *     user: getUserByID,
- *   }),
- *   tap(({ id, user }) => {
- *     console.log(`Got user ${JSON.stringify(user)} by id ${id}`)
- *   }),
- * ])
- *
- * getAndLogUserById('1') // Got user {"_id":1,"name":"John"} by id 1
- * ```
- *
- * @execution concurrent
- */
-declare function all(...args: any[]): any;
-declare namespace all {
-    /**
-     * @name all.series
-     *
-     * @synopsis
-     * ```coffeescript [specscript]
-     * all.series(...args, funcsArray Array<function>) -> result Promise|Array
-     *
-     * all.series(funcsArray Array<function>)(...args) -> result Promise|Array
-     * ```
-     *
-     * @description
-     * `all` with serial execution.
-     *
-     * ```javascript [playground]
-     * const sleep = ms => () => new Promise(resolve => setTimeout(resolve, ms))
-     *
-     * all.series([
-     *   greeting => console.log(greeting + ' world'),
-     *   sleep(1000),
-     *   greeting => console.log(greeting + ' mom'),
-     *   sleep(1000),
-     *   greeting => console.log(greeting + ' goodbye'),
-     * ])('hello') // hello world
-     *             // hello mom
-     *             // hello goodbye
-     * ```
-     *
-     * @execution series
-     */
-    function series(...args: any[]): any;
-}

package/always.d.ts

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

package/and.d.ts

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

package/assign.d.ts

@@ -1,46 +0,0 @@
-export = assign;
-/**
- * @name assign
- *
- * @synopsis
- * ```coffeescript [specscript]
- * assign(object Object, resolvers Object<function>) -> result Promise|Object
- *
- * assign(resolvers Object<function>)(object Object) -> result Promise|Object
- * ```
- *
- * @description
- * Function executor and composer. Accepts an object of resolver functions and an argument object. Creates a result object from the argument object, evaluates each resolver with the argument object, and assigns to the result object the evaluations at the corresponding resolver keys.
- *
- * ```javascript [playground]
- * const assignSquaredAndCubed = assign({
- *   squared: ({ number }) => number ** 2,
- *   cubed: ({ number }) => number ** 3,
- * })
- *
- * console.log(assignSquaredAndCubed({ number: 2 }))
- * // { number: 2, squared: 4, cubed: 8 }
- *
- * console.log(assignSquaredAndCubed({ number: 3 }))
- * // { number: 3, squared: 9, cubed: 27 }
- * ```
- *
- * Any of the resolvers may be asynchronous and return Promises.
- *
- * ```javascript [playground]
- * const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
- *
- * const asyncAssignTotal = assign({
- *   async total({ numbers }) {
- *     await sleep(500)
- *     return numbers.reduce((a, b) => a + b)
- *   },
- * })
- *
- * asyncAssignTotal({ numbers: [1, 2, 3, 4, 5] }).then(console.log)
- * // { numbers: [1, 2, 3, 4, 5], total: 15 }
- * ```
- *
- * @execution concurrent
- */
-declare function assign(arg0: any, arg1: any): any;

package/compose.d.ts

@@ -1,25 +0,0 @@
-export = compose;
-/**
- * @name compose
- *
- * @synopsis
- * ```coffeescript [specscript]
- * compose(funcs Array<function>)(...args) -> result Promise|any
- *
- * compose(...args, funcs Array<function>) -> result Promise|any
- * ```
- *
- * @description
- * Creates a function composition from an array of functions, where each function passes its return value as a single argument to the previous function until all functions have executed. The last function is called with the arguments to the composition, while the result of a function composition is the return value of its first function. If any function of the composition is asynchronous, the result of the execution is a Promise. `compose` is effectively `pipe` in reverse.
- *
- * ```javascript [playground]
- * const f = number => number * 2
- *
- * const g = number => number + 3
- *
- * console.log(
- *   compose(5, [f, g]),
- * ) // 16
- * ```
- */
-declare function compose(...args: any[]): any;

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;