rubico 1.9.6 → 2.0.0

package/_internal/TimeInLoopSuite.js

@@ -0,0 +1,138 @@
+const timeInLoop = require('./timeInLoop')
+const timeInLoopAsync = require('./timeInLoopAsync')
+
+/**
+ * @name formatRunOutput
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * formatRunOutput(
+ *   description string,
+ *   loopCount number,
+ *   duration number
+ * ) -> formatted string
+ * ```
+ */
+const formatRunOutput = function (description, loopCount, duration) {
+  const formattedDuration = duration < 1e3
+    ? `${duration.toFixed(3)}ms`
+    : `${(duration / 1e3).toFixed(3)}s`
+  return `
+${description}: ${loopCount.toExponential()}: ${formattedDuration}
+  `.trim()
+}
+
+/**
+ * @name TimeInLoopSuite
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * new TimeInLoopSuite(options? {
+ *   loopCount?: number,
+ *   runs?: number,
+ *   async?: boolean,
+ * }) -> TimeInLoopSuite
+ * ```
+ */
+const TimeInLoopSuite = function (options = {}) {
+  this.loopCount = options.loopCount ?? 1e6
+  this.runs = options.runs ?? 5
+  this.isAsync = options.async ?? false
+  this.benchmarkCases = []
+  this.handlerMap = new Map()
+}
+
+
+/**
+ * @name TimeInLoopSuite.prototype.emit
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * new TimeInLoopSuite(...).emit(eventName string, event Object) -> ()
+ * ```
+ */
+TimeInLoopSuite.prototype.emit = function (eventName, event) {
+  const handlerMap = this.handlerMap
+  if (handlerMap.has(eventName)) {
+    handlerMap.get(eventName).forEach(handler => handler(event))
+  }
+}
+
+/**
+ * @name TimeInLoopSuite.prototype.on
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * new TimeInLoopSuite(...).on(eventName string, handler function) -> ()
+ * ```
+ */
+TimeInLoopSuite.prototype.on = function (eventName, handler) {
+  const handlerMap = this.handlerMap
+  if (handlerMap.has(eventName)) {
+    handlerMap.get(eventName).add(handler)
+  } else {
+    handlerMap.set(eventName, new Set([handler]))
+  }
+}
+
+/**
+ * @name TimeInLoopSuite.prototype.add
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * new TimeInLoopSuite(...).add(description string, func function) -> ()
+ * ```
+ */
+TimeInLoopSuite.prototype.add = function (description, func) {
+  const { loopCount, isAsync } = this
+  this.benchmarkCases.push({
+    description,
+    loopCount,
+    benchmark: isAsync
+      ? () => timeInLoopAsync(description, loopCount, func, { silent: true })
+      : () => timeInLoop(description, loopCount, func, { silent: true }),
+  })
+}
+
+/**
+ * @name TimeInLoopSuite.prototype.run
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * new TimeInLoopSuite(...).run() -> Promise<>
+ * ```
+ */
+TimeInLoopSuite.prototype.run = async function () {
+  const caseBestRuns = []
+  for (const { description, loopCount, benchmark } of this.benchmarkCases) {
+    const durations = []
+    let runCount = 0
+    while (runCount < this.runs) {
+      const { duration } = await benchmark()
+      durations.push(duration)
+      runCount += 1
+      this.emit('run', { description, duration, loopCount })
+    }
+
+    const caseBestDuration = Math.min(...durations)
+
+    const caseBestRun = {
+      description,
+      duration: caseBestDuration,
+      loopCount,
+      output: formatRunOutput(description, loopCount, caseBestDuration),
+    }
+
+    caseBestRuns.push(caseBestRun)
+
+    this.emit('caseBestRun', caseBestRun)
+  }
+
+  const suiteBestRun = caseBestRuns.reduce(
+    (suiteBest, run) => run.duration < suiteBest.duration ? run : suiteBest
+  )
+
+  this.emit('suiteBestRun', suiteBestRun)
+}
+
+module.exports = TimeInLoopSuite

package/_internal/areAnyValuesPromises.js

@@ -0,0 +1,23 @@
+const isPromise = require('./isPromise')
+
+/**
+ * @name areAnyValuesPromises
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * areAnyValuesPromises(values Array) -> boolean
+ * ```
+ */
+const areAnyValuesPromises = function (values) {
+  const length = values.length
+  let index = -1
+  while (++index < length) {
+    const value = values[index]
+    if (isPromise(value)) {
+      return true
+    }
+  }
+  return false
+}
+
+module.exports = areAnyValuesPromises

package/_internal/{arrayAll.js → arrayEvery.js}

