common-fp 0.1.0

package/dist/round-to-nearest.mjs

@@ -0,0 +1,51 @@
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+import truncateToNChars from '@common-fp/shared-internals/truncate-to-n-chars'
+
+const roundToNearest = precision => {
+  validatePrecision(precision)
+  const numPrecision =
+    precision.includes('.') ?
+      precision.length - 2 // 2 accounts for the leading "0."
+    : -precision.length + 1
+
+  return aNumber => {
+    assertArgIsType(aNumber, 'aNumber', 'number', 'roundToNearest')
+
+    /**
+     * implementation based off lodash.  Essentially we're
+     *   1. shifting the exponent based off the precision passed
+     *   2. rounding the shifted result
+     *   3. shifting it back and returning the value
+     *
+     * per lodash this gets around pesky floating point issues
+     */
+    const [base, exp] = aNumber.toExponential().split('e')
+    const shiftedNum = Math.round(base + 'e' + (Number(exp) + numPrecision))
+
+    const [shiftedBase, shiftedExp] = shiftedNum.toExponential().split('e')
+    return Number(shiftedBase + 'e' + (Number(shiftedExp) - numPrecision))
+  }
+}
+
+function validatePrecision(precision) {
+  assertArgIsType(precision, 'precision', 'string', 'roundToNearest')
+  if (precision.includes('.')) {
+    if (!/^0\.0{0,9}1$/.test(precision)) {
+      const truncatedPrecision = truncateToNChars(15, precision)
+      throw new Error(
+        'With a decimal, roundToNearest requires a precision passing the regex /^0\\.0{0,9}1$/' +
+          `\n  precision: ${truncatedPrecision}`
+      )
+    }
+  } else {
+    if (!/^10{0,9}$/.test(precision)) {
+      const truncatedPrecision = truncateToNChars(15, precision)
+      throw new Error(
+        'Without a decimal, roundToNearest requires a precision passing the regex /^10{0,9}$/' +
+          `\n  precision: ${truncatedPrecision}`
+      )
+    }
+  }
+}
+
+export default roundToNearest

package/dist/set.cjs

@@ -0,0 +1,51 @@
+const ct = require('@common-fp/shared-internals/common-types')
+const getFn = require('@common-fp/shared-internals/get-fn')
+const getType = require('@common-fp/shared-internals/get-type')
+
+const set = (key, val) => {
+  const keyType = getType(key)
+
+  return collection => {
+    const typeFn = getFn(typeToFn, collection, 'collection', 'set')
+    return typeFn(collection, key, val, keyType)
+  }
+}
+
+const typeToFn = {
+  array: set_array,
+  map: set_map,
+  object: set_object,
+}
+
+function set_array(arr, key, val, keyType) {
+  if (!ct.objectKey.has(keyType)) {
+    throw new Error(
+      "when calling set with an array, 'key' must be a number or string" +
+        `\n  key type: ${keyType}`
+    )
+  }
+
+  const result = [...arr]
+
+  result[key] = val
+
+  return result
+}
+
+function set_map(aMap, key, val) {
+  const result = new Map(aMap)
+  return result.set(key, val)
+}
+
+function set_object(obj, key, val, keyType) {
+  if (!ct.objectKey.has(keyType)) {
+    throw new Error(
+      "when calling set with an object, 'key' must be a number or string" +
+        `\n  key type: ${keyType}`
+    )
+  }
+
+  return { ...obj, [key]: val }
+}
+
+module.exports = set

package/dist/set.d.cts

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

package/dist/set.d.ts

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

package/dist/set.mjs

@@ -0,0 +1,51 @@
+import * as ct from '@common-fp/shared-internals/common-types'
+import getFn from '@common-fp/shared-internals/get-fn'
+import getType from '@common-fp/shared-internals/get-type'
+
+const set = (key, val) => {
+  const keyType = getType(key)
+
+  return collection => {
+    const typeFn = getFn(typeToFn, collection, 'collection', 'set')
+    return typeFn(collection, key, val, keyType)
+  }
+}
+
+const typeToFn = {
+  array: set_array,
+  map: set_map,
+  object: set_object,
+}
+
+function set_array(arr, key, val, keyType) {
+  if (!ct.objectKey.has(keyType)) {
+    throw new Error(
+      "when calling set with an array, 'key' must be a number or string" +
+        `\n  key type: ${keyType}`
+    )
+  }
+
+  const result = [...arr]
+
+  result[key] = val
+
+  return result
+}
+
+function set_map(aMap, key, val) {
+  const result = new Map(aMap)
+  return result.set(key, val)
+}
+
+function set_object(obj, key, val, keyType) {
+  if (!ct.objectKey.has(keyType)) {
+    throw new Error(
+      "when calling set with an object, 'key' must be a number or string" +
+        `\n  key type: ${keyType}`
+    )
+  }
+
+  return { ...obj, [key]: val }
+}
+
+export default set

