rubico 2.2.3 → 2.3.1

package/_internal/NextIteration.d.ts

@@ -0,0 +1,14 @@
+export = NextIteration;
+/**
+ * @name NextIteration
+ *
+ * @synopsis
+ * NextIteration(value any) -> nextIteration { value, done: false }
+ *
+ * @description
+ * Create an object to send for the next iteration
+ */
+declare function NextIteration(value: any): {
+    value: any;
+    done: boolean;
+};

package/_internal/SelfReferencingPromise.d.ts

@@ -0,0 +1,10 @@
+export = SelfReferencingPromise;
+/**
+ * @name SelfReferencingPromise
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * SelfReferencingPromise(basePromise Promise<T>) -> Promise<[T, basePromise]>
+ * ```
+ */
+declare function SelfReferencingPromise(basePromise: any): any;

package/_internal/add.d.ts

@@ -0,0 +1,11 @@
+export = add;
+/**
+ * @name add
+ *
+ * @synopsis
+ * add (a any, b any) -> a + b
+ *
+ * @description
+ * `+` two things
+ */
+declare function add(a: any, b: any): any;

package/_internal/always.d.ts

@@ -0,0 +1,13 @@
+export = always;
+/**
+ * @name always
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * always(value any) -> getter ()=>value
+ * ```
+ *
+ * @description
+ * Create a function that always returns a value.
+ */
+declare function always(value: any): () => any;

package/_internal/areAllValuesNonfunctions.d.ts

@@ -0,0 +1,10 @@
+export = areAllValuesNonfunctions;
+/**
+ * @name areAllValuesNonfunctions
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * areAllValuesNonfunctions(values Array<function|value>) -> boolean
+ * ```
+ */
+declare function areAllValuesNonfunctions(values: any): boolean;

package/_internal/areAnyValuesPromises.d.ts

@@ -0,0 +1,10 @@
+export = areAnyValuesPromises;
+/**
+ * @name areAnyValuesPromises
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * areAnyValuesPromises(values Array) -> boolean
+ * ```
+ */
+declare function areAnyValuesPromises(values: any): boolean;

package/_internal/arrayConditional.d.ts

@@ -0,0 +1,20 @@
+export = arrayConditional;
+/**
+ * @name arrayConditional
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * arrayConditional(
+ *   array Array<function|value>,
+ *   args Array,
+ *   funcsIndex number,
+ * ) -> Promise|any
+ * ```
+ *
+ * @description
+ * Conditional operator `a ? b : c ? d : e ? ...` for functions.
+ *
+ * @TODO isPromise conditional await
+ * @TODO benchmark vs regular promise handling
+ */
+declare function arrayConditional(array: any, args: any, funcsIndex: any): any;

package/_internal/arrayEvery.d.ts

@@ -0,0 +1,10 @@
+export = arrayEvery;
+/**
+ * @name arrayEvery
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * arrayEvery(array Array, predicate ...any=>boolean) -> boolean
+ * ```
+ */
+declare function arrayEvery(array: any, predicate: any): any;

package/_internal/arrayExtend.d.ts

@@ -0,0 +1,13 @@
+export = arrayExtend;
+/**
+ * @name arrayExtend
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * arrayExtend(array Array, values Array) -> array
+ * ```
+ *
+ * @description
+ * Extend an array with values.
+ */
+declare function arrayExtend(array: any, values: any): any;

package/_internal/arrayExtendMap.d.ts

@@ -0,0 +1,20 @@
+export = arrayExtendMap;
+/**
+ * @name arrayExtendMap
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * any -> value; any -> mapped
+ *
+ * arrayExtendMap(
+ *   array Array<mapped>,
+ *   values Array<value>,
+ *   valuesIndex number,
+ *   valuesMapper value=>mapped,
+ * ) -> array
+ * ```
+ *
+ * @description
+ * `arrayExtend` while mapping
+ */
+declare function arrayExtendMap(array: any, values: any, valuesMapper: any, valuesIndex: any): any;

package/_internal/arrayFilter.d.ts

@@ -0,0 +1,16 @@
+export = arrayFilter;
+/**
+ * @name arrayFilter
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * arrayFilter<T>(
+ *   array Array<T>,
+ *   predicate T=>Promise|boolean,
+ * ) -> result Promise|Array<T>
+ * ```
+ *
+ * @description
+ * Filter an array concurrently by predicate. `predicate` may be asynchronous.
+ */
+declare function arrayFilter(array: any, predicate: any): any;

package/_internal/arrayFilterByConditions.d.ts

