rubico 1.9.7 → 2.0.1

package/_internal/objectReduce.js

@@ -2,7 +2,6 @@ const isPromise = require('./isPromise')
 const __ = require('./placeholder')
 const curry5 = require('./curry5')
 const objectKeys = require('./objectKeys')
-const objectGetFirstKey = require('./objectGetFirstKey')
 
 /**
  * @name objectReduceAsync

package/_internal/pathResolve.js

@@ -0,0 +1,6 @@
+const path = require('path')
+
+// pathResolve(...args) -> resolvedPath string
+const pathResolve = (...args) => path.resolve(...args)
+
+module.exports = pathResolve

package/_internal/{reducerAll.js → reducerEvery.js}

@@ -4,20 +4,20 @@ const curry3 = require('./curry3')
 const reducerAllSync = require('./reducerAllSync')
 
 /**
- * @name reducerAll
+ * @name reducerEvery
  *
  * @synopsis
  * ```coffeescript [specscript]
- * reducerAll(
+ * reducerEvery(
  *   predicate any=>boolean,
  * ) -> reducer(result boolean, item any)=>boolean
  * ```
  */
-const reducerAll = predicate => function allReducer(result, item) {
+const reducerEvery = predicate => function allReducer(result, item) {
   return result === false ? false
     : isPromise(result) ? result.then(
       curry3(reducerAllSync, predicate, __, item))
     : result ? predicate(item) : false
 }
 
-module.exports = reducerAll
+module.exports = reducerEvery

package/_internal/reducerFlatMap.js

@@ -1,7 +1,7 @@
-const curryArgs3 = require('./curryArgs3')
-const genericReduce = require('./genericReduce')
+const curry3 = require('./curry3')
 const __ = require('./placeholder')
 const isPromise = require('./isPromise')
+const genericReduce = require('./genericReduce')
 
 /**
  * @name reducerFlatMap
@@ -26,8 +26,8 @@ const reducerFlatMap = (
 ) => function flatMappingReducer(result, value) {
   const monad = flatMapper(value)
   return isPromise(monad)
-    ? monad.then(curryArgs3(genericReduce, __, reducer, result))
-    : genericReduce([monad], reducer, result)
+    ? monad.then(curry3(genericReduce, __, reducer, result))
+    : genericReduce(monad, reducer, result)
 }
 
 module.exports = reducerFlatMap

package/_internal/reducerFlatten.js

@@ -26,7 +26,7 @@ const genericReduce = require('./genericReduce')
 const reducerFlatten = reducer => function flatteningReducer(
   result, reducerItem,
 ) {
-  return genericReduce([reducerItem], reducer, result)
+  return genericReduce(reducerItem, reducer, result)
 }
 
 module.exports = reducerFlatten

package/_internal/{reducerAny.js → reducerSome.js}

@@ -4,11 +4,11 @@ const __ = require('./placeholder')
 const isPromise = require('./isPromise')
 
 /**
- * @name reducerAny
+ * @name reducerSome
  *
  * @synopsis
  * ```coffeescript [specscript]
- * reducerAny(
+ * reducerSome(
  *   predicate any=>boolean,
  * ) -> anyReducer (result boolean, item any)=>boolean
  * ```
@@ -17,10 +17,10 @@ const isPromise = require('./isPromise')
  *
  * @TODO throw to break early?
  */
-const reducerAny = predicate => function anyReducer(result, item) {
+const reducerSome = predicate => function anyReducer(result, item) {
   return result === true ? result
     : isPromise(result) ? result.then(curry2(reducerAnySync(predicate), __, item))
     : result ? true : predicate(item)
 }
 
-module.exports = reducerAny
+module.exports = reducerSome

package/_internal/timeInLoop.js

@@ -0,0 +1,37 @@
+/**
+ * @name timeInLoop
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * timeInLoop(description string, loopCount number, fn function, options? {
+ *   silent?: boolean,
+ * }) -> undefined
+ * ```
+ *
+ * @description
+ * Logs the amount of time required for a function to run a certain number of times
+ *
+ * ```js
+ * timeInLoop('hello', 1e6, () => 'hello') // hello: 1e+6: 3.474ms
+ * ```
+ *
+ * Reference: https://gist.github.com/funfunction/91b5876a5f562e1e352aed0fcabc3858
+ */
+const timeInLoop = (description, loopCount, fn, options = {}) => {
+  const d = `${description}: ${loopCount.toExponential()}`
+  const start = performance.now()
+  for (let i = 0; i < loopCount; i++) {
+    fn()
+  }
+  const end = performance.now()
+  const duration = end - start
+
+  if (options.silent) {
+    return { description, loopCount, duration }
+  }
+
+  console.log(`${d}: ${duration}`)
+  return { description, loopCount, duration }
+}
+
+module.exports = timeInLoop

package/_internal/timeInLoop.test.js

@@ -0,0 +1,18 @@
+const assert = require('assert')
+const timeInLoop = require('./timeInLoop')
+
+describe('timeInLoop', () => {
+  it('times a function in a loop', async () => {
+    const result = timeInLoop('hey', 1e5, () => 'hey')
+    assert.equal(result.description, 'hey')
+    assert.equal(result.loopCount, 1e5)
+    assert.equal(typeof result.duration, 'number')
+  })
+
+  it('can be silent', async () => {
+    const result = timeInLoop('hey', 1e5, () => 'hey', { silent: true })
+    assert.equal(result.description, 'hey')
+    assert.equal(result.loopCount, 1e5)
+    assert.equal(typeof result.duration, 'number')
+  })
+})

package/_internal/timeInLoopAsync.js

@@ -0,0 +1,35 @@
+/**
+ * @name timeInLoopAsync
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * timeInLoop.async(description string, loopCount number, fn function, options? {
+ *   silent?: boolean,
+ * }) -> undefined
+ * ```
+ *
+ * @description
+ * Like timeInLoop, but every call is awaited
+ *
+ * ```js
+ * timeInLoop.async('async hello', 1e6, async () => 'hello') // async hello: 1e+6: 116.006ms
+ * ```
+ */
+const timeInLoopAsync = async (description, loopCount, fn, options = {}) => {
+  const d = `${description}: ${loopCount.toExponential()}`
+  const start = performance.now()
+  for (let i = 0; i < loopCount; i++) {
+    await fn()
+  }
+  const end = performance.now()
+  const duration = end - start
+
+  if (options.silent) {
+    return { description, loopCount, duration }
+  }
+
+  console.log(`${d}: ${duration}`)
+  return { description, loopCount, duration }
+}
+
+module.exports = timeInLoopAsync

package/_internal/timeInLoopAsync.test.js

@@ -0,0 +1,22 @@
+const assert = require('assert')
+const timeInLoopAsync = require('./timeInLoopAsync')
+
+describe('timeInLoopAsync', () => {
+  it('times an async function in a loop', async () => {
+    const p = timeInLoopAsync('asyncHey', 1e5, async () => 'asyncHey')
+    assert(p instanceof Promise)
+    const result = await p
+    assert.equal(result.description, 'asyncHey')
+    assert.equal(result.loopCount, 1e5)
+    assert.equal(typeof result.duration, 'number')
+  })
+
+  it('can be silent', async () => {
+    const p = timeInLoopAsync('asyncHey', 1e5, async () => 'asyncHey', { silent: true })
+    assert(p instanceof Promise)
+    const result = await p
+    assert.equal(result.description, 'asyncHey')
+    assert.equal(result.loopCount, 1e5)
+    assert.equal(typeof result.duration, 'number')
+  })
+})

package/all.js

@@ -1,72 +1,138 @@
+const areAnyValuesPromises = require('./_internal/areAnyValuesPromises')
+const promiseAll = require('./_internal/promiseAll')
 const isArray = require('./_internal/isArray')
-const arrayAll = require('./_internal/arrayAll')
-const iteratorAll = require('./_internal/iteratorAll')
-const asyncIteratorAll = require('./_internal/asyncIteratorAll')
-const objectValues = require('./_internal/objectValues')
-const reducerAll = require('./_internal/reducerAll')
-const symbolIterator = require('./_internal/symbolIterator')
-const symbolAsyncIterator = require('./_internal/symbolAsyncIterator')
+const __ = require('./_internal/placeholder')
+const curry2 = require('./_internal/curry2')
+const curryArgs2 = require('./_internal/curryArgs2')
+const functionArrayAll = require('./_internal/functionArrayAll')
+const functionArrayAllSeries = require('./_internal/functionArrayAllSeries')
+const functionObjectAll = require('./_internal/functionObjectAll')
 
 /**
  * @name all
  *
  * @synopsis
  * ```coffeescript [specscript]
- * type Foldable = Iterable|AsyncIterable|Object
+ * all(...args, funcsArray Array<function>) -> result Promise|Array
  *
- * all(predicate function)(collection Foldable) -> result Promise|boolean
+ * all(funcsArray Array<function>)(...args) -> result Promise|Array
+ *
+ * all(...args, funcsObject Object<function>) -> result Promise|Object
+ *
+ * all(funcsObject Object<function>)(...args) -> result Promise|Object
  * ```
  *
  * @description
- * Test a predicate concurrently across all items of a collection, returning true if all predications are truthy.
+ * Function executor and composer. Accepts either an array of functions or an object of functions as the values. Calls each function of the provided array or object in parallel with the provided arguments. Returns either an array or object of the results of the function executions.
  *
  * ```javascript [playground]
- * const isOdd = number => number % 2 == 1
+ * const createArrayOfGreetingsFor = all([
+ *   name => `Hi ${name}`,
+ *   name => `Hey ${name}`,
+ *   name => `Hello ${name}`,
+ * ])
+ *
+ * const arrayOfGreetingsForFred = createArrayOfGreetingsFor('Fred')
+ *
+ * console.log(arrayOfGreetingsForFred)
+ * // ['Hi Fred', 'Hey Fred', 'Hello Fred']
  *
- * console.log(
- *   all(isOdd)([1, 2, 3, 4, 5]),
- * ) // false
+ * const createObjectOfGreetingsFor = all({
+ *   hi: name => `Hi ${name}`,
+ *   hey: name => `Hey ${name}`,
+ *   hello: name => `Hello ${name}`,
+ * })
  *
- * console.log(
- *   all(isOdd)([1, 3, 5]),
- * ) // true
+ * const objectOfGreetingsForJane = createObjectOfGreetingsFor('Jane')
+ *
+ * console.log(objectOfGreetingsForJane)
+ * // { hi: 'Hi Jane', hey: 'Hey Jane', hello: 'Hello Jane' }
  * ```
  *
- * The collection can be any iterable, async iterable, or object values iterable collection. Below is an example of `all` accepting an async generator as the collection.
+ * `all` can simultaneously compose objects and handle promises.
  *
  * ```javascript [playground]
- * const asyncNumbers = async function* () {
- *   yield 1; yield 2; yield 3; yield 4; yield 5
- * }
+ * const identity = value => value
+ *
+ * const userbase = new Map()
+ * userbase.set('1', { _id: 1, name: 'George' })
+ *
+ * const getUserByID = async id => userbase.get(id)
+ *
+ * const getAndLogUserById = pipe([
+ *   all({
+ *     id: identity,
+ *     user: getUserByID,
+ *   }),
+ *   tap(({ id, user }) => {
+ *     console.log(`Got user ${JSON.stringify(user)} by id ${id}`)
+ *   }),
+ * ])
  *
- * all(async number => number < 6)(asyncNumbers()).then(console.log) // true
+ * getAndLogUserById('1') // Got user {"_id":1,"name":"George"} by id 1
  * ```
  *
  * @execution concurrent
- *
- * @muxing
  */
-const all = predicate => function allTruthy(value) {
-  if (isArray(value)) {
-    return arrayAll(value, predicate)
-  }
-  if (value == null) {
-    return predicate(value)
-  }
 
-  if (typeof value[symbolIterator] == 'function') {
-    return iteratorAll(value[symbolIterator](), predicate)
+const all = function (...args) {
+  const funcs = args.pop()
+  if (args.length == 0) {
+    return isArray(funcs)
+      ? curryArgs2(functionArrayAll, funcs, __)
+      : curryArgs2(functionObjectAll, funcs, __)
   }
-  if (typeof value[symbolAsyncIterator] == 'function') {
-    return asyncIteratorAll(value[symbolAsyncIterator](), predicate, new Set())
+
+  if (areAnyValuesPromises(args)) {
+    return isArray(funcs)
+      ? promiseAll(args).then(curry2(functionArrayAll, funcs, __))
+      : promiseAll(args).then(curry2(functionObjectAll, funcs, __))
   }
-  if (typeof value.reduce == 'function') {
-    return value.reduce(reducerAll(predicate), true)
+
+  return isArray(funcs)
+    ? functionArrayAll(funcs, args)
+    : functionObjectAll(funcs, args)
+}
+
+/**
+ * @name all.series
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * all.series(...args, funcsArray Array<function>) -> result Promise|Array
+ *
+ * all.series(funcsArray Array<function>)(...args) -> result Promise|Array
+ * ```
+ *
+ * @description
+ * `all` with serial execution.
+ *
+ * ```javascript [playground]
+ * const sleep = ms => () => new Promise(resolve => setTimeout(resolve, ms))
+ *
+ * all.series([
+ *   greeting => console.log(greeting + ' world'),
+ *   sleep(1000),
+ *   greeting => console.log(greeting + ' mom'),
+ *   sleep(1000),
+ *   greeting => console.log(greeting + ' goodbye'),
+ * ])('hello') // hello world
+ *             // hello mom
+ *             // hello goodbye
+ * ```
+ *
+ * @execution series
+ */
+
+all.series = function allSeries(...args) {
+  const funcs = args.pop()
+  if (args.length == 0) {
+    return curryArgs2(functionArrayAllSeries, funcs, __)
   }
-  if (value.constructor == Object) {
-    return arrayAll(objectValues(value), predicate)
+  if (areAnyValuesPromises(args)) {
+    return promiseAll(args).then(curry2(functionArrayAllSeries, funcs, __))
   }
-  return predicate(value)
+  return functionArrayAllSeries(funcs, args)
 }
 
 module.exports = all

package/and.js

@@ -1,6 +1,10 @@
+const promiseAll = require('./_internal/promiseAll')
 const isPromise = require('./_internal/isPromise')
-const curry3 = require('./_internal/curry3')
+const areAnyValuesPromises = require('./_internal/areAnyValuesPromises')
 const __ = require('./_internal/placeholder')
+const curry2 = require('./_internal/curry2')
+const curry3 = require('./_internal/curry3')
+const curryArgs2 = require('./_internal/curryArgs2')
 const thunkConditional = require('./_internal/thunkConditional')
 const areAllValuesNonfunctions = require('./_internal/areAllValuesNonfunctions')
 const thunkify2 = require('./_internal/thunkify2')
@@ -8,22 +12,22 @@ const thunkify3 = require('./_internal/thunkify3')
 const always = require('./_internal/always')
 
 /**
- * @name areAllNonfunctionsTruthy
+ * @name areAllValuesTruthy
  *
  * @synopsis
  * ```coffeescript [specscript]
- * areAllNonfunctionsTruthy(predicates Array<value>) -> Promise|boolean
+ * areAllValuesTruthy(predicates Array<value>) -> Promise|boolean
  * ```
  */
-const areAllNonfunctionsTruthy = function (predicates, index) {
+const areAllValuesTruthy = function (predicates, index) {
   const length = predicates.length
   while (++index < length) {
-    let predicate = predicates[index]
+    const predicate = predicates[index]
     if (isPromise(predicate)) {
       return predicate.then(curry3(
         thunkConditional,
         __,
-        thunkify2(areAllNonfunctionsTruthy, predicates, index),
+        thunkify2(areAllValuesTruthy, predicates, index),
         always(false),
       ))
     }
@@ -41,17 +45,17 @@ const areAllNonfunctionsTruthy = function (predicates, index) {
  * ```coffeescript [specscript]
  * asyncArePredicatesAllTruthy(
  *   predicates Array<value=>Promise|boolean>
- *   point any,
+ *   args Array,
  *   index number,
  * ) -> allTruthy boolean
  * ```
  */
-const asyncArePredicatesAllTruthy = async function (predicates, point, index) {
+const asyncArePredicatesAllTruthy = async function (args, predicates, index) {
   const length = predicates.length
   while (++index < length) {
     let predicate = predicates[index]
     if (typeof predicate == 'function') {
-      predicate = predicate(point)
+      predicate = predicate(...args)
     }
     if (isPromise(predicate)) {
       predicate = await predicate
@@ -63,6 +67,31 @@ const asyncArePredicatesAllTruthy = async function (predicates, point, index) {
   return true
 }
 
+// areAllPredicatesTruthy(args Array, predicates Array<function>) -> Promise|boolean
+const areAllPredicatesTruthy = function (args, predicates) {
+  const length = predicates.length
+  let index = -1
+
+  while (++index < length) {
+    let predicate = predicates[index]
+    if (typeof predicate == 'function') {
+      predicate = predicate(...args)
+    }
+    if (isPromise(predicate)) {
+      return predicate.then(curry3(
+        thunkConditional,
+        __,
+        thunkify3(asyncArePredicatesAllTruthy, args, predicates, index),
+        always(false),
+      ))
+    }
+    if (!predicate) {
+      return false
+    }
+  }
+  return true
+}
+
 /**
  * @name and
  *
@@ -70,9 +99,9 @@ const asyncArePredicatesAllTruthy = async function (predicates, point, index) {
  * ```coffeescript [specscript]
  * and(values Array<boolean>) -> result boolean
  *
- * and(
- *   predicatesOrValues Array<function|boolean>
- * )(value any) -> result Promise|boolean
+ * and(...args, predicatesOrValues Array<function|boolean>) -> Promise|boolean
+ *
+ * and(predicatesOrValues Array<function|boolean>)(...args) -> Promise|boolean
  * ```
  *
  * @description
@@ -106,33 +135,22 @@ const asyncArePredicatesAllTruthy = async function (predicates, point, index) {
  *
  * @note ...args slows down here by an order of magnitude
  */
-const and = predicates => {
-  if (areAllValuesNonfunctions(predicates)) {
-    return areAllNonfunctionsTruthy(predicates, -1)
+const and = function (...args) {
+  const predicatesOrValues = args.pop()
+  if (areAllValuesNonfunctions(predicatesOrValues)) {
+    return areAllValuesTruthy(predicatesOrValues, -1)
   }
-  return function arePredicatesAllTruthy(point) {
-    const length = predicates.length
-    let index = -1
 
-    while (++index < length) {
-      let predicate = predicates[index]
-      if (typeof predicate == 'function') {
-        predicate = predicate(point)
-      }
-      if (isPromise(predicate)) {
-        return predicate.then(curry3(
-          thunkConditional,
-          __,
-          thunkify3(asyncArePredicatesAllTruthy, predicates, point, index),
-          always(false),
-        ))
-      }
-      if (!predicate) {
-        return false
-      }
-    }
-    return true
+  if (args.length == 0) {
+    return curryArgs2(areAllPredicatesTruthy, __, predicatesOrValues)
   }
+
+  if (areAnyValuesPromises(args)) {
+    return promiseAll(args)
+      .then(curry2(areAllPredicatesTruthy, __, predicatesOrValues))
+  }
+
+  return areAllPredicatesTruthy(args, predicatesOrValues)
 }
 
 module.exports = and

package/archive/{FlatMappingIteratorCool.js → FlatMappingIterator-2020-09-28.js}

@@ -21,7 +21,7 @@ const FlatMappingIterator = function (iterator, flatMapper) {
   const buffer = [], promises = [],
     bufferPush = curry3(callPropUnary, buffer, 'push', __),
     bufferPushReducer = funcConcatSync(getArg1, bufferPush),
-    flattenIntoBuffer = curryArgs3(genericReduce, __, bufferPushReducer, null),
+    flattenIntoBuffer = curry3(genericReduce, __, bufferPushReducer, null),
     loadIntoBuffer = funcConcatSync(flattenIntoBuffer, tapSync(bufferLoading => {
       if (isPromise(bufferLoading)) {
         const promise = bufferLoading.then(() => promises.delete(promise))

package/archive/_Promise-2023-05-29.js

@@ -0,0 +1,93 @@
+const isPromise = require('./isPromise')
+
+/**
+ * @name _Promise
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * new _Promise() -> _Promise
+ * ```
+ *
+ * @description
+ * Internal _Promise. Does not conform to spec.
+ */
+const _Promise = function () {
+  this.onFulfilledCallbacks = []
+  this.onRejectedCallbacks = []
+  this.value = null
+  this.error = null
+  this.status = 'pending'
+}
+
+_Promise.prototype._fulfill = function (value) {
+  if (this.status == 'pending') {
+    this.status = 'fulfilled'
+    this.value = value
+    this.onFulfilledCallbacks.forEach(cb => cb(value)) // TODO optimize
+  }
+}
+
+_Promise.prototype._reject = function (error) {
+  if (this.status == 'pending') {
+    this.status = 'rejected'
+    this.error = error
+    this.onRejectedCallbacks.forEach(cb => cb(error)) // TODO optimize
+  }
+}
+
+_Promise.prototype.then = function (onFulfilled, onRejected) {
+  return new Promise((resolve, reject) => {
+    if (this.status == 'pending') {
+      this.onFulfilledCallbacks.push(() => {
+        try {
+          const ret = onFulfilled(this.value)
+          if (isPromise(ret)) {
+            ret.then(resolve, reject)
+          } else {
+            resolve(ret)
+          }
+        } catch (error) {
+          reject(error)
+        }
+      })
+      this.onRejectedCallbacks.push(() => {
+        try {
+          const ret = onRejected(this.error)
+          if (isPromise(ret)) {
+            ret.then(resolve, reject)
+          } else {
+            reject(ret)
+          }
+        } catch (error) {
+          reject(error)
+        }
+      })
+    }
+    else if (this.status == 'fulfilled') {
+      try {
+        const ret = onFulfilled(this.value)
+        if (isPromise(ret)) {
+          ret.then(resolve, reject)
+        } else {
+          resolve(ret)
+        }
+      } catch (error) {
+        reject(error)
+      }
+    }
+    else {
+      try {
+        const ret = onRejected(this.error)
+        if (isPromise(ret)) {
+          ret.then(resolve, reject)
+        } else {
+          reject(ret)
+        }
+      } catch (error) {
+        reject(error)
+      }
+    }
+  })
+}
+
+module.exports = _Promise