rubico 2.7.3 → 2.7.4

package/_internal/arrayForEachSeries.js

@@ -30,7 +30,7 @@ const _arrayForEachSeriesAsync = async function (array, callback, index) {
  * ```
  *
  * @description
- * Call a callback for each item of an array in series. Return a promise if any executions are asynchronous.
+ * Call a callback for each element of an array in series. Return a promise if any executions are asynchronous.
  */
 const arrayForEachSeries = function (array, callback) {
   const length = array.length

package/_internal/arrayMap.d.ts

@@ -6,11 +6,11 @@ export = arrayMap;
  * ```coffeescript [specscript]
  * arrayMap(
  *   array Array,
- *   mapper (item any, index number, array Array)=>Promise|any,
+ *   mapper (element 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.
+ * Apply a mapper to each element of an array, returning an array. Mapper may be asynchronous.
  */
 declare function arrayMap(array: any, mapper: any): any;

package/_internal/arrayMap.js

@@ -8,12 +8,12 @@ const promiseAll = require('./promiseAll')
  * ```coffeescript [specscript]
  * arrayMap(
  *   array Array,
- *   mapper (item any, index number, array Array)=>Promise|any,
+ *   mapper (element 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.
+ * Apply a mapper to each element of an array, returning an array. Mapper may be asynchronous.
  */
 const arrayMap = function (array, mapper) {
   const arrayLength = array.length,
@@ -22,11 +22,11 @@ const arrayMap = function (array, mapper) {
     isAsync = false
 
   while (++index < arrayLength) {
-    const resultItem = mapper(array[index], index, array)
-    if (isPromise(resultItem)) {
+    const resultElement = mapper(array[index], index, array)
+    if (isPromise(resultElement)) {
       isAsync = true
     }
-    result[index] = resultItem
+    result[index] = resultElement
   }
   return isAsync ? promiseAll(result) : result
 }

package/_internal/arrayMapPool.d.ts

@@ -14,6 +14,6 @@ export = arrayMapPool;
  * ```
  *
  * @description
- * Apply a mapper with limited concurrency to each item of an array, returning an array of results.
+ * Apply a mapper with limited concurrency to each element of an array, returning an array of results.
  */
 declare function arrayMapPool(array: any, mapper: any, concurrentLimit: any): any[] | Promise<any>;

package/_internal/arrayMapPool.js

@@ -20,7 +20,7 @@ const promiseRace = require('./promiseRace')
  * ```
  *
  * @description
- * Apply a function `f` with limited concurrency to each item of an array, returning a Promise of an array of results.
+ * Apply a function `f` with limited concurrency to each element of an array, returning a Promise of an array of results.
  */
 const arrayMapPoolAsync = async function (
   array, f, concurrencyLimit, result, index, promises,
@@ -30,14 +30,14 @@ const arrayMapPoolAsync = async function (
     if (promises.size >= concurrencyLimit) {
       await promiseRace(promises)
     }
-    const resultItem = f(array[index])
-    if (isPromise(resultItem)) {
-      const selfDeletingPromise = resultItem.then(
+    const resultElement = f(array[index])
+    if (isPromise(resultElement)) {
+      const selfDeletingPromise = resultElement.then(
         tapSync(() => promises.delete(selfDeletingPromise)))
       promises.add(selfDeletingPromise)
       result[index] = selfDeletingPromise
     } else {
-      result[index] = resultItem
+      result[index] = resultElement
     }
   }
   return promiseAll(result)
@@ -52,24 +52,24 @@ const arrayMapPoolAsync = async function (
  * ```
  *
  * @description
- * Apply a function `f` with limited concurrency to each item of an array, returning an array of results.
+ * Apply a function `f` with limited concurrency to each element of an array, returning an array of results.
  */
 const arrayMapPool = function (array, concurrency, f) {
   const arrayLength = array.length,
     result = Array(arrayLength)
   let index = -1
   while (++index < arrayLength) {
-    const resultItem = f(array[index])
-    if (isPromise(resultItem)) {
+    const resultElement = f(array[index])
+    if (isPromise(resultElement)) {
       const promises = new Set(),
-        selfDeletingPromise = resultItem.then(
+        selfDeletingPromise = resultElement.then(
           tapSync(() => promises.delete(selfDeletingPromise)))
       promises.add(selfDeletingPromise)
       result[index] = selfDeletingPromise
       return arrayMapPoolAsync(
         array, f, concurrency, result, index, promises)
     }
-    result[index] = resultItem
+    result[index] = resultElement
   }
   return result
 }

package/_internal/arrayMapRate.js

@@ -28,14 +28,14 @@ const arrayMapRate = async function (array, rate, f) {
       await sleep(minPeriodMs - lastExecutionTime)
     }
     const start = performance.now()
-    let resultItem = f(array[index], index, array)
-    if (isPromise(resultItem)) {
-      resultItem = await resultItem
+    let resultElement = f(array[index], index, array)
+    if (isPromise(resultElement)) {
+      resultElement = await resultElement
     }
     const end = performance.now()
     const executionTime = end - start
     lastExecutionTime = executionTime
-    result[index] = resultItem
+    result[index] = resultElement
   }
   const totalEnd = performance.now()
   return result

package/_internal/arrayMapSeries.d.ts

@@ -12,6 +12,6 @@ export = arrayMapSeries;
  * ```
  *
  * @description
- * Apply a mapper in series to each item of an array, returning an array of results.
+ * Apply a mapper in series to each element of an array, returning an array of results.
  */
 declare function arrayMapSeries(array: any, mapper: any): any;

package/_internal/arrayMapSeries.js

@@ -20,15 +20,15 @@ const objectSet = require('./objectSet')
  * ```
  *
  * @description
- * Apply a mapper in series to each item of an array, returning a Promise of an array of results. `mapper` can be asynchronous.
+ * Apply a mapper in series to each element of an array, returning a Promise of an array of results. `mapper` can be asynchronous.
  */
 const arrayMapSeriesAsync = async function (
   array, mapper, result, index,
 ) {
   const arrayLength = array.length
   while (++index < arrayLength) {
-    const resultItem = mapper(array[index], index)
-    result[index] = isPromise(resultItem) ? await resultItem : resultItem
+    const resultElement = mapper(array[index], index)
+    result[index] = isPromise(resultElement) ? await resultElement : resultElement
   }
   return result
 }
@@ -46,7 +46,7 @@ const arrayMapSeriesAsync = async function (
  * ```
  *
  * @description
- * Apply a mapper in series to each item of an array, returning an array of results.
+ * Apply a mapper in series to each element of an array, returning an array of results.
  */
 const arrayMapSeries = function (array, mapper) {
   const arrayLength = array.length,
@@ -54,13 +54,13 @@ const arrayMapSeries = function (array, mapper) {
   let index = -1
 
   while (++index < arrayLength) {
-    const resultItem = mapper(array[index], index)
-    if (isPromise(resultItem)) {
-      return resultItem.then(funcConcat(
+    const resultElement = mapper(array[index], index)
+    if (isPromise(resultElement)) {
+      return resultElement.then(funcConcat(
         curry3(objectSet, result, index, __),
         curry4(arrayMapSeriesAsync, array, mapper, __, index)))
     }
-    result[index] = resultItem
+    result[index] = resultElement
   }
   return result
 }

package/_internal/arrayMapWithIndex.js

@@ -15,18 +15,18 @@ const promiseAll = require('./promiseAll')
  * ```
  *
  * @description
- * Apply an indexed mapper to each item of an array, returning an array of results.
+ * Apply an indexed mapper to each element of an array, returning an array of results.
  */
 const arrayMapWithIndex = function (array, mapper) {
   const arrayLength = array.length,
     result = Array(arrayLength)
   let index = -1, isAsync = false
   while (++index < arrayLength) {
-    const resultItem = mapper(array[index], index, array)
-    if (isPromise(resultItem)) {
+    const resultElement = mapper(array[index], index, array)
+    if (isPromise(resultElement)) {
       isAsync = true
     }
-    result[index] = resultItem
+    result[index] = resultElement
   }
   return isAsync ? promiseAll(result) : result
 }

package/_internal/arrayReduce.js

@@ -16,7 +16,7 @@ const curry4 = require('./curry4')
  * ```
  *
  * @description
- * Execute a reducer for each item of an array, returning a Promise of a single value.
+ * Execute a reducer for each element of an array, returning a Promise of a single value.
  */
 const arrayReduceAsync = async function (
   array, reducer, result, index,

package/_internal/asyncGeneratorFunctionForEach.js

@@ -15,15 +15,15 @@ const always = require('./always')
  * ```
  *
  * @description
- * Create an async generator executor that executes a callback for each item of an async generator generated by an async generator function.
+ * Create an async generator executor that executes a callback for each element of an async generator generated by an async generator function.
  */
 const asyncGeneratorFunctionForEach = (
   asyncGeneratorFunction, callback,
 ) => async function* executingCallbackForEach(...args) {
   const promises = [],
     asyncIterator = asyncGeneratorFunction(...args)
-  for await (const item of asyncIterator) {
-    const operation = callback(item)
+  for await (const element of asyncIterator) {
+    const operation = callback(element)
     if (isPromise(operation)) {
       promises.push(operation)
     }

package/_internal/asyncGeneratorFunctionMap.js

@@ -13,7 +13,7 @@
  * ```
  *
  * @description
- * Create a mapping async generator function from an async generator function and a mapper. A mapping async generator function produces async mapping generators that apply the mapper to each item of the original async generator.
+ * Create a mapping async generator function from an async generator function and a mapper. A mapping async generator function produces async mapping generators that apply the mapper to each element of the original async generator.
  *
  * `mapper` may be asynchronous.
  *
@@ -21,8 +21,8 @@
  */
 const asyncGeneratorFunctionMap = function (asyncGeneratorFunc, mapper) {
   return async function* mappingAsyncGeneratorFunc(...args) {
-    for await (const item of asyncGeneratorFunc(...args)) {
-      yield mapper(item)
+    for await (const element of asyncGeneratorFunc(...args)) {
+      yield mapper(element)
     }
   }
 }

package/_internal/asyncIteratorFind.js

@@ -13,13 +13,13 @@ const isPromise = require('./isPromise')
 const asyncIteratorFind = async function (asyncIterator, predicate) {
   let iteration = await asyncIterator.next()
   while (!iteration.done) {
-    const item = iteration.value
-    let predication = predicate(item)
+    const element = iteration.value
+    let predication = predicate(element)
     if (isPromise(predication)) {
       predication = await predication
     }
     if (predication) {
-      return item
+      return element
     }
     iteration = await asyncIterator.next()
   }

package/_internal/asyncIteratorForEach.d.ts

@@ -12,6 +12,6 @@ export = asyncIteratorForEach;
  * ```
  *
  * @description
- * Execute a callback function for each item of an async iterator
+ * Execute a callback function for each element of an async iterator
  */
 declare function asyncIteratorForEach(asyncIterator: any, callback: any): Promise<any>;

package/_internal/asyncIteratorForEach.js

@@ -15,12 +15,12 @@ const always = require('./always')
  * ```
  *
  * @description
- * Execute a callback function for each item of an async iterator
+ * Execute a callback function for each element of an async iterator
  */
 const asyncIteratorForEach = async function (asyncIterator, callback) {
   const promises = []
-  for await (const item of asyncIterator) {
-    const operation = callback(item)
+  for await (const element of asyncIterator) {
+    const operation = callback(element)
     if (isPromise(operation)) {
       promises.push(operation)
     }

package/_internal/asyncIteratorForEachSeries.js

@@ -13,11 +13,11 @@ const isPromise = require('./isPromise')
  * ```
  *
  * @description
- * Execute a callback function for each item of an async iterator in series.
+ * Execute a callback function for each element of an async iterator in series.
  */
 const asyncIteratorForEachSeries = async function (asyncIterator, callback) {
-  for await (const item of asyncIterator) {
-    const operation = callback(item)
+  for await (const element of asyncIterator) {
+    const operation = callback(element)
     if (isPromise(operation)) {
       await operation
     }

package/_internal/asyncIteratorToArray.js

@@ -16,8 +16,8 @@
  */
 const asyncIteratorToArray = async function (asyncIterator) {
   const result = []
-  for await (const item of asyncIterator) {
-    result.push(item)
+  for await (const element of asyncIterator) {
+    result.push(element)
   }
   return result
 }

package/_internal/copyDeep.js

@@ -4,13 +4,13 @@ const isArray = require('./isArray')
 const objectCopyDeep = function (object) {
   const result = {}
   for (const key in object) {
-    const item = object[key]
-    if (isArray(item)) {
-      result[key] = arrayCopyDeep(item)
-    } else if (item != null && item.constructor == Object) {
-      result[key] = objectCopyDeep(item)
+    const element = object[key]
+    if (isArray(element)) {
+      result[key] = arrayCopyDeep(element)
+    } else if (element != null && element.constructor == Object) {
+      result[key] = objectCopyDeep(element)
     } else {
-      result[key] = item
+      result[key] = element
     }
   }
   return result
@@ -22,13 +22,13 @@ const arrayCopyDeep = function (array) {
     result = []
   let index = -1
   while (++index < length) {
-    const item = array[index]
-    if (isArray(item)) {
-      result[index] = arrayCopyDeep(item)
-    } else if (item != null && item.constructor == Object) {
-      result[index] = objectCopyDeep(item)
+    const element = array[index]
+    if (isArray(element)) {
+      result[index] = arrayCopyDeep(element)
+    } else if (element != null && element.constructor == Object) {
+      result[index] = objectCopyDeep(element)
     } else {
-      result[index] = item
+      result[index] = element
     }
   }
   return result

package/_internal/funcAll.js

@@ -16,11 +16,11 @@ const funcAll = funcs => function allFuncs(...args) {
     result = Array(funcsLength)
   let funcsIndex = -1, isAsync = false
   while (++funcsIndex < funcsLength) {
-    const resultItem = funcs[funcsIndex](...args)
-    if (isPromise(resultItem)) {
+    const resultElement = funcs[funcsIndex](...args)
+    if (isPromise(resultElement)) {
       isAsync = true
     }
-    result[funcsIndex] = resultItem
+    result[funcsIndex] = resultElement
   }
   return isAsync ? promiseAll(result) : result
 }

package/_internal/funcAllSeries.js

@@ -23,8 +23,8 @@ const objectSet = require('./objectSet')
 const asyncFuncAllSeries = async function (funcs, args, result, funcsIndex) {
   const funcsLength = funcs.length
   while (++funcsIndex < funcsLength) {
-    const resultItem = funcs[funcsIndex](...args)
-    result[funcsIndex] = isPromise(resultItem) ? await resultItem : resultItem
+    const resultElement = funcs[funcsIndex](...args)
+    result[funcsIndex] = isPromise(resultElement) ? await resultElement : resultElement
   }
   return result
 }
@@ -43,13 +43,13 @@ const funcAllSeries = funcs => function allFuncsSeries(...args) {
   const funcsLength = funcs.length, result = []
   let funcsIndex = -1
   while (++funcsIndex < funcsLength) {
-    const resultItem = funcs[funcsIndex](...args)
-    if (isPromise(resultItem)) {
-      return resultItem.then(funcConcat(
+    const resultElement = funcs[funcsIndex](...args)
+    if (isPromise(resultElement)) {
+      return resultElement.then(funcConcat(
         curry3(objectSet, result, funcsIndex, __),
         curry4(asyncFuncAllSeries, funcs, args, __, funcsIndex)))
     }
-    result[funcsIndex] = resultItem
+    result[funcsIndex] = resultElement
   }
   return result
 }

package/_internal/funcObjectAll.js

@@ -21,11 +21,11 @@ const objectSet = require('./objectSet')
 const funcObjectAll = funcs => function objectAllFuncs(...args) {
   const result = {}, promises = []
   for (const key in funcs) {
-    const resultItem = funcs[key](...args)
-    if (isPromise(resultItem)) {
-      promises.push(resultItem.then(curry3(objectSet, result, key, __)))
+    const resultElement = funcs[key](...args)
+    if (isPromise(resultElement)) {
+      promises.push(resultElement.then(curry3(objectSet, result, key, __)))
     } else {
-      result[key] = resultItem
+      result[key] = resultElement
     }
   }
   return promises.length == 0 ? result : promiseAll(promises).then(always(result))

package/_internal/functionArrayAll.js

@@ -15,11 +15,11 @@ const functionArrayAll = function (funcs, args) {
   let funcsIndex = -1, isAsync = false
   while (++funcsIndex < funcsLength) {
     const f = funcs[funcsIndex]
-    const resultItem = typeof f == 'function' ? f(...args) : f
-    if (isPromise(resultItem)) {
+    const resultElement = typeof f == 'function' ? f(...args) : f
+    if (isPromise(resultElement)) {
       isAsync = true
     }
-    result[funcsIndex] = resultItem
+    result[funcsIndex] = resultElement
   }
   return isAsync ? promiseAll(result) : result
 }

package/_internal/functionArrayAllSeries.js

@@ -23,8 +23,8 @@ const objectSet = require('./objectSet')
 const asyncFunctionArrayAllSeries = async function (funcs, args, result, funcsIndex) {
   const funcsLength = funcs.length
   while (++funcsIndex < funcsLength) {
-    const resultItem = funcs[funcsIndex](...args)
-    result[funcsIndex] = isPromise(resultItem) ? await resultItem : resultItem
+    const resultElement = funcs[funcsIndex](...args)
+    result[funcsIndex] = isPromise(resultElement) ? await resultElement : resultElement
   }
   return result
 }
@@ -41,13 +41,13 @@ const functionArrayAllSeries = function (funcs, args) {
   const funcsLength = funcs.length, result = []
   let funcsIndex = -1
   while (++funcsIndex < funcsLength) {
-    const resultItem = funcs[funcsIndex](...args)
-    if (isPromise(resultItem)) {
-      return resultItem.then(funcConcat(
+    const resultElement = funcs[funcsIndex](...args)
+    if (isPromise(resultElement)) {
+      return resultElement.then(funcConcat(
         curry3(objectSet, result, funcsIndex, __),
         curry4(asyncFunctionArrayAllSeries, funcs, args, __, funcsIndex)))
     }
-    result[funcsIndex] = resultItem
+    result[funcsIndex] = resultElement
   }
   return result
 }

package/_internal/functionObjectAll.js

@@ -20,11 +20,11 @@ const functionObjectAll = function (funcs, args) {
   const result = {}, promises = []
   for (const key in funcs) {
     const f = funcs[key]
-    const resultItem = typeof f == 'function' ? f(...args) : f
-    if (isPromise(resultItem)) {
-      promises.push(resultItem.then(curry3(objectSet, result, key, __)))
+    const resultElement = typeof f == 'function' ? f(...args) : f
+    if (isPromise(resultElement)) {
+      promises.push(resultElement.then(curry3(objectSet, result, key, __)))
     } else {
-      result[key] = resultItem
+      result[key] = resultElement
     }
   }
   return promises.length == 0 ? result : promiseAll(promises).then(always(result))

package/_internal/generatorFunctionForEach.js

@@ -15,15 +15,15 @@ const always = require('./always')
  * ```
  *
  * @description
- * Create a generator executor that executes a callback for each item of a generator generated by a generator function. The executor may return a promise if any execution is asynchronous.
+ * Create a generator executor that executes a callback for each element of a generator generated by a generator function. The executor may return a promise if any execution is asynchronous.
  */
 const generatorFunctionForEach = (
   generatorFunction, callback,
 ) => function* executingCallbackForEach(...args) {
   const promises = [],
     generator = generatorFunction(...args)
-  for (const item of generator) {
-    const operation = callback(item)
+  for (const element of generator) {
+    const operation = callback(element)
     if (isPromise(operation)) {
       promises.push(operation)
     }

package/_internal/generatorFunctionMap.js

@@ -12,15 +12,15 @@
  * ```
  *
  * @description
- * Create a mapping generator function from a generator function and a mapper. A mapping generator function produces mapping generators that apply the mapper to each item of the original generator.
+ * Create a mapping generator function from a generator function and a mapper. A mapping generator function produces mapping generators that apply the mapper to each element of the original generator.
  *
  * @TODO playground example
  */
 const generatorFunctionMap = (
   generatorFunc, mapper,
 ) => function* mappingGeneratorFunc(...args) {
-  for (const item of generatorFunc(...args)) {
-    yield mapper(item)
+  for (const element of generatorFunc(...args)) {
+    yield mapper(element)
   }
 }
 

package/_internal/generatorFunctionReduce.js

@@ -19,7 +19,7 @@ const iteratorReduce = require('./iteratorReduce')
  * ```
  *
  * @description
- * Execute a reducer for each item of a generator function, returning a single value.
+ * Execute a reducer for each element of a generator function, returning a single value.
  */
 const generatorFunctionReduce = (
   generatorFunction, reducer, result,

package/_internal/iteratorEvery.js

@@ -16,8 +16,8 @@ const callPropUnary = require('./callPropUnary')
  */
 const iteratorEvery = function (iterator, predicate) {
   const promises = []
-  for (const item of iterator) {
-    const predication = predicate(item)
+  for (const element of iterator) {
+    const predication = predicate(element)
     if (isPromise(predication)) {
       promises.push(predication)
     } else if (!predication) {

package/_internal/iteratorFind.js

@@ -18,13 +18,13 @@ const always = require('./always')
 const iteratorFindAsync = async function (iterator, predicate) {
   let iteration = iterator.next()
   while (!iteration.done) {
-    const item = iteration.value
-    let predication = predicate(item)
+    const element = iteration.value
+    let predication = predicate(element)
     if (isPromise(predication)) {
       predication = await predication
     }
     if (predication) {
-      return item
+      return element
     }
     iteration = iterator.next()
   }
@@ -44,16 +44,16 @@ const iteratorFindAsync = async function (iterator, predicate) {
 const iteratorFind = function (iterator, predicate) {
   let iteration = iterator.next()
   while (!iteration.done) {
-    const item = iteration.value,
-      predication = predicate(item)
+    const element = iteration.value,
+      predication = predicate(element)
     if (isPromise(predication)) {
       return predication.then(curry3(
         thunkConditional,
         __,
-        always(item),
+        always(element),
         thunkify2(iteratorFindAsync, iterator, predicate)))
     } else if (predication) {
-      return item
+      return element
     }
     iteration = iterator.next()
   }

package/_internal/iteratorForEach.d.ts

@@ -12,7 +12,7 @@ export = iteratorForEach;
  * ```
  *
  * @description
- * Call a callback for each item of an iterator. Return a promise if any executions are asynchronous.
+ * Call a callback for each element of an iterator. Return a promise if any executions are asynchronous.
  *
  * Note: iterator is consumed
  */

package/_internal/iteratorForEach.js

@@ -15,14 +15,14 @@ const always = require('./always')
  * ```
  *
  * @description
- * Call a callback for each item of an iterator. Return a promise if any executions are asynchronous.
+ * Call a callback for each element of an iterator. Return a promise if any executions are asynchronous.
  *
  * Note: iterator is consumed
  */
 const iteratorForEach = function (iterator, callback) {
   const promises = []
-  for (const item of iterator) {
-    const operation = callback(item)
+  for (const element of iterator) {
+    const operation = callback(element)
     if (isPromise(operation)) {
       promises.push(operation)
     }

package/_internal/iteratorForEachSeries.js

@@ -26,7 +26,7 @@ const _iteratorForEachSeriesAsync = async function (iterator, callback) {
  * ```
  *
  * @description
- * Call a callback for each item of an iterator. Return a promise if any executions are asynchronous.
+ * Call a callback for each element of an iterator. Return a promise if any executions are asynchronous.
  *
  * Note: iterator is consumed
  */