rubico 2.5.0 → 2.6.1

package/index.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.5.0
+ * rubico v2.6.1
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2024 Richard Tong
  * rubico may be freely distributed under the MIT license.
@@ -152,29 +152,67 @@ const curryArgs2 = function (baseFunc, arg0, arg1) {
   return curryArgs2ResolveArgs1(baseFunc, arg0)
 }
 
-// _tap(args Array, func function) -> Promise|any
-const _tap = function (args, func) {
+// argument resolver for curryArgs3
+const curryArgs3ResolveArgs0 = (
+  baseFunc, arg1, arg2,
+) => function args0Resolver(...args) {
+  return baseFunc(args, arg1, arg2)
+}
+
+// argument resolver for curryArgs3
+const curryArgs3ResolveArgs1 = (
+  baseFunc, arg0, arg2,
+) => function arg1Resolver(...args) {
+  return baseFunc(arg0, args, arg2)
+}
+
+// argument resolver for curryArgs3
+const curryArgs3ResolveArgs2 = (
+  baseFunc, arg0, arg1,
+) => function arg2Resolver(...args) {
+  return baseFunc(arg0, arg1, args)
+}
+
+const curryArgs3 = function (baseFunc, arg0, arg1, arg2) {
+  if (arg0 == __) {
+    return curryArgs3ResolveArgs0(baseFunc, arg1, arg2)
+  }
+  if (arg1 == __) {
+    return curryArgs3ResolveArgs1(baseFunc, arg0, arg2)
+  }
+  return curryArgs3ResolveArgs2(baseFunc, arg0, arg1)
+}
+
+// _tap(args Array, f function) -> Promise|any
+const _tap = function (args, f) {
   const result = args[0],
-    call = func(...args)
+    call = f(...args)
   return isPromise(call) ? call.then(always(result)) : result
 }
 
 const tap = function (...args) {
-  const func = args.pop()
+  const f = args.pop()
   if (args.length == 0) {
-    return curryArgs2(_tap, __, func)
+    return curryArgs2(_tap, __, f)
+  }
+  if (areAnyValuesPromises(args)) {
+    return promiseAll(args).then(curry2(_tap, __, f))
   }
-  return _tap(args, func)
+  return _tap(args, f)
 }
 
-tap.if = (predicate, func) => function tappingIf(...args) {
-  const predication = predicate(...args)
-  if (isPromise(predication)) {
-    return predication.then(curry3(
-      thunkConditional, __, thunkifyArgs(tap(func), args), always(args[0])))
+const _tapIf = function (predicate, f, args) {
+  const b = predicate(...args)
+  if (isPromise(b)) {
+    return b.then(curry3(
+      thunkConditional,
+      __,
+      thunkifyArgs(tap(f), args),
+      always(args[0]),
+    ))
   }
-  if (predication) {
-    const execution = func(...args)
+  if (b) {
+    const execution = f(...args)
     if (isPromise(execution)) {
       return execution.then(always(args[0]))
     }
@@ -182,6 +220,20 @@ tap.if = (predicate, func) => function tappingIf(...args) {
   return args[0]
 }
 
+tap.if = function (...args) {
+  if (args.length == 2) {
+    return curryArgs3(_tapIf, args[0], args[1], __)
+  }
+  const argsLength = args.length
+  const f = args[argsLength - 1]
+  const predicate = args[argsLength - 2]
+  const argValues = args.slice(0, -2)
+  if (areAnyValuesPromises(argValues)) {
+    return promiseAll(argValues).then(curry3(_tapIf, predicate, f, __))
+  }
+  return _tapIf(predicate, f, args)
+}
+
 const isArray = Array.isArray
 
 const functionArrayAll = function (funcs, args) {
@@ -448,37 +500,6 @@ const nonfunctionsConditional = function (array, index) {
   return array[index]
 }
 
-// argument resolver for curryArgs3
-const curryArgs3ResolveArgs0 = (
-  baseFunc, arg1, arg2,
-) => function args0Resolver(...args) {
-  return baseFunc(args, arg1, arg2)
-}
-
-// argument resolver for curryArgs3
-const curryArgs3ResolveArgs1 = (
-  baseFunc, arg0, arg2,
-) => function arg1Resolver(...args) {
-  return baseFunc(arg0, args, arg2)
-}
-
-// argument resolver for curryArgs3
-const curryArgs3ResolveArgs2 = (
-  baseFunc, arg0, arg1,
-) => function arg2Resolver(...args) {
-  return baseFunc(arg0, arg1, args)
-}
-
-const curryArgs3 = function (baseFunc, arg0, arg1, arg2) {
-  if (arg0 == __) {
-    return curryArgs3ResolveArgs0(baseFunc, arg1, arg2)
-  }
-  if (arg1 == __) {
-    return curryArgs3ResolveArgs1(baseFunc, arg0, arg2)
-  }
-  return curryArgs3ResolveArgs2(baseFunc, arg0, arg1)
-}
-
 const switchCase = (...args) => {
   const values = args.pop()
   if (areAllValuesNonfunctions(values)) {
@@ -707,6 +728,7 @@ const objectMapSeries = function (object, f) {
         thunkify4(_objectMapSeriesAsync, object, f, result, doneKeys),
       ))
     }
+    result[key] = resultItem
   }
   return result
 }
@@ -801,15 +823,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)))
@@ -822,13 +843,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(
@@ -836,13 +856,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,
@@ -978,7 +1152,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)
@@ -1001,7 +1175,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)
@@ -1033,7 +1207,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)
@@ -1041,11 +1215,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}`)
+  }
+  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)
   }
-  throw new TypeError(`${value} is not an Array`)
+  return isPromise(arg0)
+    ? arg0.then(curry3(_mapPool, __, arg1, arg2))
+    : _mapPool(arg0, arg1, arg2)
 }
 
 const FilteringIterator = (iterator, predicate) => ({
@@ -2152,7 +2350,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/lt.js

@@ -47,6 +47,12 @@ const lessThan = require('./_internal/lessThan')
  *   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]
+ * lt(Promise.resolve({ a: 1, b: 2 }), get('a'), get('b')).then(console.log) // true
+ * ```
  */
 const lt = ComparisonOperator(lessThan)
 

package/lte.js

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