package/dist/shuffle.cjs

@@ -0,0 +1,21 @@
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+const getRandomInt = require('@common-fp/shared-internals/get-random-int')
+
+const shuffle = anArray => {
+  assertArgIsType(anArray, 'anArray', 'array', 'shuffle')
+
+  const result = [...anArray]
+  const len = result.length
+  for (let i = 0; i < len - 1; i += 1) {
+    const randomI = getRandomInt(i, len - 1)
+    if (randomI === i) continue
+
+    const tmp = result[i]
+    result[i] = result[randomI]
+    result[randomI] = tmp
+  }
+
+  return result
+}
+
+module.exports = shuffle

package/dist/shuffle.d.cts

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

package/dist/shuffle.d.ts

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

package/dist/shuffle.mjs

@@ -0,0 +1,21 @@
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+import getRandomInt from '@common-fp/shared-internals/get-random-int'
+
+const shuffle = anArray => {
+  assertArgIsType(anArray, 'anArray', 'array', 'shuffle')
+
+  const result = [...anArray]
+  const len = result.length
+  for (let i = 0; i < len - 1; i += 1) {
+    const randomI = getRandomInt(i, len - 1)
+    if (randomI === i) continue
+
+    const tmp = result[i]
+    result[i] = result[randomI]
+    result[randomI] = tmp
+  }
+
+  return result
+}
+
+export default shuffle

package/dist/split-every.cjs

@@ -0,0 +1,31 @@
+const assertArgIsInt = require('@common-fp/shared-internals/assert-arg-is-int')
+const assertArgTypeIsOneOf = require('@common-fp/shared-internals/assert-arg-type-is-one-of')
+const ct = require('@common-fp/shared-internals/common-types')
+const getType = require('@common-fp/shared-internals/get-type')
+
+const splitEvery = groupSize => {
+  assertArgIsInt(groupSize, 'groupSize', 'splitEvery', { positive: true })
+
+  return sequence => {
+    const seqType = getType(sequence)
+    assertArgTypeIsOneOf(seqType, 'sequence', ct.sequence, 'splitEvery')
+
+    if (!sequence.length) {
+      const emptySeq = seqType === 'string' ? '' : []
+      return [emptySeq]
+    }
+
+    const numArrays = Math.ceil(sequence.length / groupSize)
+    const res = new Array(numArrays)
+
+    for (let i = 0; i < numArrays - 1; i += 1) {
+      res[i] = sequence.slice(i * groupSize, (i + 1) * groupSize)
+    }
+
+    res[numArrays - 1] = sequence.slice((numArrays - 1) * groupSize)
+
+    return res
+  }
+}
+
+module.exports = splitEvery

package/dist/split-every.d.cts

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

package/dist/split-every.d.ts

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

package/dist/split-every.mjs

@@ -0,0 +1,31 @@
+import assertArgIsInt from '@common-fp/shared-internals/assert-arg-is-int'
+import assertArgTypeIsOneOf from '@common-fp/shared-internals/assert-arg-type-is-one-of'
+import * as ct from '@common-fp/shared-internals/common-types'
+import getType from '@common-fp/shared-internals/get-type'
+
+const splitEvery = groupSize => {
+  assertArgIsInt(groupSize, 'groupSize', 'splitEvery', { positive: true })
+
+  return sequence => {
+    const seqType = getType(sequence)
+    assertArgTypeIsOneOf(seqType, 'sequence', ct.sequence, 'splitEvery')
+
+    if (!sequence.length) {
+      const emptySeq = seqType === 'string' ? '' : []
+      return [emptySeq]
+    }
+
+    const numArrays = Math.ceil(sequence.length / groupSize)
+    const res = new Array(numArrays)
+
+    for (let i = 0; i < numArrays - 1; i += 1) {
+      res[i] = sequence.slice(i * groupSize, (i + 1) * groupSize)
+    }
+
+    res[numArrays - 1] = sequence.slice((numArrays - 1) * groupSize)
+
+    return res
+  }
+}
+
+export default splitEvery

package/dist/split.cjs

@@ -0,0 +1,14 @@
+const assertArgIsOneOfType = require('@common-fp/shared-internals/assert-arg-is-one-of-type')
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+
+const split = separator => {
+  assertArgIsOneOfType(separator, 'separator', ['regexp', 'string'], 'split')
+
+  return aString => {
+    assertArgIsType(aString, 'aString', 'string', 'split')
+
+    return aString.split(separator)
+  }
+}
+
+module.exports = split

package/dist/split.d.cts

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

