rubico 2.4.2 → 2.6.0

package/es.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.4.2
+ * rubico v2.6.0
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2024 Richard Tong
  * rubico may be freely distributed under the MIT license.
@@ -158,6 +158,9 @@ const tap = function (...args) {
   if (args.length == 0) {
     return curryArgs2(_tap, __, func)
   }
+  if (areAnyValuesPromises(args)) {
+    return promiseAll(args).then(curry2(_tap, __, func))
+  }
   return _tap(args, func)
 }
 
@@ -658,6 +661,136 @@ const arrayMapSeries = function (array, mapper) {
   return result
 }
 
+const stringMapSeries = function (string, mapper) {
+  const result = arrayMapSeries(string, mapper)
+  return isPromise(result)
+    ? result.then(curry3(callPropUnary, __, 'join', ''))
+    : result.join('')
+}
+
+const thunkify4 = (func, arg0, arg1, arg2, arg3) => function thunk() {
+  return func(arg0, arg1, arg2, arg3)
+}
+
+// _objectMapSeriesAsync(
+//   object Object,
+//   f function,
+//   result Object,
+//   doneKeys Object
+// ) -> Promise<object>
+const _objectMapSeriesAsync = async function (object, f, result, doneKeys) {
+  for (const key in object) {
+    if (key in doneKeys) {
+      continue
+    }
+    let resultItem = f(object[key])
+    if (isPromise(resultItem)) {
+      resultItem = await resultItem
+    }
+    result[key] = resultItem
+  }
+  return result
+}
+
+const objectMapSeries = function (object, f) {
+  const result = {}
+  const doneKeys = {}
+  for (const key in object) {
+    doneKeys[key] = true
+    const resultItem = f(object[key], key, object)
+    if (isPromise(resultItem)) {
+      return resultItem.then(funcConcat(
+        curry3(objectSet, result, key, __),
+        thunkify4(_objectMapSeriesAsync, object, f, result, doneKeys),
+      ))
+    }
+    result[key] = resultItem
+  }
+  return result
+}
+
+const setAdd = function (set, value) {
+  set.add(value)
+  return set
+}
+
+// _setMapSeriesAsync(
+//   iterator Iterator,
+//   f function,
+//   result Set,
+// ) -> Promise<Set>
+const _setMapSeriesAsync = async function (iterator, f, result) {
+  let iteration = iterator.next()
+  while (!iteration.done) {
+    let resultItem = f(iteration.value)
+    if (isPromise(resultItem)) {
+      resultItem = await resultItem
+    }
+    result.add(resultItem)
+    iteration = iterator.next()
+  }
+  return result
+}
+
+const setMapSeries = function (set, f) {
+  const result = new Set()
+  const iterator = set[symbolIterator]()
+  let iteration = iterator.next()
+  while (!iteration.done) {
+    const resultItem = f(iteration.value)
+    if (isPromise(resultItem)) {
+      return resultItem.then(funcConcat(
+        curry2(setAdd, result, __),
+        thunkify3(_setMapSeriesAsync, iterator, f, result),
+      ))
+    }
+    result.add(resultItem)
+    iteration = iterator.next()
+  }
+  return result
+}
+
+const mapSet = function setting(source, key, value) {
+  return source.set(key, value)
+}
+
+// _mapMapSeriesAsync(
+//   iterator Iterator,
+//   f function,
+//   result Map,
+// ) -> Promise<Map>
+const _mapMapSeriesAsync = async function (iterator, f, result) {
+  let iteration = iterator.next()
+  while (!iteration.done) {
+    let resultItem = f(iteration.value[1])
+    if (isPromise(resultItem)) {
+      resultItem = await resultItem
+    }
+    result.set(iteration.value[0], resultItem)
+    iteration = iterator.next()
+  }
+  return result
+}
+
+const mapMapSeries = function (map, f) {
+  const result = new Map()
+  const iterator = map[symbolIterator]()
+  let iteration = iterator.next()
+  while (!iteration.done) {
+    const key = iteration.value[0]
+    const resultItem = f(iteration.value[1])
+    if (isPromise(resultItem)) {
+      return resultItem.then(funcConcat(
+        curry3(mapSet, result, key, __),
+        thunkify3(_mapMapSeriesAsync, iterator, f, result),
+      ))
+    }
+    result.set(key, resultItem)
+    iteration = iterator.next()
+  }
+  return result
+}
+
 const tapSync = func => function tapping(...args) {
   func(...args)
   return args[0]
@@ -666,15 +799,14 @@ const tapSync = func => function tapping(...args) {
 const promiseRace = Promise.race.bind(Promise)
 
 const arrayMapPoolAsync = async function (
-  array, mapper, concurrencyLimit, result, index, promises,
+  array, f, concurrencyLimit, result, index, promises,
 ) {
   const arrayLength = array.length
   while (++index < arrayLength) {
     if (promises.size >= concurrencyLimit) {
       await promiseRace(promises)
     }
-
-    const resultItem = mapper(array[index])
+    const resultItem = f(array[index])
     if (isPromise(resultItem)) {
       const selfDeletingPromise = resultItem.then(
         tapSync(() => promises.delete(selfDeletingPromise)))
@@ -687,13 +819,12 @@ const arrayMapPoolAsync = async function (
   return promiseAll(result)
 }
 
-const arrayMapPool = function (array, mapper, concurrentLimit) {
+const arrayMapPool = function (array, concurrency, f) {
   const arrayLength = array.length,
     result = Array(arrayLength)
   let index = -1
   while (++index < arrayLength) {
-
-    const resultItem = mapper(array[index])
+    const resultItem = f(array[index])
     if (isPromise(resultItem)) {
       const promises = new Set(),
         selfDeletingPromise = resultItem.then(
@@ -701,13 +832,167 @@ const arrayMapPool = function (array, mapper, concurrentLimit) {
       promises.add(selfDeletingPromise)
       result[index] = selfDeletingPromise
       return arrayMapPoolAsync(
-        array, mapper, concurrentLimit, result, index, promises)
+        array, f, concurrency, result, index, promises)
     }
     result[index] = resultItem
   }
   return result
 }
 
+const stringMapPool = function (s, concurrency, f) {
+  const result = arrayMapPool(s, concurrency, f)
+  return isPromise(result)
+    ? result.then(curry3(callPropUnary, __, 'join', ''))
+    : result.join('')
+}
+
+const _setMapPoolAsync = async function (
+  s, iterator, concurrency, f, result, promises,
+) {
+  let iteration = iterator.next()
+  while (!iteration.done) {
+    if (promises.size >= concurrency) {
+      await promiseRace(promises)
+    }
+    const resultItem = f(iteration.value, iteration.value, s)
+    if (isPromise(resultItem)) {
+      const selfDeletingPromise = resultItem.then(resolvedValue => {
+        promises.delete(selfDeletingPromise)
+        result.add(resolvedValue)
+      })
+      promises.add(selfDeletingPromise)
+    } else {
+      result.add(resultItem)
+    }
+    iteration = iterator.next()
+  }
+  if (promises.size > 0) {
+    await promiseAll(promises)
+  }
+  return result
+}
+
+const setMapPool = function (s, concurrency, f) {
+  const result = new Set()
+  const iterator = s[symbolIterator]()
+  let iteration = iterator.next()
+  while (!iteration.done) {
+    const resultItem = f(iteration.value, iteration.value, s)
+    if (isPromise(resultItem)) {
+      const promises = new Set()
+      const selfDeletingPromise = resultItem.then(resolvedValue => {
+        promises.delete(selfDeletingPromise)
+        result.add(resolvedValue)
+      })
+      promises.add(selfDeletingPromise)
+      return _setMapPoolAsync(s, iterator, concurrency, f, result, promises)
+    }
+    result.add(resultItem)
+    iteration = iterator.next()
+  }
+  return result
+}
+
+const _mapMapPoolAsync = async function (
+  m, iterator, concurrency, f, result, promises,
+) {
+  let iteration = iterator.next()
+  while (!iteration.done) {
+    if (promises.size >= concurrency) {
+      await promiseRace(promises)
+    }
+    const key = iteration.value[0]
+    const resultItem = f(iteration.value[1], key, m)
+    if (isPromise(resultItem)) {
+      result.set(key, resultItem)
+      const selfDeletingPromise = resultItem.then(resolvedValue => {
+        promises.delete(selfDeletingPromise)
+        result.set(key, resolvedValue)
+      })
+      promises.add(selfDeletingPromise)
+    } else {
+      result.set(key, resultItem)
+    }
+    iteration = iterator.next()
+  }
+  if (promises.size > 0) {
+    await promiseAll(promises)
+  }
+  return result
+}
+
+const mapMapPool = function (m, concurrency, f) {
+  const result = new Map()
+  const iterator = m[symbolIterator]()
+  let iteration = iterator.next()
+  while (!iteration.done) {
+    const key = iteration.value[0]
+    const resultItem = f(iteration.value[1], key, m)
+    if (isPromise(resultItem)) {
+      const promises = new Set()
+      result.set(key, resultItem)
+      const selfDeletingPromise = resultItem.then(resolvedValue => {
+        promises.delete(selfDeletingPromise)
+        result.set(key, resolvedValue)
+      })
+      promises.add(selfDeletingPromise)
+      return _mapMapPoolAsync(m, iterator, concurrency, f, result, promises)
+    }
+    result.set(key, resultItem)
+    iteration = iterator.next()
+  }
+  return result
+}
+
+const _objectMapPoolAsync = async function (
+  o, concurrency, f, result, doneKeys, promises,
+) {
+  for (const key in o) {
+    if (key in doneKeys) {
+      continue
+    }
+    if (promises.size >= concurrency) {
+      await promiseRace(promises)
+    }
+    const resultItem = f(o[key], key, o)
+    if (isPromise(resultItem)) {
+      result[key] = resultItem
+      const selfDeletingPromise = resultItem.then(resolvedValue => {
+        promises.delete(selfDeletingPromise)
+        result[key] = resolvedValue
+      })
+      promises.add(selfDeletingPromise)
+    } else {
+      result[key] = resultItem
+    }
+  }
+  if (promises.size > 0) {
+    await promiseAll(promises)
+  }
+  return result
+}
+
+const objectMapPool = function (o, concurrency, f) {
+  const result = {}
+  const doneKeys = {}
+  for (const key in o) {
+    doneKeys[key] = true
+    const resultItem = f(o[key], key, o)
+    if (isPromise(resultItem)) {
+      const promises = new Set()
+      result[key] = resultItem
+      const selfDeletingPromise = resultItem.then(resolvedValue => {
+        promises.delete(selfDeletingPromise)
+        result[key] = resolvedValue
+      })
+      promises.add(selfDeletingPromise)
+      return _objectMapPoolAsync(o, concurrency, f, result, doneKeys, promises)
+    }
+    result[key] = resultItem
+  }
+  return result
+}
+
 const _curryArity = (arity, func, args) => function curried(...curriedArgs) {
   const argsLength = args.length,
     curriedArgsLength = curriedArgs.length,
@@ -786,10 +1071,6 @@ const objectMapEntries = function (object, mapper) {
     : promiseAll(promises).then(always(result))
 }
 
-const mapSet = function setting(source, key, value) {
-  return source.set(key, value)
-}
-
 // (mapper function, result Map, promises Array<Promise>) => (key any, value any) => ()
 const mapMapEntriesForEachCallback = (
   mapper, result, promises,
@@ -847,7 +1128,7 @@ const _map = function (value, mapper) {
 }
 
 const map = function (arg0, arg1) {
-  if (typeof arg0 == 'function') {
+  if (arg1 == null) {
     return curry2(_map, __, arg0)
   }
   return isPromise(arg0)
@@ -870,7 +1151,7 @@ const _mapEntries = (value, mapper) => {
 }
 
 map.entries = function mapEntries(arg0, arg1) {
-  if (typeof arg0 == 'function') {
+  if (arg1 == null) {
     return curry2(_mapEntries, __, arg0)
   }
   return isPromise(arg0)
@@ -878,18 +1159,67 @@ map.entries = function mapEntries(arg0, arg1) {
     : _mapEntries(arg0, arg1)
 }
 
-map.series = mapper => function mappingInSeries(value) {
-  if (isArray(value)) {
-    return arrayMapSeries(value, mapper)
+const _mapSeries = function (collection, f) {
+  if (isArray(collection)) {
+    return arrayMapSeries(collection, f)
+  }
+  if (collection == null) {
+    throw new TypeError(`invalid collection ${collection}`)
   }
-  throw new TypeError(`${value} is not an Array`)
+
+  if (typeof collection == 'string' || collection.constructor == String) {
+    return stringMapSeries(collection, f)
+  }
+  if (collection.constructor == Set) {
+    return setMapSeries(collection, f)
+  }
+  if (collection.constructor == Map) {
+    return mapMapSeries(collection, f)
+  }
+  if (collection.constructor == Object) {
+    return objectMapSeries(collection, f)
+  }
+  throw new TypeError(`invalid collection ${collection}`)
 }
 
-map.pool = (concurrencyLimit, mapper) => function concurrentPoolMapping(value) {
-  if (isArray(value)) {
-    return arrayMapPool(value, mapper, concurrencyLimit)
+map.series = function mapSeries(arg0, arg1) {
+  if (arg1 == null) {
+    return curry2(_mapSeries, __, arg0)
+  }
+  return isPromise(arg0)
+    ? arg0.then(curry2(_mapSeries, __, arg1))
+    : _mapSeries(arg0, arg1)
+}
+
+const _mapPool = function (collection, concurrency, f) {
+  if (isArray(collection)) {
+    return arrayMapPool(collection, concurrency, f)
+  }
+  if (collection == null) {
+    throw new TypeError(`invalid collection ${collection}`)
+  }
+  if (typeof collection == 'string' || collection.constructor == String) {
+    return stringMapPool(collection, concurrency, f)
+  }
+  if (collection.constructor == Set) {
+    return setMapPool(collection, concurrency, f)
+  }
+  if (collection.constructor == Map) {
+    return mapMapPool(collection, concurrency, f)
+  }
+  if (collection.constructor == Object) {
+    return objectMapPool(collection, concurrency, f)
   }
-  throw new TypeError(`${value} is not an Array`)
+  throw new TypeError(`invalid collection ${collection}`)
+}
+
+map.pool = function mapPool(arg0, arg1, arg2) {
+  if (arg2 == null) {
+    return curry3(_mapPool, __, arg0, arg1)
+  }
+  return isPromise(arg0)
+    ? arg0.then(curry3(_mapPool, __, arg1, arg2))
+    : _mapPool(arg0, arg1, arg2)
 }
 
 const FilteringIterator = (iterator, predicate) => ({
@@ -1005,10 +1335,6 @@ const setFilter = function (value, predicate) {
     : promiseAll(promises).then(always(result))
 }
 
-const thunkify4 = (func, arg0, arg1, arg2, arg3) => function thunk() {
-  return func(arg0, arg1, arg2, arg3)
-}
-
 const mapFilter = function (map, predicate) {
   const result = new Map(),
     promises = []
@@ -1923,11 +2249,11 @@ const arrayForEachSeries = function (array, callback) {
 // _objectForEachSeriesAsync(
 //   object Object,
 //   callback function,
-//   firstKey string
+//   doneKeys Object,
 // ) -> Promise<object>
-const _objectForEachSeriesAsync = async function (object, callback, firstKey) {
+const _objectForEachSeriesAsync = async function (object, callback, doneKeys) {
   for (const key in object) {
-    if (key == firstKey) {
+    if (key in doneKeys) {
       continue
     }
     const operation = callback(object[key])
@@ -1939,11 +2265,13 @@ const _objectForEachSeriesAsync = async function (object, callback, firstKey) {
 }
 
 const objectForEachSeries = function (object, callback) {
+  const doneKeys = {}
   for (const key in object) {
+    doneKeys[key] = true
     const operation = callback(object[key])
     if (isPromise(operation)) {
       return operation
-        .then(thunkify3(_objectForEachSeriesAsync, object, callback, key))
+        .then(thunkify3(_objectForEachSeriesAsync, object, callback, doneKeys))
     }
   }
   return object
@@ -1998,7 +2326,8 @@ const _forEach = function (collection, callback) {
     return collection
   }
   if (typeof collection.forEach == 'function') {
-    return collection.forEach(callback)
+    collection.forEach(callback)
+    return collection
   }
   if (typeof collection[symbolIterator] == 'function') {
     return iteratorForEach(collection[symbolIterator](), callback)
@@ -2026,7 +2355,7 @@ const _forEachSeries = function (collection, callback) {
     return arrayForEachSeries(collection, callback)
   }
   if (collection == null) {
-    throw new Error(`invalid collection ${collection}`)
+    throw new TypeError(`invalid collection ${collection}`)
   }
   if (typeof collection[symbolIterator] == 'function') {
     return iteratorForEachSeries(collection[symbolIterator](), callback)
@@ -2037,7 +2366,7 @@ const _forEachSeries = function (collection, callback) {
   if (collection.constructor == Object) {
     return objectForEachSeries(collection, callback)
   }
-  throw new Error(`invalid collection ${collection}`)
+  throw new TypeError(`invalid collection ${collection}`)
 }
 
 forEach.series = function forEachSeries(arg0, arg1) {

package/every.js

@@ -82,6 +82,12 @@ const _every = function (collection, predicate) {
  * ])
  * ```
  *
+ * Any promises passed in argument position are resolved for their values before further execution. This only applies to the eager version of the API.
+ *
+ * ```javascript [playground]
+ * every(Promise.resolve([1, 2, 3, 4, 5]), n => n < 6).then(console.log) // true
+ * ```
+ *
  * @execution concurrent
  *
  * @muxing

package/filter.js

@@ -226,6 +226,15 @@ const _filter = function (value, predicate) {
  * }
  * ```
  *
+ * Any promises passed in argument position are resolved for their values before further execution. This only applies to the eager version of the API.
+ *
+ * ```javascript [playground]
+ * const isOdd = number => number % 2 == 1
+ *
+ * filter(Promise.resolve([1, 2, 3, 4, 5]), isOdd).then(console.log)
+ * // [1, 3, 5]
+ * ```
+ *
  * @execution concurrent
  *
  * @transducing

package/flatMap.js

@@ -157,6 +157,13 @@ const _flatMap = function (value, flatMapper) {
  * ) // Set(10) { 1, 101, 2, 102, 3, 103, 4, 104, 5, 105 }
  * ```
  *
+ * Any promises passed in argument position are resolved for their values before further execution. This only applies to the eager version of the API.
+ *
+ * ```javascript [playground]
+ * flatMap(Promise.resolve([1, 2, 3, 4, 5]), n => [n, n]).then(console.log)
+ * // [1, 1, 2, 2, 3, 3, 4, 4, 5, 5]
+ * ```
+ *
  * @execution concurrent
  *
  * @transducing

package/forEach.js

@@ -25,7 +25,8 @@ const _forEach = function (collection, callback) {
     return collection
   }
   if (typeof collection.forEach == 'function') {
-    return collection.forEach(callback)
+    collection.forEach(callback)
+    return collection
   }
   if (typeof collection[symbolIterator] == 'function') {
     return iteratorForEach(collection[symbolIterator](), callback)
@@ -71,6 +72,15 @@ const _forEach = function (collection, callback) {
  *                         // 25
  * ])
  * ```
+ *
+ * Any promises passed in argument position are resolved for their values before further execution. This only applies to the eager version of the API.
+ *
+ * ```javascript [playground]
+ * forEach(Promise.resolve([1, 2, 3]), console.log)
+ * // 1
+ * // 2
+ * // 3
+ * ```
  */
 const forEach = function (arg0, arg1) {
   if (typeof arg0 == 'function') {
@@ -96,7 +106,7 @@ const _forEachSeries = function (collection, callback) {
     return arrayForEachSeries(collection, callback)
   }
   if (collection == null) {
-    throw new Error(`invalid collection ${collection}`)
+    throw new TypeError(`invalid collection ${collection}`)
   }
   if (typeof collection[symbolIterator] == 'function') {
     return iteratorForEachSeries(collection[symbolIterator](), callback)
@@ -107,7 +117,7 @@ const _forEachSeries = function (collection, callback) {
   if (collection.constructor == Object) {
     return objectForEachSeries(collection, callback)
   }
-  throw new Error(`invalid collection ${collection}`)
+  throw new TypeError(`invalid collection ${collection}`)
 }
 
 /**
@@ -130,6 +140,15 @@ const _forEachSeries = function (collection, callback) {
  *
  * forEach.series({ a: 1, b: 2, c: 3 }, console.log) // 1 2 3
  * ```
+ *
+ * Any promises passed in argument position are resolved for their values before further execution. This only applies to the eager version of the API.
+ *
+ * ```javascript [playground]
+ * forEach.series(Promise.resolve([1, 2, 3]), console.log)
+ * // 1
+ * // 2
+ * // 3
+ * ```
  */
 forEach.series = function forEachSeries(arg0, arg1) {
   if (typeof arg0 == 'function') {

package/get.js

@@ -80,6 +80,12 @@ const _get = function (object, path, defaultValue) {
  * console.log(get00000BracketNotation([[[[['foo']]]]])) // foo
  * console.log(get00000ArrayNotation([[[[['foo']]]]])) // foo
  * ```
+ *
+ * Any promises passed in argument position are resolved for their values before further execution. This only applies to the eager version of the API.
+ *
+ * ```javascript [playground]
+ * get(Promise.resolve({ a: 1 }), 'a').then(console.log) // 1
+ * ```
  */
 
 const get = function (arg0, arg1, arg2) {

package/gt.js

@@ -47,6 +47,12 @@ const greaterThan = require('./_internal/greaterThan')
  *   console.log, // true
  * ])
  * ```
+ *
+ * Any promises passed in argument position are resolved for their values before further execution. This only applies to the eager version of the API.
+ *
+ * ```javascript [playground]
+ * gt(Promise.resolve({ a: 2, b: 1 }), get('a'), get('b')).then(console.log) // true
+ * ```
  */
 const gt = ComparisonOperator(greaterThan)
 

package/gte.js

@@ -49,6 +49,12 @@ const greaterThanOrEqual = require('./_internal/greaterThanOrEqual')
  *   console.log, // true
  * ])
  * ```
+ *
+ * Any promises passed in argument position are resolved for their values before further execution. This only applies to the eager version of the API.
+ *
+ * ```javascript [playground]
+ * gte(Promise.resolve({ a: 1, b: 1 }), get('a'), get('b')).then(console.log) // true
+ * ```
  */
 const gte = ComparisonOperator(greaterThanOrEqual)