@@ -0,0 +1,20 @@
+export = arrayFilterByConditions;
+/**
+ * @name arrayFilterByConditions
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * arrayFilterByConditions(
+ *   array Array,
+ *   result Array,
+ *   index number,
+ *   conditions Array<boolean>,
+ * ) -> result
+ * ```
+ *
+ * @description
+ * Filter an array by a boolean array of conditions
+ *
+ * @TODO switch positions of index and conditions
+ */
+declare function arrayFilterByConditions(array: any, result: any, index: any, conditions: any): any;

package/_internal/arrayFind.d.ts

@@ -0,0 +1,15 @@
+export = arrayFind;
+/**
+ * @name arrayFind
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * var T any,
+ *   array Array<T>,
+ *   predicate T=>Promise|boolean,
+ *   result Promise|T|undefined
+ *
+ * arrayFind(array, predicate) -> result
+ * ```
+ */
+declare function arrayFind(array: any, predicate: any): any;

package/_internal/arrayFlatMap.d.ts

@@ -0,0 +1,20 @@
+export = arrayFlatMap;
+/**
+ * @name arrayFlatMap
+ *
+ * @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>
+ *
+ * arrayFlatMap<T>(
+ *   array Array<T>,
+ *   flatMapper T=>Promise|Monad<T>|Foldable<T>|T,
+ * ) -> Promise|Array<T>
+ * ```
+ */
+declare function arrayFlatMap(array: any, flatMapper: any): any;

package/_internal/arrayFlatten.d.ts

@@ -0,0 +1,20 @@
+export = arrayFlatten;
+/**
+ * @name arrayFlatten
+ *
+ * @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>
+ *
+ * arrayFlatten<
+ *   T any,
+ *   array Array<Monad<T>|Foldable<T>|T>
+ * >(array) -> Array<T>
+ * ```
+ */
+declare function arrayFlatten(array: any): any;

package/_internal/arrayForEach.d.ts

@@ -0,0 +1,19 @@
+export = arrayForEach;
+/**
+ * @name arrayForEach
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * var T any,
+ *   array Array<T>,
+ *   callback T=>()
+ *
+ * arrayForEach(array, callback) -> ()
+ * ```
+ *
+ * @description
+ * Call a callback for each item of an iterator. Return a promise if any executions are asynchronous.
+ *
+ * Note: iterator is consumed
+ */
+declare function arrayForEach(array: any, callback: any): any;

package/_internal/arrayJoin.d.ts

@@ -0,0 +1,13 @@
+export = arrayJoin;
+/**
+ * @name arrayJoin
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * arrayJoin(array Array, delimiter string) -> string
+ * ```
+ *
+ * @description
+ * Call `.join` on an array.
+ */
+declare function arrayJoin(array: any, delimiter: any): any;

package/_internal/arrayMap.d.ts

@@ -0,0 +1,16 @@
+export = arrayMap;
+/**
+ * @name arrayMap
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * arrayMap(
+ *   array Array,
+ *   mapper (item any, index number, array Array)=>Promise|any,
+ * ) -> Promise|Array
+ * ```
+ *
+ * @description
+ * Apply a mapper to each item of an array, returning an array. Mapper may be asynchronous.
+ */
+declare function arrayMap(array: any, mapper: any): any;

package/_internal/arrayMapPool.d.ts

@@ -0,0 +1,19 @@
+export = arrayMapPool;
+/**
+ * @name
+ * arrayMapPool
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * arrayMapPool<
+ *   T any,
+ *   array Array<T>
+ *   mapper T=>Promise|any,
+ *   concurrentLimit number,
+ * >(array, mapper, concurrentLimit) -> Promise|Array
+ * ```
+ *
+ * @description
+ * Apply a mapper with limited concurrency to each item of an array, returning an array of results.
+ */
+declare function arrayMapPool(array: any, mapper: any, concurrentLimit: any): any[] | Promise<any>;

package/_internal/arrayMapSeries.d.ts

@@ -0,0 +1,17 @@
+export = arrayMapSeries;
+/**
+ * @name arrayMapSeries
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * arrayMapSeries<
+ *   T any,
+ *   array Array<T>,
+ *   mapper T=>Promise|any,
+ * >(array, mapper) -> mappedInSeries Promise|Array
+ * ```
+ *
+ * @description
+ * Apply a mapper in series to each item of an array, returning an array of results.
+ */
+declare function arrayMapSeries(array: any, mapper: any): any;

package/_internal/arrayPush.d.ts

@@ -0,0 +1,11 @@
+export = arrayPush;
+/**
+ * @name arrayPush
+ *
+ * @synopsis
+ * arrayPush(
+ *   array Array,
+ *   value any
+ * ) -> array
+ */
+declare function arrayPush(array: any, value: any): any;

