common-fp 0.1.0

package/dist/find-last.cjs

@@ -0,0 +1,16 @@
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+
+const findLast = predicate => {
+  assertArgIsType(predicate, 'predicate', 'function', 'findLast')
+
+  return anArray => {
+    assertArgIsType(anArray, 'anArray', 'array', 'findLast')
+
+    const arr = anArray
+    for (let i = arr.length - 1; i >= 0; i -= 1) {
+      if (predicate(arr[i], i, arr)) return arr[i]
+    }
+  }
+}
+
+module.exports = findLast

package/dist/find-last.d.cts

@@ -0,0 +1,2 @@
+import { default as findLast } from '@common-fp/common-fp-types/find-last'
+export = findLast

package/dist/find-last.d.ts

@@ -0,0 +1 @@
+export { default } from '@common-fp/common-fp-types/find-last'

package/dist/find-last.mjs

@@ -0,0 +1,16 @@
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+
+const findLast = predicate => {
+  assertArgIsType(predicate, 'predicate', 'function', 'findLast')
+
+  return anArray => {
+    assertArgIsType(anArray, 'anArray', 'array', 'findLast')
+
+    const arr = anArray
+    for (let i = arr.length - 1; i >= 0; i -= 1) {
+      if (predicate(arr[i], i, arr)) return arr[i]
+    }
+  }
+}
+
+export default findLast

package/dist/find.cjs

@@ -0,0 +1,21 @@
+const assertArgTypeIsOneOf = require('@common-fp/shared-internals/assert-arg-type-is-one-of')
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+const ct = require('@common-fp/shared-internals/common-types')
+const getIterator = require('@common-fp/shared-internals/get-iterator')
+const getType = require('@common-fp/shared-internals/get-type')
+
+const find = predicate => {
+  assertArgIsType(predicate, 'predicate', 'function', 'find')
+
+  return collection => {
+    const collType = getType(collection)
+    assertArgTypeIsOneOf(collType, 'collection', ct.collection, 'find')
+    const entries = getIterator('entries', collection, collType)
+
+    for (const [key, val] of entries) {
+      if (predicate(val, key, collection)) return val
+    }
+  }
+}
+
+module.exports = find

package/dist/find.d.cts

@@ -0,0 +1,2 @@
+import { default as find } from '@common-fp/common-fp-types/find'
+export = find

package/dist/find.d.ts

@@ -0,0 +1 @@
+export { default } from '@common-fp/common-fp-types/find'

package/dist/find.mjs

@@ -0,0 +1,21 @@
+import assertArgTypeIsOneOf from '@common-fp/shared-internals/assert-arg-type-is-one-of'
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+import * as ct from '@common-fp/shared-internals/common-types'
+import getIterator from '@common-fp/shared-internals/get-iterator'
+import getType from '@common-fp/shared-internals/get-type'
+
+const find = predicate => {
+  assertArgIsType(predicate, 'predicate', 'function', 'find')
+
+  return collection => {
+    const collType = getType(collection)
+    assertArgTypeIsOneOf(collType, 'collection', ct.collection, 'find')
+    const entries = getIterator('entries', collection, collType)
+
+    for (const [key, val] of entries) {
+      if (predicate(val, key, collection)) return val
+    }
+  }
+}
+
+export default find

package/dist/first.cjs

@@ -0,0 +1,10 @@
+const assertArgIsOneOfType = require('@common-fp/shared-internals/assert-arg-is-one-of-type')
+const ct = require('@common-fp/shared-internals/common-types')
+
+// also known as 'head'
+const first = sequence => {
+  assertArgIsOneOfType(sequence, 'sequence', ct.sequence, 'first')
+  return sequence[0]
+}
+
+module.exports = first

package/dist/first.d.cts

@@ -0,0 +1,2 @@
+import { default as first } from '@common-fp/common-fp-types/first'
+export = first

package/dist/first.d.ts

@@ -0,0 +1 @@
+export { default } from '@common-fp/common-fp-types/first'

package/dist/first.mjs