@@ -5,14 +5,14 @@ const promiseAll = require('./promiseAll')
 const callPropUnary = require('./callPropUnary')
 
 /**
- * @name arrayAll
+ * @name arrayEvery
  *
  * @synopsis
  * ```coffeescript [specscript]
- * arrayAll(array Array, predicate ...any=>boolean) -> boolean
+ * arrayEvery(array Array, predicate ...any=>boolean) -> boolean
  * ```
  */
-const arrayAll = function (array, predicate) {
+const arrayEvery = function (array, predicate) {
   const arrayLength = array.length,
     promises = []
   let index = -1
@@ -29,4 +29,4 @@ const arrayAll = function (array, predicate) {
     : promiseAll(promises).then(curry3(callPropUnary, __, 'every', Boolean))
 }
 
-module.exports = arrayAll
+module.exports = arrayEvery

package/_internal/arrayExtend.js

@@ -1,4 +1,5 @@
-const isArrayLike = require('./isArrayLike')
+const isArray = require('./isArray')
+const isBinary = require('./isBinary')
 
 /**
  * @name _arrayExtend
@@ -30,7 +31,7 @@ const _arrayExtend = function (array, values) {
  * Extend an array with values.
  */
 const arrayExtend = function (array, values) {
-  if (isArrayLike(values)) {
+  if (isArray(values) || isBinary(values)) {
     return _arrayExtend(array, values)
   }
   array.push(values)

package/_internal/arrayFilter.js

@@ -26,12 +26,11 @@ const arrayFilter = function (array, predicate) {
     resultIndex = -1
   while (++index < arrayLength) {
     const item = array[index],
-      shouldIncludeItem = predicate(item)
+      shouldIncludeItem = predicate(item, index, array)
     if (isPromise(shouldIncludeItem)) {
       return promiseAll(
-        arrayExtendMap(
-          [shouldIncludeItem], array, predicate, index)).then(
-            curry4(arrayFilterByConditions, array, result, index - 1, __))
+        arrayExtendMap([shouldIncludeItem], array, predicate, index)
+      ).then(curry4(arrayFilterByConditions, array, result, index - 1, __))
     }
     if (shouldIncludeItem) {
       result[++resultIndex] = item

package/_internal/{arrayAny.js → arraySome.js}

@@ -3,11 +3,11 @@ const isPromise = require('./isPromise')
 const promiseRace = require('./promiseRace')
 
 /**
- * @name asyncArrayAny
+ * @name asyncArraySome
  *
  * @synopsis
  * ```coffeescript [specscript]
- * asyncArrayAny(
+ * asyncArraySome(
  *   array Array,
  *   predicate any=>Promise|boolean,
  *   index number,
@@ -15,7 +15,7 @@ const promiseRace = require('./promiseRace')
  * ) -> boolean
  * ```
  */
-const asyncArrayAny = async function (
+const asyncArraySome = async function (
   array, predicate, index, promisesInFlight,
 ) {
   const length = array.length
@@ -39,23 +39,23 @@ const asyncArrayAny = async function (
 }
 
 /**
- * @name arrayAny
+ * @name arraySome
  *
  * @synopsis
  * ```coffeescript [specscript]
- * arrayAny(
+ * arraySome(
  *   array Array,
  *   predicate any=>Promise|boolean,
  * ) -> boolean
  * ```
  */
-const arrayAny = function (array, predicate) {
+const arraySome = function (array, predicate) {
   const length = array.length
   let index = -1
   while (++index < length) {
     const predication = predicate(array[index])
     if (isPromise(predication)) {
-      return asyncArrayAny(
+      return asyncArraySome(
         array, predicate, index, new Set([SelfReferencingPromise(predication)]))
     }
     if (predication) {
@@ -65,4 +65,4 @@ const arrayAny = function (array, predicate) {
   return false
 }
 
-module.exports = arrayAny
+module.exports = arraySome

package/_internal/{asyncIteratorAll.js → asyncIteratorEvery.js}

@@ -3,7 +3,7 @@ const isPromise = require('./isPromise')
 const promiseRace = require('./promiseRace')
 
 /**
- * @name asyncIteratorAll
+ * @name asyncIteratorEvery
  *
  * @synopsis
  * var T any,
@@ -12,11 +12,11 @@ const promiseRace = require('./promiseRace')
  *   promisesInFlight Set<Promise<[T, Promise]>>,
  *   maxConcurrency number
  *
- * asyncIteratorAll(
+ * asyncIteratorEvery(
  *   asyncIterator, predicate, promisesInFlight, maxConcurrency,
  * ) -> Promise<boolean>
  */
-const asyncIteratorAll = async function (
+const asyncIteratorEvery = async function (
   asyncIterator, predicate, promisesInFlight, maxConcurrency = 20,
 ) {
   let iteration = await asyncIterator.next()
@@ -47,4 +47,4 @@ const asyncIteratorAll = async function (
   return true
 }
 
-module.exports = asyncIteratorAll
+module.exports = asyncIteratorEvery

package/_internal/{asyncIteratorAny.js → asyncIteratorSome.js}

@@ -3,11 +3,11 @@ const isPromise = require('./isPromise')
 const promiseRace = require('./promiseRace')
 
 /**
- * @name asyncIteratorAny
+ * @name asyncIteratorSome
  *
  * @synopsis
  * ```coffeescript [specscript]
- * asyncIteratorAny(
+ * asyncIteratorSome(
  *   iterator Iterator|AsyncIterator,
  *   predicate any=>Promise|boolean,
  *   index number,
@@ -16,7 +16,7 @@ const promiseRace = require('./promiseRace')
  * ) -> boolean
  * ```
  */
-const asyncIteratorAny = async function (
+const asyncIteratorSome = async function (
   iterator, predicate, promisesInFlight, maxConcurrency = 20,
 ) {
   let iteration = iterator.next()
@@ -53,4 +53,4 @@ const asyncIteratorAny = async function (
   return false
 }
 
-module.exports = asyncIteratorAny
+module.exports = asyncIteratorSome

package/_internal/curry4.test.js

@@ -0,0 +1,25 @@
+const assert = require('assert')
+const curry4 = require('./curry4')
+const __ = require('./placeholder')
+
+describe('curry4', () => {
+  const func = function (a, b, c, d) {
+    return [a, b, c, d]
+  }
+  it('resolves arguments in __ position for arg0', async () => {
+    const curried = curry4(func, __, 1, 2, 3)
+    assert.deepEqual(curried(4), [4, 1, 2, 3])
+  })
+  it('resolves arguments in __ position for arg1', async () => {
+    const curried = curry4(func, 1, __, 2, 3)
+    assert.deepEqual(curried(4), [1, 4, 2, 3])
+  })
+  it('resolves arguments in __ position for arg2', async () => {
+    const curried = curry4(func, 1, 2, __, 3)
+    assert.deepEqual(curried(4), [1, 2, 4, 3])
+  })
+  it('resolves arguments in __ position for arg3', async () => {
+    const curried = curry4(func, 1, 2, 3, __)
+    assert.deepEqual(curried(4), [1, 2, 3, 4])
+  })
+})

package/_internal/curry5.test.js

@@ -0,0 +1,29 @@
+const assert = require('assert')
+const curry5 = require('./curry5')
+const __ = require('./placeholder')
+
+describe('curry5', () => {
+  const func = function (a, b, c, d, e) {
+    return [a, b, c, d, e]
+  }
+  it('resolves arguments in __ position for arg0', async () => {
+    const curried = curry5(func, __, 1, 2, 3, 4)
+    assert.deepEqual(curried(5), [5, 1, 2, 3, 4])
+  })
+  it('resolves arguments in __ position for arg1', async () => {
+    const curried = curry5(func, 1, __, 2, 3, 4)
+    assert.deepEqual(curried(5), [1, 5, 2, 3, 4])
+  })
+  it('resolves arguments in __ position for arg2', async () => {
+    const curried = curry5(func, 1, 2, __, 3, 4)
+    assert.deepEqual(curried(5), [1, 2, 5, 3, 4])
+  })
+  it('resolves arguments in __ position for arg3', async () => {
+    const curried = curry5(func, 1, 2, 3, __, 4)
+    assert.deepEqual(curried(5), [1, 2, 3, 5, 4])
+  })
+  it('resolves arguments in __ position for arg4', async () => {
+    const curried = curry5(func, 1, 2, 3, 4, __)
+    assert.deepEqual(curried(5), [1, 2, 3, 4, 5])
+  })
+})

package/_internal/curryArgs2.js

@@ -0,0 +1,43 @@
+const __ = require('./placeholder')
+
+// argument resolver for curryArgs2
+const curryArgs2ResolveArgs0 = (
+  baseFunc, arg1, arg2,
+) => function args0Resolver(...args) {
+  return baseFunc(args, arg1)
+}
+
+// argument resolver for curryArgs2
+const curryArgs2ResolveArgs1 = (
+  baseFunc, arg0, arg2,
+) => function arg1Resolver(...args) {
+  return baseFunc(arg0, args)
+}
+
+/**
+ * @name curryArgs2
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * type __ = Symbol('placeholder')
+ *
+ * curryArgs2(
+ *   baseFunc function,
+ *   arg0 __|any,
+ *   arg1 __|any,
+ * ) -> function
+ * ```
+ *
+ * @description
+ * Curry arguments for a 2-ary function. Arguments are supplied in placeholder position as an array.
+ *
+ * Note: at least one argument must be the placeholder
+ */
+const curryArgs2 = function (baseFunc, arg0, arg1) {
+  if (arg0 == __) {
+    return curryArgs2ResolveArgs0(baseFunc, arg1)
+  }
+  return curryArgs2ResolveArgs1(baseFunc, arg0)
+}
+
+module.exports = curryArgs2

package/_internal/curryArgs3.test.js

@@ -0,0 +1,21 @@
+const assert = require('assert')
+const curryArgs3 = require('./curryArgs3')
+const __ = require('./placeholder')
+
+describe('curryArgs3', () => {
+  const func = function (a, b, c) {
+    return [a, b, c]
+  }
+  it('resolves arguments in __ position for arg0', async () => {
+    const curried = curryArgs3(func, __, 1, 2)
+    assert.deepEqual(curried(3), [[3], 1, 2])
+  })
+  it('resolves arguments in __ position for arg1', async () => {
+    const curried = curryArgs3(func, 1, __, 2)
+    assert.deepEqual(curried(3), [1, [3], 2])
+  })
+  it('resolves arguments in __ position for arg2', async () => {
+    const curried = curryArgs3(func, 1, 2, __)
+    assert.deepEqual(curried(3), [1, 2, [3]])
+  })
+})

package/_internal/curryArgs4.js

@@ -0,0 +1,65 @@
+const __ = require('./placeholder')
+
+// argument resolver for curryArgs4
+const curryArgs4ResolveArgs0 = (
+  baseFunc, arg1, arg2, arg3,
+) => function args0Resolver(...args) {
+  return baseFunc(args, arg1, arg2, arg3)
+}
+
+// argument resolver for curryArgs4
+const curryArgs4ResolveArgs1 = (
+  baseFunc, arg0, arg2, arg3,
+) => function args1Resolver(...args) {
+  return baseFunc(arg0, args, arg2, arg3)
+}
+
+// argument resolver for curryArgs4
+const curryArgs4ResolveArgs2 = (
+  baseFunc, arg0, arg1, arg3,
+) => function args2Resolver(...args) {
+  return baseFunc(arg0, arg1, args, arg3)
+}
+
+// argument resolver for curryArgs4
+const curryArgs4ResolveArgs3 = (
+  baseFunc, arg0, arg1, arg2,
+) => function args3Resolver(...args) {
+  return baseFunc(arg0, arg1, arg2, args)
+}
+
+/**
+ * @name curryArgs4
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * __ = Symbol('placeholder')
+ *
+ * curryArgs4(
+ *   baseFunc function,
+ *   arg0 __|any,
+ *   arg1 __|any,
+ *   arg2 __|any
+ *   arg3 __|any,
+ * ) -> function
+ * ```
+ *
+ * @description
+ * Curry arguments for a 4-ary function. Arguments are supplied in placeholder position as an array.
+ *
+ * Note: at least one argument must be the placeholder
+ */
+const curryArgs4 = function (baseFunc, arg0, arg1, arg2, arg3) {
+  if (arg0 == __) {
+    return curryArgs4ResolveArgs0(baseFunc, arg1, arg2, arg3)
+  }
+  if (arg1 == __) {
+    return curryArgs4ResolveArgs1(baseFunc, arg0, arg2, arg3)
+  }
+  if (arg2 == __) {
+    return curryArgs4ResolveArgs2(baseFunc, arg0, arg1, arg3)
+  }
+  return curryArgs4ResolveArgs3(baseFunc, arg0, arg1, arg2)
+}
+
+module.exports = curryArgs4

package/_internal/curryArgs4.test.js

@@ -0,0 +1,25 @@
+const assert = require('assert')
+const curryArgs4 = require('./curryArgs4')
+const __ = require('./placeholder')
+
+describe('curryArgs4', () => {
+  const func = function (a, b, c, d) {
+    return [a, b, c, d]
+  }
+  it('resolves arguments in __ position for arg0', async () => {
+    const curried = curryArgs4(func, __, 1, 2, 3)
+    assert.deepEqual(curried(1, 2, 3), [[1, 2, 3], 1, 2, 3])
+  })
+  it('resolves arguments in __ position for arg1', async () => {
+    const curried = curryArgs4(func, 1, __, 2, 3)
+    assert.deepEqual(curried(1, 2, 3), [1, [1, 2, 3], 2, 3])
+  })
+  it('resolves arguments in __ position for arg2', async () => {
+    const curried = curryArgs4(func, 1, 2, __, 3)
+    assert.deepEqual(curried(1, 2, 3), [1, 2, [1, 2, 3], 3])
+  })
+  it('resolves arguments in __ position for arg3', async () => {
+    const curried = curryArgs4(func, 1, 2, 3, __)
+    assert.deepEqual(curried(1, 2, 3), [1, 2, 3, [1, 2, 3]])
+  })
+})

package/_internal/equals.js

@@ -0,0 +1,13 @@
+/**
+ * @name equals
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * equals(left any, right any) -> boolean
+ * ```
+ */
+const equals = function (left, right) {
+  return left == right
+}
+
+module.exports = equals

package/_internal/findAllFilePaths.js

@@ -0,0 +1,22 @@
+const fs = require('fs')
+const pathResolve = require('./pathResolve')
+
+// findAllFilePaths(path string) -> filePaths Promise<Array<string>>
+const findAllFilePaths = async function (path) {
+  const files = await fs.promises.readdir(path, {
+    withFileTypes: true,
+    recursive: true,
+  })
+  const result = []
+  for (const file of files) {
+    if (file.isDirectory()) {
+      const filePaths = await findAllFilePaths(pathResolve(path, file.name))
+      result.push(...filePaths)
+    } else {
+      result.push(pathResolve(path, file.name))
+    }
+  }
+  return result
+}
+
+module.exports = findAllFilePaths

package/_internal/funcApply.js

@@ -13,3 +13,5 @@
  * Apply arguments to a function.
  */
 const funcApply = (func, args) => func(...args)
+
+module.exports = funcApply

package/_internal/funcCall.js

@@ -0,0 +1,14 @@
+/**
+ * @name funcCall
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * funcCall(func function, context Object, ...args) -> any
+ * ```
+ *
+ * @description
+ * Apply arguments to a function.
+ */
+const funcCall = (func, context, ...args) => func.call(context, ...args)
+
+module.exports = funcCall

package/_internal/functionArrayAll.js

@@ -0,0 +1,26 @@
+const isPromise = require('./isPromise')
+const promiseAll = require('./promiseAll')
+
+/**
+ * @name functionArrayAll
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * functionArrayAll(funcs Array<function>, args Array) -> Promise|Array
+ * ```
+ */
+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)
+    if (isPromise(resultItem)) {
+      isAsync = true
+    }
+    result[funcsIndex] = resultItem
+  }
+  return isAsync ? promiseAll(result) : result
+}
+
+module.exports = functionArrayAll

package/_internal/functionArrayAllSeries.js

@@ -0,0 +1,55 @@
+const funcConcat = require('./funcConcat')
+const isPromise = require('./isPromise')
+const __ = require('./placeholder')
+const curry3 = require('./curry3')
+const curry4 = require('./curry4')
+const objectSet = require('./objectSet')
+
+/**
+ * @name asyncFunctionArrayAllSeries
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * asyncFunctionArrayAllSeries(
+ *   funcs Array<function>,
+ *   args Array,
+ *   result Array,
+ *   funcsIndex number
+ * ) -> Promise|Array
+ * ```
+ *
+ * @TODO benchmark vs regular promise handling
+ */
+const asyncFunctionArrayAllSeries = async function (funcs, args, result, funcsIndex) {
+  const funcsLength = funcs.length
+  while (++funcsIndex < funcsLength) {
+    const resultItem = funcs[funcsIndex](...args)
+    result[funcsIndex] = isPromise(resultItem) ? await resultItem : resultItem
+  }
+  return result
+}
+
+/**
+ * @name functionArrayAllSeries
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * functionArrayAllSeries(funcs Array<function>, args Array) -> Promise|Array
+ * ```
+ */
+const functionArrayAllSeries = function (funcs, args) {
+  const funcsLength = funcs.length, result = []
+  let funcsIndex = -1
+  while (++funcsIndex < funcsLength) {
+    const resultItem = funcs[funcsIndex](...args)
+    if (isPromise(resultItem)) {
+      return resultItem.then(funcConcat(
+        curry3(objectSet, result, funcsIndex, __),
+        curry4(asyncFunctionArrayAllSeries, funcs, args, __, funcsIndex)))
+    }
+    result[funcsIndex] = resultItem
+  }
+  return result
+}
+
+module.exports = functionArrayAllSeries