package/_internal/arrayReduce.d.ts

@@ -0,0 +1,14 @@
+export = arrayReduce;
+/**
+ * @name arrayReduce
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * arrayReduce<T>(
+ *   array Array<T>,
+ *   reducer (any, T)=>Promise|any,
+ *   result any,
+ * ) -> Promise|result
+ * ```
+ */
+declare function arrayReduce(array: any, reducer: any, result: any): any;

package/_internal/arraySome.d.ts

@@ -0,0 +1,13 @@
+export = arraySome;
+/**
+ * @name arraySome
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * arraySome(
+ *   array Array,
+ *   predicate any=>Promise|boolean,
+ * ) -> boolean
+ * ```
+ */
+declare function arraySome(array: any, predicate: any): boolean | Promise<boolean>;

package/_internal/asyncIteratorEvery.d.ts

@@ -0,0 +1,16 @@
+export = asyncIteratorEvery;
+/**
+ * @name asyncIteratorEvery
+ *
+ * @synopsis
+ * var T any,
+ *   asyncIterator AsyncIterator<T>,
+ *   predicate T=>Promise|boolean,
+ *   promisesInFlight Set<Promise<[T, Promise]>>,
+ *   maxConcurrency number
+ *
+ * asyncIteratorEvery(
+ *   asyncIterator, predicate, promisesInFlight, maxConcurrency,
+ * ) -> Promise<boolean>
+ */
+declare function asyncIteratorEvery(asyncIterator: any, predicate: any, promisesInFlight: any, maxConcurrency?: number): Promise<boolean>;

package/_internal/asyncIteratorFind.d.ts

@@ -0,0 +1,12 @@
+export = asyncIteratorFind;
+/**
+ * @name asyncIteratorFind
+ *
+ * @synopsis
+ * var T any,
+ *   asyncIterator AsyncIterator<T>,
+ *   predicate T=>Promise|boolean
+ *
+ * asyncIteratorFind(asyncIterator, predicate) -> Promise|T|undefined
+ */
+declare function asyncIteratorFind(asyncIterator: any, predicate: any): Promise<any>;

package/_internal/asyncIteratorForEach.d.ts

@@ -0,0 +1,17 @@
+export = asyncIteratorForEach;
+/**
+ * @name asyncIteratorForEach
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * var T any,
+ *   asyncIterator AsyncIterator<T>,
+ *   callback T=>()
+ *
+ * asyncIteratorForEach(asyncIterator, callback) -> Promise<>
+ * ```
+ *
+ * @description
+ * Execute a callback function for each item of an async iterator
+ */
+declare function asyncIteratorForEach(asyncIterator: any, callback: any): Promise<any>;

package/_internal/asyncIteratorReduce.d.ts

@@ -0,0 +1,14 @@
+export = asyncIteratorReduce;
+/**
+ * @name asyncIteratorReduce
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * asyncIteratorReduce(
+ *   asyncIterator AsyncIterator<T>,
+ *   reducer (any, T)=>Promise|any,
+ *   result any,
+ * ) -> result any
+ * ```
+ */
+declare function asyncIteratorReduce(asyncIterator: any, reducer: any, result: any): Promise<any>;

package/_internal/asyncIteratorSome.d.ts

@@ -0,0 +1,16 @@
+export = asyncIteratorSome;
+/**
+ * @name asyncIteratorSome
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * asyncIteratorSome(
+ *   iterator Iterator|AsyncIterator,
+ *   predicate any=>Promise|boolean,
+ *   index number,
+ *   promisesInFlight Set<Promise>,
+ *   maxConcurrency number=20,
+ * ) -> boolean
+ * ```
+ */
+declare function asyncIteratorSome(iterator: any, predicate: any, promisesInFlight: any, maxConcurrency?: number): Promise<boolean>;

package/_internal/binaryExtend.d.ts

@@ -0,0 +1,16 @@
+export = binaryExtend;
+/**
+ * @name binaryExtend
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * binaryExtend(
+ *   typedArray TypedArray,
+ *   array Array|TypedArray|any,
+ * ) -> concatenatedTypedArray
+ * ```
+ *
+ * @description
+ * Types branching for _binaryExtend
+ */
+declare function binaryExtend(typedArray: any, array: any): any;

package/_internal/bufferAlloc.d.ts

@@ -0,0 +1,8 @@
+export = bufferAlloc;
+/**
+ * @name bufferAlloc
+ *
+ * @synopsis
+ * Dereferenced `Buffer.alloc` or noop
+ */
+declare const bufferAlloc: any;

package/_internal/callConcat.d.ts