@@ -0,0 +1,10 @@
+import assertArgIsOneOfType from '@common-fp/shared-internals/assert-arg-is-one-of-type'
+import * as ct from '@common-fp/shared-internals/common-types'
+
+// also known as 'head'
+const first = sequence => {
+  assertArgIsOneOfType(sequence, 'sequence', ct.sequence, 'first')
+  return sequence[0]
+}
+
+export default first

package/dist/flatten-fully.cjs

@@ -0,0 +1,9 @@
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+
+const flattenFully = anArray => {
+  assertArgIsType(anArray, 'anArray', 'array', 'flattenFully')
+
+  return anArray.flat(Infinity)
+}
+
+module.exports = flattenFully

package/dist/flatten-fully.d.cts

@@ -0,0 +1,2 @@
+import { default as flattenFully } from '@common-fp/common-fp-types/flatten-fully'
+export = flattenFully

package/dist/flatten-fully.d.ts

@@ -0,0 +1 @@
+export { default } from '@common-fp/common-fp-types/flatten-fully'

package/dist/flatten-fully.mjs

@@ -0,0 +1,9 @@
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+
+const flattenFully = anArray => {
+  assertArgIsType(anArray, 'anArray', 'array', 'flattenFully')
+
+  return anArray.flat(Infinity)
+}
+
+export default flattenFully

package/dist/flatten-once.cjs

@@ -0,0 +1,9 @@
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+
+const flattenOnce = anArray => {
+  assertArgIsType(anArray, 'anArray', 'array', 'flattenOnce')
+
+  return anArray.flat()
+}
+
+module.exports = flattenOnce

package/dist/flatten-once.d.cts

@@ -0,0 +1,2 @@
+import { default as flattenOnce } from '@common-fp/common-fp-types/flatten-once'
+export = flattenOnce

package/dist/flatten-once.d.ts

@@ -0,0 +1 @@
+export { default } from '@common-fp/common-fp-types/flatten-once'

package/dist/flatten-once.mjs

@@ -0,0 +1,9 @@
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+
+const flattenOnce = anArray => {
+  assertArgIsType(anArray, 'anArray', 'array', 'flattenOnce')
+
+  return anArray.flat()
+}
+
+export default flattenOnce

package/dist/flatten-to-depth.cjs

@@ -0,0 +1,15 @@
+const assertArgIsInt = require('@common-fp/shared-internals/assert-arg-is-int')
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+
+const flattenToDepth = depth => {
+  if (depth !== Infinity)
+    assertArgIsInt(depth, 'depth', 'flattenToDepth', { nonNegative: true })
+
+  return anArray => {
+    assertArgIsType(anArray, 'anArray', 'array', 'flattenToDepth')
+
+    return anArray.flat(depth)
+  }
+}
+
+module.exports = flattenToDepth

package/dist/flatten-to-depth.d.cts

@@ -0,0 +1,2 @@
+import { default as flattenToDepth } from '@common-fp/common-fp-types/flatten-to-depth'
+export = flattenToDepth

package/dist/flatten-to-depth.d.ts

@@ -0,0 +1 @@
+export { default } from '@common-fp/common-fp-types/flatten-to-depth'

package/dist/flatten-to-depth.mjs

@@ -0,0 +1,15 @@
+import assertArgIsInt from '@common-fp/shared-internals/assert-arg-is-int'
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+
+const flattenToDepth = depth => {
+  if (depth !== Infinity)
+    assertArgIsInt(depth, 'depth', 'flattenToDepth', { nonNegative: true })
+
+  return anArray => {
+    assertArgIsType(anArray, 'anArray', 'array', 'flattenToDepth')
+
+    return anArray.flat(depth)
+  }
+}
+
+export default flattenToDepth

package/dist/for-each.cjs

