rubico 2.5.0 → 2.6.0

package/dist/x/unionWith.min.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.5.0
+ * rubico v2.6.0
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2024 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/unionWith.mjs

@@ -1,5 +1,5 @@
 /**
- * rubico v2.5.0
+ * rubico v2.6.0
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2024 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/uniq.es.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.5.0
+ * rubico v2.6.0
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2024 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/uniq.es.min.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.5.0
+ * rubico v2.6.0
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2024 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/uniq.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.5.0
+ * rubico v2.6.0
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2024 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/uniq.min.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.5.0
+ * rubico v2.6.0
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2024 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/uniq.mjs

@@ -1,5 +1,5 @@
 /**
- * rubico v2.5.0
+ * rubico v2.6.0
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2024 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/unless.es.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.5.0
+ * rubico v2.6.0
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2024 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/unless.es.min.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.5.0
+ * rubico v2.6.0
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2024 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/unless.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.5.0
+ * rubico v2.6.0
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2024 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/unless.min.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.5.0
+ * rubico v2.6.0
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2024 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/unless.mjs

@@ -1,5 +1,5 @@
 /**
- * rubico v2.5.0
+ * rubico v2.6.0
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2024 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/values.es.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.5.0
+ * rubico v2.6.0
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2024 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/values.es.min.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.5.0
+ * rubico v2.6.0
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2024 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/values.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.5.0
+ * rubico v2.6.0
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2024 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/values.min.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.5.0
+ * rubico v2.6.0
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2024 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/values.mjs

@@ -1,5 +1,5 @@
 /**
- * rubico v2.5.0
+ * rubico v2.6.0
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2024 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/when.es.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.5.0
+ * rubico v2.6.0
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2024 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/when.es.min.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.5.0
+ * rubico v2.6.0
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2024 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/when.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.5.0
+ * rubico v2.6.0
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2024 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/when.min.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.5.0
+ * rubico v2.6.0
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2024 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/when.mjs

@@ -1,5 +1,5 @@
 /**
- * rubico v2.5.0
+ * rubico v2.6.0
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2024 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/eq.js

@@ -48,6 +48,12 @@ const equals = require('./_internal/equals')
  * ])
  * ```
  *
+ * 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]
+ * eq(Promise.resolve({ a: 1, b: 1 }), get('a'), get('b')).then(console.log) // true
+ * ```
+ *
  * @execution concurrent
  */
 

package/es.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.5.0
+ * 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)
 }
 
@@ -701,6 +704,7 @@ const objectMapSeries = function (object, f) {
         thunkify4(_objectMapSeriesAsync, object, f, result, doneKeys),
       ))
     }
+    result[key] = resultItem
   }
   return result
 }
@@ -795,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)))
@@ -816,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(
@@ -830,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,
@@ -972,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)
@@ -995,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)
@@ -1027,7 +1183,7 @@ const _mapSeries = function (collection, f) {
 }
 
 map.series = function mapSeries(arg0, arg1) {
-  if (typeof arg0 == 'function') {
+  if (arg1 == null) {
     return curry2(_mapSeries, __, arg0)
   }
   return isPromise(arg0)
@@ -1035,11 +1191,35 @@ map.series = function mapSeries(arg0, arg1) {
     : _mapSeries(arg0, arg1)
 }
 
-map.pool = (concurrencyLimit, mapper) => function concurrentPoolMapping(value) {
-  if (isArray(value)) {
-    return arrayMapPool(value, mapper, concurrencyLimit)
+const _mapPool = function (collection, concurrency, f) {
+  if (isArray(collection)) {
+    return arrayMapPool(collection, concurrency, 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 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(`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) => ({
@@ -2146,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)

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') {
@@ -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)