common-fp 0.1.0

package/dist/m-prepend-all.cjs

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

package/dist/m-prepend-all.d.cts

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

package/dist/m-prepend-all.d.ts

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

package/dist/m-prepend-all.mjs

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

package/dist/m-prepend-one.cjs

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

package/dist/m-prepend-one.d.cts

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

package/dist/m-prepend-one.d.ts

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

package/dist/m-prepend-one.mjs

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

package/dist/m-reverse.cjs

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

package/dist/m-reverse.d.cts

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

package/dist/m-reverse.d.ts

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

package/dist/m-reverse.mjs

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

package/dist/m-set-at-path.cjs

@@ -0,0 +1,40 @@
+const assertArgIsArrayOfAcceptedTypes = require('@common-fp/shared-internals/assert-arg-is-array-of-accepted-types')
+const ct = require('@common-fp/shared-internals/common-types')
+
+const mSetAtPath = (path, value) => {
+  assertArgIsArrayOfAcceptedTypes(path, 'path', ct.propertyKey, 'mSetAtPath')
+  if (!path.length) {
+    throw new Error("mSetAtPath requries 'path' to be a non-empty array")
+  }
+
+  return anything => {
+    const initialPath = path.slice(0, -1)
+    let obj = anything
+
+    for (const key of initialPath) {
+      obj = obj?.[key]
+      if (obj === undefined) {
+        const err = new Error(
+          "mSetAtPath requires path to exist on 'anything'.  Arguments are assigned to this error to aid in debugging."
+        )
+        Object.assign(err, { arguments: { path, value, anything } })
+        throw err
+      }
+    }
+
+    const lastKey = path[path.length - 1]
+    try {
+      obj[lastKey] = value
+    } catch (innerError) {
+      const err = new Error(
+        'mSetAtPath requires the property at path to be assignable.  See error properties for more info.'
+      )
+      Object.assign(err, { innerError, arguments: { path, value, anything } })
+      throw err
+    }
+
+    return anything
+  }
+}
+
+module.exports = mSetAtPath

package/dist/m-set-at-path.d.cts

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

package/dist/m-set-at-path.d.ts

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

package/dist/m-set-at-path.mjs

@@ -0,0 +1,40 @@
+import assertArgIsArrayOfAcceptedTypes from '@common-fp/shared-internals/assert-arg-is-array-of-accepted-types'
+import * as ct from '@common-fp/shared-internals/common-types'
+
+const mSetAtPath = (path, value) => {
+  assertArgIsArrayOfAcceptedTypes(path, 'path', ct.propertyKey, 'mSetAtPath')
+  if (!path.length) {
+    throw new Error("mSetAtPath requries 'path' to be a non-empty array")
+  }
+
+  return anything => {
+    const initialPath = path.slice(0, -1)
+    let obj = anything
+
+    for (const key of initialPath) {
+      obj = obj?.[key]
+      if (obj === undefined) {
+        const err = new Error(
+          "mSetAtPath requires path to exist on 'anything'.  Arguments are assigned to this error to aid in debugging."
+        )
+        Object.assign(err, { arguments: { path, value, anything } })
+        throw err
+      }
+    }
+
+    const lastKey = path[path.length - 1]
+    try {
+      obj[lastKey] = value
+    } catch (innerError) {
+      const err = new Error(
+        'mSetAtPath requires the property at path to be assignable.  See error properties for more info.'
+      )
+      Object.assign(err, { innerError, arguments: { path, value, anything } })
+      throw err
+    }
+
+    return anything
+  }
+}
+
+export default mSetAtPath

package/dist/m-set.cjs

@@ -0,0 +1,21 @@
+const assertArgIsOneOfType = require('@common-fp/shared-internals/assert-arg-is-one-of-type')
+const ct = require('@common-fp/shared-internals/common-types')
+
+const mSet = (key, value) => {
+  assertArgIsOneOfType(key, 'key', ct.propertyKey, 'mSet')
+
+  return anything => {
+    try {
+      anything[key] = value
+    } catch (innerError) {
+      const err = new Error(
+        'mSet requires key to be assignable.  See error properties for more info.'
+      )
+      Object.assign(err, { innerError, arguments: { key, value, anything } })
+      throw err
+    }
+    return anything
+  }
+}
+
+module.exports = mSet

package/dist/m-set.d.cts

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

package/dist/m-set.d.ts

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

package/dist/m-set.mjs

@@ -0,0 +1,21 @@
+import assertArgIsOneOfType from '@common-fp/shared-internals/assert-arg-is-one-of-type'
+import * as ct from '@common-fp/shared-internals/common-types'
+
+const mSet = (key, value) => {
+  assertArgIsOneOfType(key, 'key', ct.propertyKey, 'mSet')
+
+  return anything => {
+    try {
+      anything[key] = value
+    } catch (innerError) {
+      const err = new Error(
+        'mSet requires key to be assignable.  See error properties for more info.'
+      )
+      Object.assign(err, { innerError, arguments: { key, value, anything } })
+      throw err
+    }
+    return anything
+  }
+}
+
+export default mSet

package/dist/m-shuffle.cjs

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