@@ -0,0 +1,22 @@
+const assertArgTypeIsOneOf = require('@common-fp/shared-internals/assert-arg-type-is-one-of')
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+const ct = require('@common-fp/shared-internals/common-types')
+const getIterator = require('@common-fp/shared-internals/get-iterator')
+const getType = require('@common-fp/shared-internals/get-type')
+
+const forEach = fn => {
+  assertArgIsType(fn, 'fn', 'function', 'forEach')
+
+  return collection => {
+    const collType = getType(collection)
+    assertArgTypeIsOneOf(collType, 'collection', ct.collection, 'forEach')
+    const entries = getIterator('entries', collection, collType)
+    for (const [key, val] of entries) {
+      fn(val, key, collection)
+    }
+
+    return collection
+  }
+}
+
+module.exports = forEach

package/dist/for-each.d.cts

@@ -0,0 +1,2 @@
+import { default as forEach } from '@common-fp/common-fp-types/for-each'
+export = forEach

package/dist/for-each.d.ts

@@ -0,0 +1 @@
+export { default } from '@common-fp/common-fp-types/for-each'

package/dist/for-each.mjs

@@ -0,0 +1,22 @@
+import assertArgTypeIsOneOf from '@common-fp/shared-internals/assert-arg-type-is-one-of'
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+import * as ct from '@common-fp/shared-internals/common-types'
+import getIterator from '@common-fp/shared-internals/get-iterator'
+import getType from '@common-fp/shared-internals/get-type'
+
+const forEach = fn => {
+  assertArgIsType(fn, 'fn', 'function', 'forEach')
+
+  return collection => {
+    const collType = getType(collection)
+    assertArgTypeIsOneOf(collType, 'collection', ct.collection, 'forEach')
+    const entries = getIterator('entries', collection, collType)
+    for (const [key, val] of entries) {
+      fn(val, key, collection)
+    }
+
+    return collection
+  }
+}
+
+export default forEach

package/dist/get-at-path.cjs

@@ -0,0 +1,11 @@
+const assertArgIsArrayOfAcceptedTypes = require('@common-fp/shared-internals/assert-arg-is-array-of-accepted-types')
+const ct = require('@common-fp/shared-internals/common-types')
+const getAtPathInternal = require('./internal/get-at-path.cjs')
+
+const getAtPath = path => {
+  assertArgIsArrayOfAcceptedTypes(path, 'path', ct.propertyKey, 'getAtPath')
+
+  return anObject => getAtPathInternal(path, anObject)
+}
+
+module.exports = getAtPath

package/dist/get-at-path.d.cts

@@ -0,0 +1,2 @@
+import { default as getAtPath } from '@common-fp/common-fp-types/get-at-path'
+export = getAtPath

package/dist/get-at-path.d.ts

@@ -0,0 +1 @@
+export { default } from '@common-fp/common-fp-types/get-at-path'

package/dist/get-at-path.mjs

@@ -0,0 +1,11 @@
+import assertArgIsArrayOfAcceptedTypes from '@common-fp/shared-internals/assert-arg-is-array-of-accepted-types'
+import * as ct from '@common-fp/shared-internals/common-types'
+import getAtPathInternal from './internal/get-at-path.mjs'
+
+const getAtPath = path => {
+  assertArgIsArrayOfAcceptedTypes(path, 'path', ct.propertyKey, 'getAtPath')
+
+  return anObject => getAtPathInternal(path, anObject)
+}
+
+export default getAtPath

package/dist/get-average-value.cjs

@@ -0,0 +1,19 @@
+const assertArgHasValuesOfType = require('@common-fp/shared-internals/assert-arg-has-values-of-type')
+const assertArgTypeIsOneOf = require('@common-fp/shared-internals/assert-arg-type-is-one-of')
+const ct = require('@common-fp/shared-internals/common-types')
+const getIterator = require('@common-fp/shared-internals/get-iterator')
+const getType = require('@common-fp/shared-internals/get-type')
+
+const getAverage = nums => {
+  const numsType = getType(nums)
+  assertArgTypeIsOneOf(numsType, 'nums', ct.collection, 'getAverageValue')
+  assertArgHasValuesOfType(nums, 'nums', 'number', 'getAverageValue')
+
+  const numArr = [...getIterator('values', nums, numsType)]
+  if (!numArr.length) return undefined
+
+  const total = numArr.reduce((runningTotal, num) => runningTotal + num, 0)
+  return total / numArr.length
+}
+
+module.exports = getAverage