package/dist/split.d.ts

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

package/dist/split.mjs

@@ -0,0 +1,14 @@
+import assertArgIsOneOfType from '@common-fp/shared-internals/assert-arg-is-one-of-type'
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+
+const split = separator => {
+  assertArgIsOneOfType(separator, 'separator', ['regexp', 'string'], 'split')
+
+  return aString => {
+    assertArgIsType(aString, 'aString', 'string', 'split')
+
+    return aString.split(separator)
+  }
+}
+
+export default split

package/dist/starts-with.cjs

@@ -0,0 +1,13 @@
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+
+const startsWith = prefix => {
+  assertArgIsType(prefix, 'prefix', 'string', 'startsWith')
+
+  return aString => {
+    assertArgIsType(aString, 'aString', 'string', 'startsWith')
+
+    return aString.startsWith(prefix)
+  }
+}
+
+module.exports = startsWith

package/dist/starts-with.d.cts

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

package/dist/starts-with.d.ts

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

package/dist/starts-with.mjs

@@ -0,0 +1,13 @@
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+
+const startsWith = prefix => {
+  assertArgIsType(prefix, 'prefix', 'string', 'startsWith')
+
+  return aString => {
+    assertArgIsType(aString, 'aString', 'string', 'startsWith')
+
+    return aString.startsWith(prefix)
+  }
+}
+
+export default startsWith

package/dist/strict-equals.cjs

@@ -0,0 +1,3 @@
+const strictEquals = item1 => item2 => item1 === item2
+
+module.exports = strictEquals

package/dist/strict-equals.d.cts

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

package/dist/strict-equals.d.ts

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

package/dist/strict-equals.mjs

@@ -0,0 +1,3 @@
+const strictEquals = item1 => item2 => item1 === item2
+
+export default strictEquals

package/dist/subtract.cjs

@@ -0,0 +1,13 @@
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+
+const subtract = right => {
+  assertArgIsType(right, 'right', 'number', 'subtract')
+
+  return left => {
+    assertArgIsType(left, 'left', 'number', 'subtract')
+
+    return left - right
+  }
+}
+
+module.exports = subtract

package/dist/subtract.d.cts

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

package/dist/subtract.d.ts

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

package/dist/subtract.mjs

@@ -0,0 +1,13 @@
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+
+const subtract = right => {
+  assertArgIsType(right, 'right', 'number', 'subtract')
+
+  return left => {
+    assertArgIsType(left, 'left', 'number', 'subtract')
+
+    return left - right
+  }
+}
+
+export default subtract

package/dist/sum-values.cjs

@@ -0,0 +1,20 @@
+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 sumValues = collection => {
+  const collType = getType(collection)
+  assertArgTypeIsOneOf(collType, 'collection', ct.collection, 'sumValues')
+  assertArgHasValuesOfType(collection, 'collection', 'number', 'sumValues')
+
+  const values = getIterator('values', collection, collType)
+  let sum = 0
+  for (const num of values) {
+    sum += num
+  }
+  return sum
+}
+
+module.exports = sumValues

package/dist/sum-values.d.cts

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

package/dist/sum-values.d.ts

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

package/dist/sum-values.mjs

@@ -0,0 +1,20 @@
+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 sumValues = collection => {
+  const collType = getType(collection)
+  assertArgTypeIsOneOf(collType, 'collection', ct.collection, 'sumValues')
+  assertArgHasValuesOfType(collection, 'collection', 'number', 'sumValues')
+
+  const values = getIterator('values', collection, collType)
+  let sum = 0
+  for (const num of values) {
+    sum += num
+  }
+  return sum
+}
+
+export default sumValues

package/dist/swap-first-two-args.cjs

@@ -0,0 +1,15 @@
+const swapFirstTwoArgs =
+  fn =>
+  (...args) => {
+    if (!args.length) return fn()
+
+    // don't change the number of arguments passed to the function, just
+    // pass undefined
+    if (args.length === 1) return fn(undefined)
+
+    return args.length === 2 ?
+        fn(args[1], args[0])
+      : fn(args[1], args[0], ...args.slice(2))
+  }
+
+module.exports = swapFirstTwoArgs

package/dist/swap-first-two-args.d.cts

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

package/dist/swap-first-two-args.d.ts

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

package/dist/swap-first-two-args.mjs

@@ -0,0 +1,15 @@
+const swapFirstTwoArgs =
+  fn =>
+  (...args) => {
+    if (!args.length) return fn()
+
+    // don't change the number of arguments passed to the function, just
+    // pass undefined
+    if (args.length === 1) return fn(undefined)
+
+    return args.length === 2 ?
+        fn(args[1], args[0])
+      : fn(args[1], args[0], ...args.slice(2))
+  }
+
+export default swapFirstTwoArgs