@@ -0,0 +1,8 @@
+export = callConcat;
+/**
+ * @name callConcat
+ *
+ * @synopsis
+ * callConcat(object Object, values any) -> object.concat(values)
+ */
+declare function callConcat(object: any, values: any): any;

package/_internal/callPropBinary.d.ts

@@ -0,0 +1,18 @@
+export = callPropBinary;
+/**
+ * @name callPropBinary
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * callPropBinary(
+ *   value object,
+ *   property string,
+ *   arg0 any,
+ *   arg1 any,
+ * ) -> value[property](arg0, arg1)
+ * ```
+ *
+ * @description
+ * Call a property function on a value with two arguments.
+ */
+declare function callPropBinary(value: any, property: any, arg0: any, arg1: any): any;

package/_internal/callPropUnary.d.ts

@@ -0,0 +1,17 @@
+export = callPropUnary;
+/**
+ * @name callPropUnary
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * callPropUnary(
+ *   value object,
+ *   property string,
+ *   arg0 any,
+ * ) -> value[property](arg0)
+ * ```
+ *
+ * @description
+ * Call a property function on a value with a single argument.
+ */
+declare function callPropUnary(value: any, property: any, arg0: any): any;

package/_internal/catcherApply.d.ts

@@ -0,0 +1,17 @@
+export = catcherApply;
+/**
+ * @name catcherApply
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * catcherApply<
+ *   args ...any,
+ *   err Error|any,
+ *   catcher (err, ...args)=>any,
+ * >(catcher, err, args) -> catcher(err, ...args)
+ * ```
+ *
+ * @description
+ * Apply an error and arguments to a catcher.
+ */
+declare function catcherApply(catcher: any, err: any, args: any): any;

package/_internal/copyDeep.d.ts

@@ -0,0 +1,13 @@
+export = copyDeep;
+/**
+ * @name copyDeep
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * copyDeep(value Array|Object) -> deepCopy Array|Object
+ * ```
+ *
+ * @catchphrase
+ * Deep copy objects or arrays.
+ */
+declare function copyDeep(value: any): any;

package/_internal/curry2.d.ts

@@ -0,0 +1,21 @@
+export = curry2;
+/**
+ * @name curry2
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * __ = Symbol('placeholder')
+ *
+ * curry2(
+ *   baseFunc function,
+ *   arg0 __|any,
+ *   arg1 __|any,
+ * ) -> function
+ * ```
+ *
+ * @description
+ * Curry a binary function.
+ *
+ * Note: exactly one argument must be the placeholder
+ */
+declare function curry2(baseFunc: any, arg0: any, arg1: any): (arg0: any) => any;

package/_internal/curry3.d.ts

@@ -0,0 +1,22 @@
+export = curry3;
+/**
+ * @name curry3
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * __ = Symbol('placeholder')
+ *
+ * curry3(
+ *   baseFunc function,
+ *   arg0 __|any,
+ *   arg1 __|any,
+ *   arg2 __|any
+ * ) -> function
+ * ```
+ *
+ * @description
+ * Curry a 3-ary function.
+ *
+ * Note: exactly one argument must be the placeholder
+ */
+declare function curry3(baseFunc: any, arg0: any, arg1: any, arg2: any): (arg0: any) => any;

package/_internal/curry4.d.ts

@@ -0,0 +1,23 @@
+export = curry4;
+/**
+ * @name curry4
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * __ = Symbol('placeholder')
+ *
+ * curry4(
+ *   baseFunc function,
+ *   arg0 __|any,
+ *   arg1 __|any,
+ *   arg2 __|any,
+ *   arg3 __|any,
+ * ) -> function
+ * ```
+ *
+ * @description
+ * Curry a 4-ary function.
+ *
+ * Note: exactly one argument must be the placeholder
+ */
+declare function curry4(baseFunc: any, arg0: any, arg1: any, arg2: any, arg3: any): (arg0: any) => any;

package/_internal/curry5.d.ts

@@ -0,0 +1,24 @@
+export = curry5;
+/**
+ * @name curry5
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * __ = Symbol('placeholder')
+ *
+ * curry5(
+ *   baseFunc function,
+ *   arg0 __|any,
+ *   arg1 __|any,
+ *   arg2 __|any,
+ *   arg3 __|any,
+ *   arg4 __|any,
+ * ) -> function
+ * ```
+ *
+ * @description
+ * Curry a 5-ary function.
+ *
+ * Note: exactly one argument must be the placeholder
+ */
+declare function curry5(baseFunc: any, arg0: any, arg1: any, arg2: any, arg3: any, arg4: any): (arg0: any) => any;