package/dist/get-average-value.d.cts

@@ -0,0 +1,2 @@
+import { default as getAverageValue } from '@common-fp/common-fp-types/get-average-value'
+export = getAverageValue

package/dist/get-average-value.d.ts

@@ -0,0 +1 @@
+export { default } from '@common-fp/common-fp-types/get-average-value'

package/dist/get-average-value.mjs

@@ -0,0 +1,19 @@
+import assertArgHasValuesOfType from '@common-fp/shared-internals/assert-arg-has-values-of-type'
+import assertArgTypeIsOneOf from '@common-fp/shared-internals/assert-arg-type-is-one-of'
+import * as ct from '@common-fp/shared-internals/common-types'
+import getIterator from '@common-fp/shared-internals/get-iterator'
+import getType from '@common-fp/shared-internals/get-type'
+
+const getAverage = nums => {
+  const numsType = getType(nums)
+  assertArgTypeIsOneOf(numsType, 'nums', ct.collection, 'getAverageValue')
+  assertArgHasValuesOfType(nums, 'nums', 'number', 'getAverageValue')
+
+  const numArr = [...getIterator('values', nums, numsType)]
+  if (!numArr.length) return undefined
+
+  const total = numArr.reduce((runningTotal, num) => runningTotal + num, 0)
+  return total / numArr.length
+}
+
+export default getAverage

package/dist/get-common-values.cjs

@@ -0,0 +1,31 @@
+/**
+ * returns values which appear in all sets
+ * e.g. getCommonValues([[1, 2, 3], [2, 3, 4]]) returns [2, 3]
+ */
+
+const assertArgIsArrayOfAcceptedTypes = require('@common-fp/shared-internals/assert-arg-is-array-of-accepted-types')
+const ct = require('@common-fp/shared-internals/common-types')
+const ensureSet = require('@common-fp/shared-internals/ensure-set')
+
+const getCommonValues = anArray => {
+  assertArgIsArrayOfAcceptedTypes(
+    anArray,
+    'anArray',
+    ct.valueCollection,
+    'getCommonValues'
+  )
+
+  const arrOfSets = anArray.map(ensureSet)
+  const result = new Set(arrOfSets.shift())
+  let nextSet = arrOfSets.shift()
+  while (nextSet && result.size) {
+    for (const el of result) {
+      if (!nextSet.has(el)) result.delete(el)
+    }
+    nextSet = arrOfSets.shift()
+  }
+
+  return [...result]
+}
+
+module.exports = getCommonValues

package/dist/get-common-values.d.cts

@@ -0,0 +1,2 @@
+import { default as getCommonValues } from '@common-fp/common-fp-types/get-common-values'
+export = getCommonValues

package/dist/get-common-values.d.ts

@@ -0,0 +1 @@
+export { default } from '@common-fp/common-fp-types/get-common-values'

package/dist/get-common-values.mjs

@@ -0,0 +1,31 @@
+/**
+ * returns values which appear in all sets
+ * e.g. getCommonValues([[1, 2, 3], [2, 3, 4]]) returns [2, 3]
+ */
+
+import assertArgIsArrayOfAcceptedTypes from '@common-fp/shared-internals/assert-arg-is-array-of-accepted-types'
+import * as ct from '@common-fp/shared-internals/common-types'
+import ensureSet from '@common-fp/shared-internals/ensure-set'
+
+const getCommonValues = anArray => {
+  assertArgIsArrayOfAcceptedTypes(
+    anArray,
+    'anArray',
+    ct.valueCollection,
+    'getCommonValues'
+  )
+
+  const arrOfSets = anArray.map(ensureSet)
+  const result = new Set(arrOfSets.shift())
+  let nextSet = arrOfSets.shift()
+  while (nextSet && result.size) {
+    for (const el of result) {
+      if (!nextSet.has(el)) result.delete(el)
+    }
+    nextSet = arrOfSets.shift()
+  }
+
+  return [...result]
+}
+
+export default getCommonValues