package/dist/transpose.cjs

@@ -0,0 +1,46 @@
+const assertArgIsArrayOfType = require('@common-fp/shared-internals/assert-arg-is-array-of-type')
+
+/**
+ * commonly known as _.zip
+ * https://lodash.com/docs/4.17.15#zip
+ *
+ * wiki article
+ * https://en.wikipedia.org/wiki/Transpose
+ */
+const transpose = anArray => {
+  assertArgIsArrayOfType(anArray, 'anArray', 'array', 'transpose')
+  if (!anArray.length) return []
+
+  validateArraysHaveSameLength(anArray)
+
+  const numCols = anArray[0].length
+  const numRows = anArray.length
+  const result = new Array(numCols)
+
+  for (let col = 0; col < numCols; col += 1) {
+    const group = new Array(numRows)
+
+    for (let row = 0; row < numRows; row += 1) {
+      group[row] = anArray[row][col]
+    }
+
+    result[col] = group
+  }
+
+  return result
+}
+
+function validateArraysHaveSameLength(anArray) {
+  const expectedLength = anArray[0].length
+
+  const allArraysHaveSameLength = anArray
+    .slice(1)
+    .every(arr => arr.length === expectedLength)
+  if (!allArraysHaveSameLength) {
+    const errMsg =
+      "transpose requires 'anArray' to contain arrays of equal length"
+    throw new Error(errMsg)
+  }
+}
+
+module.exports = transpose

package/dist/transpose.d.cts

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

package/dist/transpose.d.ts

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

package/dist/transpose.mjs

@@ -0,0 +1,46 @@
+import assertArgIsArrayOfType from '@common-fp/shared-internals/assert-arg-is-array-of-type'
+
+/**
+ * commonly known as _.zip
+ * https://lodash.com/docs/4.17.15#zip
+ *
+ * wiki article
+ * https://en.wikipedia.org/wiki/Transpose
+ */
+const transpose = anArray => {
+  assertArgIsArrayOfType(anArray, 'anArray', 'array', 'transpose')
+  if (!anArray.length) return []
+
+  validateArraysHaveSameLength(anArray)
+
+  const numCols = anArray[0].length
+  const numRows = anArray.length
+  const result = new Array(numCols)
+
+  for (let col = 0; col < numCols; col += 1) {
+    const group = new Array(numRows)
+
+    for (let row = 0; row < numRows; row += 1) {
+      group[row] = anArray[row][col]
+    }
+
+    result[col] = group
+  }
+
+  return result
+}
+
+function validateArraysHaveSameLength(anArray) {
+  const expectedLength = anArray[0].length
+
+  const allArraysHaveSameLength = anArray
+    .slice(1)
+    .every(arr => arr.length === expectedLength)
+  if (!allArraysHaveSameLength) {
+    const errMsg =
+      "transpose requires 'anArray' to contain arrays of equal length"
+    throw new Error(errMsg)
+  }
+}
+
+export default transpose

package/dist/truncate-to-n-chars.cjs

@@ -0,0 +1,17 @@
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+const assertArgIsInt = require('@common-fp/shared-internals/assert-arg-is-int')
+const truncateToNCharsInternal = require('@common-fp/shared-internals/truncate-to-n-chars')
+
+const truncateToNChars = n => {
+  assertArgIsInt(n, 'n', 'truncateToNChars', {
+    nonNegative: true,
+  })
+
+  return aString => {
+    assertArgIsType(aString, 'aString', 'string', 'truncateToNChars')
+
+    return truncateToNCharsInternal(n, aString)
+  }
+}
+
+module.exports = truncateToNChars

package/dist/truncate-to-n-chars.d.cts

@@ -0,0 +1,2 @@
+import { default as truncateToNChars } from '@common-fp/common-fp-types/truncate-to-n-chars'
+export = truncateToNChars

package/dist/truncate-to-n-chars.d.ts

@@ -0,0 +1 @@
+export { default } from '@common-fp/common-fp-types/truncate-to-n-chars'

package/dist/truncate-to-n-chars.mjs

@@ -0,0 +1,17 @@
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+import assertArgIsInt from '@common-fp/shared-internals/assert-arg-is-int'
+import truncateToNCharsInternal from '@common-fp/shared-internals/truncate-to-n-chars'
+
+const truncateToNChars = n => {
+  assertArgIsInt(n, 'n', 'truncateToNChars', {
+    nonNegative: true,
+  })
+
+  return aString => {
+    assertArgIsType(aString, 'aString', 'string', 'truncateToNChars')
+
+    return truncateToNCharsInternal(n, aString)
+  }
+}
+
+export default truncateToNChars