rubico 2.6.0 → 2.6.2

package/index.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.6.0
+ * rubico v2.6.2
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2024 Richard Tong
  * rubico may be freely distributed under the MIT license.
@@ -11,13 +11,25 @@
   else (root.rubico = rubico) // Browser
 }(typeof globalThis == 'object' ? globalThis : this, (function () { 'use strict'
 
+const isArray = Array.isArray
+
 const isPromise = value => value != null && typeof value.then == 'function'
 
 const areAnyValuesPromises = function (values) {
-  const length = values.length
-  let index = -1
-  while (++index < length) {
-    const value = values[index]
+  if (isArray(values)) {
+    const length = values.length
+    let index = -1
+    while (++index < length) {
+      const value = values[index]
+      if (isPromise(value)) {
+        return true
+      }
+    }
+    return false
+  }
+
+  for (const key in values) {
+    const value = values[key]
     if (isPromise(value)) {
       return true
     }
@@ -152,32 +164,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, __, func))
+    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]))
     }
@@ -185,14 +232,72 @@ tap.if = (predicate, func) => function tappingIf(...args) {
   return args[0]
 }
 
-const isArray = Array.isArray
+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 areAllValuesNonfunctions = function (values) {
+  if (isArray(values)) {
+    const length = values.length
+    let index = -1
+    while (++index < length) {
+      if (typeof values[index] == 'function') {
+        return false
+      }
+    }
+    return true
+  }
+
+  for (const key in values) {
+    if (typeof values[key] == 'function') {
+      return false
+    }
+  }
+  return true
+}
+
+const promiseObjectAllExecutor = object => function executor(resolve) {
+  const result = {}
+  let numPromises = 0
+  for (const key in object) {
+    const value = object[key]
+    if (isPromise(value)) {
+      numPromises += 1
+      value.then((key => function (res) {
+        result[key] = res
+        numPromises -= 1
+        if (numPromises == 0) {
+          resolve(result)
+        }
+      })(key))
+    } else {
+      result[key] = value
+    }
+  }
+  if (numPromises == 0) {
+    resolve(result)
+  }
+}
+
+const promiseObjectAll = object => new Promise(promiseObjectAllExecutor(object))
 
 const functionArrayAll = function (funcs, args) {
   const funcsLength = funcs.length,
     result = Array(funcsLength)
   let funcsIndex = -1, isAsync = false
   while (++funcsIndex < funcsLength) {
-    const resultItem = funcs[funcsIndex](...args)
+    const f = funcs[funcsIndex]
+    const resultItem = typeof f == 'function' ? f(...args) : f
     if (isPromise(resultItem)) {
       isAsync = true
     }
@@ -274,7 +379,8 @@ const functionArrayAllSeries = function (funcs, args) {
 const functionObjectAll = function (funcs, args) {
   const result = {}, promises = []
   for (const key in funcs) {
-    const resultItem = funcs[key](...args)
+    const f = funcs[key]
+    const resultItem = typeof f == 'function' ? f(...args) : f
     if (isPromise(resultItem)) {
       promises.push(resultItem.then(curry3(objectSet, result, key, __)))
     } else {
@@ -284,7 +390,48 @@ const functionObjectAll = function (funcs, args) {
   return promises.length == 0 ? result : promiseAll(promises).then(always(result))
 }
 
+const _allValues = function (values) {
+  if (isArray(values)) {
+    return areAnyValuesPromises(values)
+      ? promiseAll(values)
+      : values
+  }
+  return areAnyValuesPromises(values)
+    ? promiseObjectAll(values)
+    : values
+}
+
 const all = function (...args) {
+  if (args.length == 1) {
+    const resolversOrValues = args[0]
+    if (isPromise(resolversOrValues)) {
+      return resolversOrValues.then(_allValues)
+    }
+    if (areAllValuesNonfunctions(resolversOrValues)) {
+      return _allValues(resolversOrValues)
+    }
+    return isArray(resolversOrValues)
+      ? curryArgs2(functionArrayAll, resolversOrValues, __)
+      : curryArgs2(functionObjectAll, resolversOrValues, __)
+  }
+
+  const resolversOrValues = args[args.length - 1]
+  const argValues = args.slice(0, -1)
+
+  if (areAnyValuesPromises(argValues)) {
+    return isArray(resolversOrValues)
+      ? promiseAll(argValues)
+        .then(curry2(functionArrayAll, resolversOrValues, __))
+      : promiseAll(argValues)
+        .then(curry2(functionObjectAll, resolversOrValues, __))
+  }
+
+  return isArray(resolversOrValues)
+    ? functionArrayAll(resolversOrValues, argValues)
+    : functionObjectAll(resolversOrValues, argValues)
+
+  /*
+  ////////////////////////////////////////////////////////////////
   const funcs = args.pop()
   if (args.length == 0) {
     return isArray(funcs)
@@ -301,6 +448,7 @@ const all = function (...args) {
   return isArray(funcs)
     ? functionArrayAll(funcs, args)
     : functionObjectAll(funcs, args)
+  */
 }
 
 all.series = function allSeries(...args) {
@@ -411,17 +559,6 @@ const arrayConditional = function (array, args, funcsIndex) {
     : defaultResolverOrValue
 }
 
-const areAllValuesNonfunctions = function (values) {
-  const length = values.length
-  let index = -1
-  while (++index < length) {
-    if (typeof values[index] == 'function') {
-      return false
-    }
-  }
-  return true
-}
-
 const thunkify2 = (func, arg0, arg1) => function thunk() {
   return func(arg0, arg1)
 }
@@ -451,37 +588,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)) {
@@ -601,31 +707,6 @@ const mapMap = function (value, mapper) {
     : promiseAll(promises).then(always(result))
 }
 
-const promiseObjectAllExecutor = object => function executor(resolve) {
-  const result = {}
-  let numPromises = 0
-  for (const key in object) {
-    const value = object[key]
-    if (isPromise(value)) {
-      numPromises += 1
-      value.then((key => function (res) {
-        result[key] = res
-        numPromises -= 1
-        if (numPromises == 0) {
-          resolve(result)
-        }
-      })(key))
-    } else {
-      result[key] = value
-    }
-  }
-  if (numPromises == 0) {
-    resolve(result)
-  }
-}
-
-const promiseObjectAll = object => new Promise(promiseObjectAllExecutor(object))
-
 const objectMap = function (object, mapper) {
   const result = {}
   let isAsync = false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rubico",
-  "version": "2.6.0",
+  "version": "2.6.2",
   "description": "[a]synchronous functional programming",
   "author": "Richard Tong",
   "license": "MIT",

package/tap.js

@@ -5,14 +5,15 @@ const thunkConditional = require('./_internal/thunkConditional')
 const curry2 = require('./_internal/curry2')
 const curry3 = require('./_internal/curry3')
 const curryArgs2 = require('./_internal/curryArgs2')
+const curryArgs3 = require('./_internal/curryArgs3')
 const __ = require('./_internal/placeholder')
 const areAnyValuesPromises = require('./_internal/areAnyValuesPromises')
 const promiseAll = require('./_internal/promiseAll')
 
-// _tap(args Array, func function) -> Promise|any
-const _tap = function (args, func) {
+// _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
 }
 
@@ -21,8 +22,8 @@ const _tap = function (args, func) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * tap(...args, func function) -> Promise|args[0]
- * tap(func function)(...args) -> Promise|args[0]
+ * tap(...args, f function) -> Promise|args[0]
+ * tap(f function)(...args) -> Promise|args[0]
  * ```
  *
  * @description
@@ -41,19 +42,51 @@ const _tap = function (args, func) {
  * ```
  *
  * 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]
- * tap(Promise.resolve(1), Promise.resolve(2), 3, console.log) // 1, 2, 3
+ * tap(Promise.resolve(1), Promise.resolve(2), 3, console.log) // 1 2 3
  * ```
  */
 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, __, func))
+    return promiseAll(args).then(curry2(_tap, __, f))
   }
-  return _tap(args, func)
+  return _tap(args, f)
+}
+
+/**
+ * @name _tapIf
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * _tapIf(
+ *   predicate function,
+ *   f function,
+ *   args Array,
+ * ) -> Promise|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 (b) {
+    const execution = f(...args)
+    if (isPromise(execution)) {
+      return execution.then(always(args[0]))
+    }
+  }
+  return args[0]
 }
 
 /**
@@ -61,37 +94,42 @@ const tap = function (...args) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * tap.if(predicate function, func function)(...args) -> Promise|args[0]
+ * tap.if(...args, predicate function, f function) -> Promise|args[0]
+ * tap.if(predicate function, f function)(...args) -> Promise|args[0]
  * ```
  *
  * @description
- * A version of `tap` that accepts a predicate function (a function that returns a boolean value) before the function to execute. Only executes the function if the predicate function tests true for the same arguments provided to the execution function.
+ * A version of `tap` that accepts a predicate function (a function that returns a boolean value) before the function `f` to execute. Only executes `f` if the predicate function tests true. The arguments are the same to both the predicate function and the function to execute `f`.
  *
  * ```javascript [playground]
  * const isOdd = number => number % 2 == 1
  *
- * const logIfOdd = tap.if(
- *   isOdd,
- *   number => console.log(number, 'is an odd number')
- * )
+ * const logIfOdd = tap.if(isOdd, console.log)
  *
  * logIfOdd(2)
- * logIfOdd(3) // 3 is an odd number
+ * logIfOdd(3) // 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]
+ * tap.if(Promise.resolve(1), n => n < 5, console.log) // 1
+ * tap.if(Promise.resolve(6), n => n < 5, console.log)
  * ```
  */
-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])))
+
+tap.if = function (...args) {
+  if (args.length == 2) {
+    return curryArgs3(_tapIf, args[0], args[1], __)
   }
-  if (predication) {
-    const execution = func(...args)
-    if (isPromise(execution)) {
-      return execution.then(always(args[0]))
-    }
+  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 args[0]
+  return _tapIf(predicate, f, args)
 }
 
 module.exports = tap