package/dist/get-exclusive-values.cjs

@@ -0,0 +1,41 @@
+/**
+ * returns values which appear exclusively in one set
+ * e.g. getExclusiveValues([[1, 2], [2, 3], [3, 4]]) returns [1, 4]
+ */
+
+const assertArgIsArrayOfAcceptedTypes = require('@common-fp/shared-internals/assert-arg-is-array-of-accepted-types')
+const ct = require('@common-fp/shared-internals/common-types')
+const ensureSet = require('@common-fp/shared-internals/ensure-set')
+
+const getExclusiveValues = anArray => {
+  assertArgIsArrayOfAcceptedTypes(
+    anArray,
+    'anArray',
+    ct.valueCollection,
+    'getExclusiveValues'
+  )
+
+  if (!anArray.length) return []
+
+  const result = new Set()
+  const arrOfSets = anArray.map(ensureSet)
+  for (const set1 of arrOfSets) {
+    for (const el of set1) {
+      let elIsDifferent = true
+
+      for (const set2 of arrOfSets) {
+        if (set1 === set2) continue
+        if (set2.has(el)) {
+          elIsDifferent = false
+          break
+        }
+      }
+
+      if (elIsDifferent) result.add(el)
+    }
+  }
+
+  return [...result]
+}
+
+module.exports = getExclusiveValues

package/dist/get-exclusive-values.d.cts

@@ -0,0 +1,2 @@
+import { default as getExclusiveValues } from '@common-fp/common-fp-types/get-exclusive-values'
+export = getExclusiveValues

package/dist/get-exclusive-values.d.ts

@@ -0,0 +1 @@
+export { default } from '@common-fp/common-fp-types/get-exclusive-values'

package/dist/get-exclusive-values.mjs

@@ -0,0 +1,41 @@
+/**
+ * returns values which appear exclusively in one set
+ * e.g. getExclusiveValues([[1, 2], [2, 3], [3, 4]]) returns [1, 4]
+ */
+
+import assertArgIsArrayOfAcceptedTypes from '@common-fp/shared-internals/assert-arg-is-array-of-accepted-types'
+import * as ct from '@common-fp/shared-internals/common-types'
+import ensureSet from '@common-fp/shared-internals/ensure-set'
+
+const getExclusiveValues = anArray => {
+  assertArgIsArrayOfAcceptedTypes(
+    anArray,
+    'anArray',
+    ct.valueCollection,
+    'getExclusiveValues'
+  )
+
+  if (!anArray.length) return []
+
+  const result = new Set()
+  const arrOfSets = anArray.map(ensureSet)
+  for (const set1 of arrOfSets) {
+    for (const el of set1) {
+      let elIsDifferent = true
+
+      for (const set2 of arrOfSets) {
+        if (set1 === set2) continue
+        if (set2.has(el)) {
+          elIsDifferent = false
+          break
+        }
+      }
+
+      if (elIsDifferent) result.add(el)
+    }
+  }
+
+  return [...result]
+}
+
+export default getExclusiveValues

package/dist/get-keys.cjs

@@ -0,0 +1,23 @@
+const getFn = require('@common-fp/shared-internals/get-fn')
+
+const getKeys = collection => {
+  const fn = getFn(typeToFn, collection, 'collection', 'getKeys')
+
+  return fn(collection)
+}
+
+const typeToFn = {
+  array: getKeys_iterator,
+  map: getKeys_iterator,
+  object: getKeys_object,
+}
+
+function getKeys_iterator(coll) {
+  return Array.from(coll.keys())
+}
+
+function getKeys_object(obj) {
+  return Object.keys(obj)
+}
+
+module.exports = getKeys

package/dist/get-keys.d.cts

@@ -0,0 +1,2 @@
+import { default as getKeys } from '@common-fp/common-fp-types/get-keys'
+export = getKeys

package/dist/get-keys.d.ts