package/dist/m-shuffle.d.cts

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

package/dist/m-shuffle.d.ts

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

package/dist/m-shuffle.mjs

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

package/dist/m-update.cjs

@@ -0,0 +1,68 @@
+const aOrAn = require('@common-fp/shared-internals/a-or-an')
+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 mUpdate = mapperFns => {
+  const mapperType = getType(mapperFns)
+  assertArgTypeIsOneOf(mapperType, 'mapperFns', ct.entryCollection, 'mUpdate')
+  assertArgHasValuesOfType(mapperFns, 'mapperFns', 'function', 'mUpdate')
+
+  return collection => {
+    const collType = getType(collection)
+    assertArgTypeIsOneOf(collType, 'collection', ct.entryCollection, 'mUpdate')
+    validateCollectionType(collType, mapperType)
+    const fn = typeToFn[collType]
+    const mapperFnsIterator = getIterator('entries', mapperFns)
+    return fn(collection, mapperFnsIterator)
+  }
+}
+
+const typeToFn = {
+  array: mUpdate_array,
+  map: mUpdate_map,
+  object: mUpdate_object,
+}
+
+function mUpdate_array(arr, mapperFnsIterator) {
+  for (const [key, fn] of mapperFnsIterator) {
+    if (Object.hasOwn(arr, key)) arr[key] = fn(arr[key], key, arr)
+  }
+
+  return arr
+}
+
+function mUpdate_map(aMap, mapperFnsIterator) {
+  for (const [key, fn] of mapperFnsIterator) {
+    if (aMap.has(key)) aMap.set(key, fn(aMap.get(key), key, aMap))
+  }
+
+  return aMap
+}
+
+function mUpdate_object(obj, mapperFnsIterator) {
+  for (const [key, fn] of mapperFnsIterator) {
+    if (Object.hasOwn(obj, key)) obj[key] = fn(obj[key], key, obj)
+  }
+
+  return obj
+}
+
+/**
+ * If mapperFns is an array or map, then collection must match.  This convention
+ * will prevent odd combinations like declaring an array of mappers intended for
+ * objects which happen to have number keys.
+ *
+ * Objects, on the other hand, will be the most common way to declare mappers
+ * - and should apply to array and map collections.
+ */
+function validateCollectionType(collType, mapperType) {
+  if (['array', 'map'].includes(mapperType) && collType !== mapperType) {
+    const msg = `mUpdate requires argument 'collection' to be ${aOrAn(mapperType)} since you passed ${aOrAn(mapperType)} for 'mapperFns'`
+    throw new Error(msg)
+  }
+}
+
+module.exports = mUpdate

package/dist/m-update.d.cts

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

package/dist/m-update.d.ts

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

package/dist/m-update.mjs

@@ -0,0 +1,68 @@
+import aOrAn from '@common-fp/shared-internals/a-or-an'
+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 mUpdate = mapperFns => {
+  const mapperType = getType(mapperFns)
+  assertArgTypeIsOneOf(mapperType, 'mapperFns', ct.entryCollection, 'mUpdate')
+  assertArgHasValuesOfType(mapperFns, 'mapperFns', 'function', 'mUpdate')
+
+  return collection => {
+    const collType = getType(collection)
+    assertArgTypeIsOneOf(collType, 'collection', ct.entryCollection, 'mUpdate')
+    validateCollectionType(collType, mapperType)
+    const fn = typeToFn[collType]
+    const mapperFnsIterator = getIterator('entries', mapperFns)
+    return fn(collection, mapperFnsIterator)
+  }
+}
+
+const typeToFn = {
+  array: mUpdate_array,
+  map: mUpdate_map,
+  object: mUpdate_object,
+}
+
+function mUpdate_array(arr, mapperFnsIterator) {
+  for (const [key, fn] of mapperFnsIterator) {
+    if (Object.hasOwn(arr, key)) arr[key] = fn(arr[key], key, arr)
+  }
+
+  return arr
+}
+
+function mUpdate_map(aMap, mapperFnsIterator) {
+  for (const [key, fn] of mapperFnsIterator) {
+    if (aMap.has(key)) aMap.set(key, fn(aMap.get(key), key, aMap))
+  }
+
+  return aMap
+}
+
+function mUpdate_object(obj, mapperFnsIterator) {
+  for (const [key, fn] of mapperFnsIterator) {
+    if (Object.hasOwn(obj, key)) obj[key] = fn(obj[key], key, obj)
+  }
+
+  return obj
+}
+
+/**
+ * If mapperFns is an array or map, then collection must match.  This convention
+ * will prevent odd combinations like declaring an array of mappers intended for
+ * objects which happen to have number keys.
+ *
+ * Objects, on the other hand, will be the most common way to declare mappers
+ * - and should apply to array and map collections.
+ */
+function validateCollectionType(collType, mapperType) {
+  if (['array', 'map'].includes(mapperType) && collType !== mapperType) {
+    const msg = `mUpdate requires argument 'collection' to be ${aOrAn(mapperType)} since you passed ${aOrAn(mapperType)} for 'mapperFns'`
+    throw new Error(msg)
+  }
+}
+
+export default mUpdate

