rubico 2.6.5 → 2.7.0

package/index.js

@@ -1,7 +1,7 @@
 /**
- * rubico v2.6.2
+ * rubico v2.7.0
  * https://github.com/a-synchronous/rubico
- * (c) 2019-2024 Richard Tong
+ * (c) 2019-2025 Richard Tong
  * rubico may be freely distributed under the MIT license.
  */
 
@@ -73,6 +73,10 @@ const curry2 = function (baseFunc, arg0, arg1) {
 }
 
 const pipe = function (...args) {
+  if (typeof args[0] == 'function') {
+    return args.reduce(funcConcat)
+  }
+
   const funcs = args.pop()
   const pipeline = funcs.reduce(funcConcat)
 
@@ -88,6 +92,10 @@ const pipe = function (...args) {
 }
 
 const compose = function (...args) {
+  if (typeof args[0] == 'function') {
+    return args.reduceRight(funcConcat)
+  }
+
   const funcs = args.pop()
   const composition = funcs.reduceRight(funcConcat)
 
@@ -429,26 +437,6 @@ const all = function (...args) {
   return isArray(resolversOrValues)
     ? functionArrayAll(resolversOrValues, argValues)
     : functionObjectAll(resolversOrValues, argValues)
-
-  /*
-  ////////////////////////////////////////////////////////////////
-  const funcs = args.pop()
-  if (args.length == 0) {
-    return isArray(funcs)
-      ? curryArgs2(functionArrayAll, funcs, __)
-      : curryArgs2(functionObjectAll, funcs, __)
-  }
-
-  if (areAnyValuesPromises(args)) {
-    return isArray(funcs)
-      ? promiseAll(args).then(curry2(functionArrayAll, funcs, __))
-      : promiseAll(args).then(curry2(functionObjectAll, funcs, __))
-  }
-
-  return isArray(funcs)
-    ? functionArrayAll(funcs, args)
-    : functionObjectAll(funcs, args)
-  */
 }
 
 all.series = function allSeries(...args) {
@@ -1179,39 +1167,39 @@ const mapMapEntries = function (source, mapper) {
     : promiseAll(promises).then(always(result))
 }
 
-const _map = function (value, mapper) {
+const _map = function (value, f) {
   if (isArray(value)) {
-    return arrayMap(value, mapper)
+    return arrayMap(value, f)
   }
   if (value == null) {
     return value
   }
 
   if (typeof value.then == 'function') {
-    return value.then(mapper)
+    return value.then(f)
   }
   if (typeof value.map == 'function') {
-    return value.map(mapper)
+    return value.map(f)
   }
   if (typeof value == 'string' || value.constructor == String) {
-    return stringMap(value, mapper)
+    return stringMap(value, f)
   }
   if (value.constructor == Set) {
-    return setMap(value, mapper)
+    return setMap(value, f)
   }
   if (value.constructor == Map) {
-    return mapMap(value, mapper)
+    return mapMap(value, f)
   }
   if (typeof value[symbolIterator] == 'function') {
-    return MappingIterator(value[symbolIterator](), mapper)
+    return MappingIterator(value[symbolIterator](), f)
   }
   if (typeof value[symbolAsyncIterator] == 'function') {
-    return MappingAsyncIterator(value[symbolAsyncIterator](), mapper)
+    return MappingAsyncIterator(value[symbolAsyncIterator](), f)
   }
   if (value.constructor == Object) {
-    return objectMap(value, mapper)
+    return objectMap(value, f)
   }
-  return mapper(value)
+  return f(value)
 }
 
 const map = function (arg0, arg1) {
@@ -1223,16 +1211,16 @@ const map = function (arg0, arg1) {
     : _map(arg0, arg1)
 }
 
-// _mapEntries(value Object|Map, mapper function) -> Object|Map
-const _mapEntries = (value, mapper) => {
+// _mapEntries(value Object|Map, f function) -> Object|Map
+const _mapEntries = (value, f) => {
   if (value == null) {
     throw new TypeError('value is not an Object or Map')
   }
   if (value.constructor == Object) {
-    return objectMapEntries(value, mapper)
+    return objectMapEntries(value, f)
   }
   if (value.constructor == Map) {
-    return mapMapEntries(value, mapper)
+    return mapMapEntries(value, f)
   }
   throw new TypeError('value is not an Object or Map')
 }
@@ -1278,26 +1266,26 @@ map.series = function mapSeries(arg0, arg1) {
     : _mapSeries(arg0, arg1)
 }
 
-const _mapPool = function (collection, concurrency, f) {
-  if (isArray(collection)) {
-    return arrayMapPool(collection, concurrency, f)
+const _mapPool = function (f, concurrency, mapper) {
+  if (isArray(f)) {
+    return arrayMapPool(f, concurrency, mapper)
   }
-  if (collection == null) {
-    throw new TypeError(`invalid collection ${collection}`)
+  if (f == null) {
+    throw new TypeError(`invalid functor ${f}`)
   }
-  if (typeof collection == 'string' || collection.constructor == String) {
-    return stringMapPool(collection, concurrency, f)
+  if (typeof f == 'string' || f.constructor == String) {
+    return stringMapPool(f, concurrency, mapper)
   }
-  if (collection.constructor == Set) {
-    return setMapPool(collection, concurrency, f)
+  if (f.constructor == Set) {
+    return setMapPool(f, concurrency, mapper)
   }
-  if (collection.constructor == Map) {
-    return mapMapPool(collection, concurrency, f)
+  if (f.constructor == Map) {
+    return mapMapPool(f, concurrency, mapper)
   }
-  if (collection.constructor == Object) {
-    return objectMapPool(collection, concurrency, f)
+  if (f.constructor == Object) {
+    return objectMapPool(f, concurrency, mapper)
   }
-  throw new TypeError(`invalid collection ${collection}`)
+  throw new TypeError(`invalid functor ${f}`)
 }
 
 map.pool = function mapPool(arg0, arg1, arg2) {
@@ -1502,7 +1490,9 @@ const filter = function (arg0, arg1) {
   if (typeof arg0 == 'function') {
     return curry2(_filter, __, arg0)
   }
-  return _filter(arg0, arg1)
+  return isPromise(arg0)
+    ? arg0.then(curry2(_filter, __, arg1))
+    : _filter(arg0, arg1)
 }
 
 const objectValues = Object.values
@@ -1763,17 +1753,17 @@ const genericReduce = function (collection, reducer, result) {
     : reducer(result, collection)
 }
 
-// _reduce(collection any, reducer function, initialValue function|any) -> Promise
-const _reduce = function (collection, reducer, initialValue) {
-  if (typeof initialValue == 'function') {
-    const actualInitialValue = initialValue(collection)
+// _reduce(collection any, reducer function, initial function|any) -> Promise
+const _reduce = function (collection, reducer, initial) {
+  if (typeof initial == 'function') {
+    const actualInitialValue = initial(collection)
     return isPromise(actualInitialValue)
       ? actualInitialValue.then(curry3(genericReduce, collection, reducer, __))
       : genericReduce(collection, reducer, actualInitialValue)
   }
-  return isPromise(initialValue)
-    ? initialValue.then(curry3(genericReduce, collection, reducer, __))
-    : genericReduce(collection, reducer, initialValue)
+  return isPromise(initial)
+    ? initial.then(curry3(genericReduce, collection, reducer, __))
+    : genericReduce(collection, reducer, initial)
 }
 
 const reduce = function (...args) {

package/lte.js

@@ -53,6 +53,15 @@ const lessThanOrEqual = require('./_internal/lessThanOrEqual')
  * ```javascript [playground]
  * lte(Promise.resolve({ a: 1, b: 1 }), get('a'), get('b')).then(console.log) // true
  * ```
+ *
+ * See also:
+ *  * [and](/docs/and)
+ *  * [eq](/docs/eq)
+ *  * [lt](/docs/lt)
+ *  * [gt](/docs/gt)
+ *  * [gte](/docs/gte)
+ *  * [thunkify](/docs/thunkify)
+ *
  */
 const lte = ComparisonOperator(lessThanOrEqual)