@@ -0,0 +1 @@
+export { default } from '@common-fp/common-fp-types/get-keys'

package/dist/get-keys.mjs

@@ -0,0 +1,23 @@
+import getFn from '@common-fp/shared-internals/get-fn'
+
+const getKeys = collection => {
+  const fn = getFn(typeToFn, collection, 'collection', 'getKeys')
+
+  return fn(collection)
+}
+
+const typeToFn = {
+  array: getKeys_iterator,
+  map: getKeys_iterator,
+  object: getKeys_object,
+}
+
+function getKeys_iterator(coll) {
+  return Array.from(coll.keys())
+}
+
+function getKeys_object(obj) {
+  return Object.keys(obj)
+}
+
+export default getKeys

package/dist/get-max-value.cjs

@@ -0,0 +1,16 @@
+const assertArgHasValuesOfType = require('@common-fp/shared-internals/assert-arg-has-values-of-type')
+const assertArgTypeIsOneOf = require('@common-fp/shared-internals/assert-arg-type-is-one-of')
+const ct = require('@common-fp/shared-internals/common-types')
+const getIterator = require('@common-fp/shared-internals/get-iterator')
+const getType = require('@common-fp/shared-internals/get-type')
+
+const getMaxValue = collection => {
+  const collType = getType(collection)
+  assertArgTypeIsOneOf(collType, 'collection', ct.collection, 'getMaxValue')
+  assertArgHasValuesOfType(collection, 'collection', 'number', 'getMaxValue')
+
+  const values = Array.from(getIterator('values', collection, collType))
+  return values.length ? Math.max(...values) : undefined
+}
+
+module.exports = getMaxValue

package/dist/get-max-value.d.cts

@@ -0,0 +1,2 @@
+import { default as getMaxValue } from '@common-fp/common-fp-types/get-max-value'
+export = getMaxValue

package/dist/get-max-value.d.ts

@@ -0,0 +1 @@
+export { default } from '@common-fp/common-fp-types/get-max-value'

package/dist/get-max-value.mjs

@@ -0,0 +1,16 @@
+import assertArgHasValuesOfType from '@common-fp/shared-internals/assert-arg-has-values-of-type'
+import assertArgTypeIsOneOf from '@common-fp/shared-internals/assert-arg-type-is-one-of'
+import * as ct from '@common-fp/shared-internals/common-types'
+import getIterator from '@common-fp/shared-internals/get-iterator'
+import getType from '@common-fp/shared-internals/get-type'
+
+const getMaxValue = collection => {
+  const collType = getType(collection)
+  assertArgTypeIsOneOf(collType, 'collection', ct.collection, 'getMaxValue')
+  assertArgHasValuesOfType(collection, 'collection', 'number', 'getMaxValue')
+
+  const values = Array.from(getIterator('values', collection, collType))
+  return values.length ? Math.max(...values) : undefined
+}
+
+export default getMaxValue

package/dist/get-min-value.cjs

@@ -0,0 +1,16 @@
+const assertArgHasValuesOfType = require('@common-fp/shared-internals/assert-arg-has-values-of-type')
+const assertArgTypeIsOneOf = require('@common-fp/shared-internals/assert-arg-type-is-one-of')
+const ct = require('@common-fp/shared-internals/common-types')
+const getIterator = require('@common-fp/shared-internals/get-iterator')
+const getType = require('@common-fp/shared-internals/get-type')
+
+const getMinValue = collection => {
+  const collType = getType(collection)
+  assertArgTypeIsOneOf(collType, 'collection', ct.collection, 'getMinValue')
+  assertArgHasValuesOfType(collection, 'collection', 'number', 'getMinValue')
+
+  const values = Array.from(getIterator('values', collection, collType))
+  return values.length ? Math.min(...values) : undefined
+}
+
+module.exports = getMinValue

package/dist/get-min-value.d.cts

@@ -0,0 +1,2 @@
+import { default as getMinValue } from '@common-fp/common-fp-types/get-min-value'
+export = getMinValue