package/dist/map-keys.cjs

@@ -0,0 +1,36 @@
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+const getFn = require('@common-fp/shared-internals/get-fn')
+
+const mapKeys = mapperFn => {
+  assertArgIsType(mapperFn, 'mapperFn', 'function', 'mapKeys')
+
+  return collection => {
+    const fn = getFn(typeToFn, collection, 'collection', 'mapKeys')
+    return fn(collection, mapperFn)
+  }
+}
+
+const typeToFn = {
+  map: mapKeys_map,
+  object: mapKeys_object,
+}
+
+function mapKeys_map(aMap, mapperFn) {
+  const result = new Map()
+
+  for (const [key, val] of aMap) result.set(mapperFn(val, key, aMap), val)
+
+  return result
+}
+
+function mapKeys_object(obj, mapperFn) {
+  const result = {}
+
+  for (const [key, val] of Object.entries(obj)) {
+    result[mapperFn(val, key, obj)] = val
+  }
+
+  return result
+}
+
+module.exports = mapKeys

package/dist/map-keys.d.cts

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

package/dist/map-keys.d.ts

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

package/dist/map-keys.mjs

@@ -0,0 +1,36 @@
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+import getFn from '@common-fp/shared-internals/get-fn'
+
+const mapKeys = mapperFn => {
+  assertArgIsType(mapperFn, 'mapperFn', 'function', 'mapKeys')
+
+  return collection => {
+    const fn = getFn(typeToFn, collection, 'collection', 'mapKeys')
+    return fn(collection, mapperFn)
+  }
+}
+
+const typeToFn = {
+  map: mapKeys_map,
+  object: mapKeys_object,
+}
+
+function mapKeys_map(aMap, mapperFn) {
+  const result = new Map()
+
+  for (const [key, val] of aMap) result.set(mapperFn(val, key, aMap), val)
+
+  return result
+}
+
+function mapKeys_object(obj, mapperFn) {
+  const result = {}
+
+  for (const [key, val] of Object.entries(obj)) {
+    result[mapperFn(val, key, obj)] = val
+  }
+
+  return result
+}
+
+export default mapKeys

package/dist/map-values.cjs

@@ -0,0 +1,50 @@
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+const getFn = require('@common-fp/shared-internals/get-fn')
+
+const mapValues = mapperFn => {
+  assertArgIsType(mapperFn, 'mapperFn', 'function', 'mapValues')
+
+  return collection => {
+    const fn = getFn(typeToFn, collection, 'collection', 'mapValues')
+    return fn(collection, mapperFn)
+  }
+}
+
+const typeToFn = {
+  array: mapValues_array,
+  map: mapValues_map,
+  object: mapValues_object,
+  set: mapValues_set,
+}
+
+function mapValues_array(arr, mapperFn) {
+  return arr.map(mapperFn)
+}
+
+function mapValues_map(aMap, mapperFn) {
+  const result = new Map()
+
+  for (const [key, val] of aMap) result.set(key, mapperFn(val, key, aMap))
+
+  return result
+}
+
+function mapValues_object(obj, mapperFn) {
+  const result = {}
+
+  for (const [key, val] of Object.entries(obj)) {
+    result[key] = mapperFn(val, key, obj)
+  }
+
+  return result
+}
+
+function mapValues_set(aSet, mapperFn) {
+  const result = new Set()
+
+  for (const el of aSet) result.add(mapperFn(el, el, aSet))
+
+  return result
+}
+
+module.exports = mapValues

package/dist/map-values.d.cts

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

package/dist/map-values.d.ts

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

package/dist/map-values.mjs

@@ -0,0 +1,50 @@
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+import getFn from '@common-fp/shared-internals/get-fn'
+
+const mapValues = mapperFn => {
+  assertArgIsType(mapperFn, 'mapperFn', 'function', 'mapValues')
+
+  return collection => {
+    const fn = getFn(typeToFn, collection, 'collection', 'mapValues')
+    return fn(collection, mapperFn)
+  }
+}
+
+const typeToFn = {
+  array: mapValues_array,
+  map: mapValues_map,
+  object: mapValues_object,
+  set: mapValues_set,
+}
+
+function mapValues_array(arr, mapperFn) {
+  return arr.map(mapperFn)
+}
+
+function mapValues_map(aMap, mapperFn) {
+  const result = new Map()
+
+  for (const [key, val] of aMap) result.set(key, mapperFn(val, key, aMap))
+
+  return result
+}
+
+function mapValues_object(obj, mapperFn) {
+  const result = {}
+
+  for (const [key, val] of Object.entries(obj)) {
+    result[key] = mapperFn(val, key, obj)
+  }
+
+  return result
+}
+
+function mapValues_set(aSet, mapperFn) {
+  const result = new Set()
+
+  for (const el of aSet) result.add(mapperFn(el, el, aSet))
+
+  return result
+}
+
+export default mapValues

package/dist/multiply-by.cjs

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

package/dist/multiply-by.d.cts

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

package/dist/multiply-by.d.ts

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

package/dist/multiply-by.mjs

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