common-fp 0.1.0

package/dist/negate.cjs

@@ -0,0 +1,9 @@
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+
+const negate = fn => {
+  assertArgIsType(fn, 'fn', 'function', 'negate')
+
+  return (...args) => !fn(...args)
+}
+
+module.exports = negate

package/dist/negate.d.cts

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

package/dist/negate.d.ts

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

package/dist/negate.mjs

@@ -0,0 +1,9 @@
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+
+const negate = fn => {
+  assertArgIsType(fn, 'fn', 'function', 'negate')
+
+  return (...args) => !fn(...args)
+}
+
+export default negate

package/dist/number-is-between.cjs

@@ -0,0 +1,33 @@
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+const validateIsBetweenInput = require('@common-fp/shared-internals/validate-is-between-input')
+
+const numberIsBetween = (num1, num2, opts = {}) => {
+  let { exclusiveMin, exclusiveMax } = opts
+
+  validateIsBetweenInput(
+    num1,
+    'num1',
+    num2,
+    'num2',
+    'number',
+    'numberIsBetween',
+    {
+      exclusiveMin,
+      exclusiveMax,
+    }
+  )
+
+  const [min, max] = num1 <= num2 ? [num1, num2] : [num2, num1]
+  if (exclusiveMin === undefined) exclusiveMin = false
+  if (exclusiveMax === undefined) exclusiveMax = false
+
+  return aNumber => {
+    assertArgIsType(aNumber, 'aNumber', 'number', 'numberIsBetween')
+    const minCheck = exclusiveMin ? aNumber > min : aNumber >= min
+    if (!minCheck) return false
+
+    return exclusiveMax ? aNumber < max : aNumber <= max
+  }
+}
+
+module.exports = numberIsBetween

package/dist/number-is-between.d.cts

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

package/dist/number-is-between.d.ts

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

package/dist/number-is-between.mjs

@@ -0,0 +1,33 @@
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+import validateIsBetweenInput from '@common-fp/shared-internals/validate-is-between-input'
+
+const numberIsBetween = (num1, num2, opts = {}) => {
+  let { exclusiveMin, exclusiveMax } = opts
+
+  validateIsBetweenInput(
+    num1,
+    'num1',
+    num2,
+    'num2',
+    'number',
+    'numberIsBetween',
+    {
+      exclusiveMin,
+      exclusiveMax,
+    }
+  )
+
+  const [min, max] = num1 <= num2 ? [num1, num2] : [num2, num1]
+  if (exclusiveMin === undefined) exclusiveMin = false
+  if (exclusiveMax === undefined) exclusiveMax = false
+
+  return aNumber => {
+    assertArgIsType(aNumber, 'aNumber', 'number', 'numberIsBetween')
+    const minCheck = exclusiveMin ? aNumber > min : aNumber >= min
+    if (!minCheck) return false
+
+    return exclusiveMax ? aNumber < max : aNumber <= max
+  }
+}
+
+export default numberIsBetween

package/dist/omit.cjs

@@ -0,0 +1,52 @@
+const assertArgIsOneOfType = require('@common-fp/shared-internals/assert-arg-is-one-of-type')
+const ct = require('@common-fp/shared-internals/common-types')
+const ensureSet = require('@common-fp/shared-internals/ensure-set')
+const getFn = require('@common-fp/shared-internals/get-fn')
+const validateArrayKeys = require('@common-fp/shared-internals/validate-array-keys')
+const validateObjectKeys = require('@common-fp/shared-internals/validate-object-keys')
+
+const omit = keys => {
+  assertArgIsOneOfType(keys, 'keys', ct.valueCollection, 'omit')
+  const setOfKeys = ensureSet(keys)
+
+  return collection => {
+    const fn = getFn(typeToFn, collection, 'collection', 'omit')
+    return fn(collection, setOfKeys)
+  }
+}
+
+const typeToFn = {
+  array: omit_array,
+  map: omit_map,
+  object: omit_object,
+}
+
+function omit_array(arr, keys) {
+  validateArrayKeys(keys, 'omit')
+
+  return arr.filter((_el, i) => !keys.has(i))
+}
+
+function omit_map(aMap, keys) {
+  const result = new Map()
+
+  for (const [k, val] of aMap) {
+    if (!keys.has(k)) result.set(k, val)
+  }
+
+  return result
+}
+
+function omit_object(obj, keys) {
+  validateObjectKeys(keys, 'omit')
+
+  const result = {}
+
+  for (const k of Object.keys(obj)) {
+    if (!keys.has(k)) result[k] = obj[k]
+  }
+
+  return result
+}
+
+module.exports = omit

package/dist/omit.d.cts

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

package/dist/omit.d.ts

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

package/dist/omit.mjs

@@ -0,0 +1,52 @@
+import assertArgIsOneOfType from '@common-fp/shared-internals/assert-arg-is-one-of-type'
+import * as ct from '@common-fp/shared-internals/common-types'
+import ensureSet from '@common-fp/shared-internals/ensure-set'
+import getFn from '@common-fp/shared-internals/get-fn'
+import validateArrayKeys from '@common-fp/shared-internals/validate-array-keys'
+import validateObjectKeys from '@common-fp/shared-internals/validate-object-keys'
+
+const omit = keys => {
+  assertArgIsOneOfType(keys, 'keys', ct.valueCollection, 'omit')
+  const setOfKeys = ensureSet(keys)
+
+  return collection => {
+    const fn = getFn(typeToFn, collection, 'collection', 'omit')
+    return fn(collection, setOfKeys)
+  }
+}
+
+const typeToFn = {
+  array: omit_array,
+  map: omit_map,
+  object: omit_object,
+}
+
+function omit_array(arr, keys) {
+  validateArrayKeys(keys, 'omit')
+
+  return arr.filter((_el, i) => !keys.has(i))
+}
+
+function omit_map(aMap, keys) {
+  const result = new Map()
+
+  for (const [k, val] of aMap) {
+    if (!keys.has(k)) result.set(k, val)
+  }
+
+  return result
+}
+
+function omit_object(obj, keys) {
+  validateObjectKeys(keys, 'omit')
+
+  const result = {}
+
+  for (const k of Object.keys(obj)) {
+    if (!keys.has(k)) result[k] = obj[k]
+  }
+
+  return result
+}
+
+export default omit

package/dist/order.cjs

@@ -0,0 +1,13 @@
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+
+const order = compareFn => {
+  assertArgIsType(compareFn, 'compareFn', 'function', 'order')
+
+  return anArray => {
+    assertArgIsType(anArray, 'anArray', 'array', 'order')
+
+    return [...anArray].sort(compareFn)
+  }
+}
+
+module.exports = order

package/dist/order.d.cts

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

package/dist/order.d.ts

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

package/dist/order.mjs

@@ -0,0 +1,13 @@
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+
+const order = compareFn => {
+  assertArgIsType(compareFn, 'compareFn', 'function', 'order')
+
+  return anArray => {
+    assertArgIsType(anArray, 'anArray', 'array', 'order')
+
+    return [...anArray].sort(compareFn)
+  }
+}
+
+export default order

package/dist/p-all.cjs

@@ -0,0 +1,23 @@
+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 pAll = predicate => {
+  assertArgIsType(predicate, 'predicate', 'function', 'pAll')
+
+  return async collection => {
+    const collType = getType(collection)
+    assertArgTypeIsOneOf(collType, 'collection', ct.collection, 'pAll')
+    const entries = getIterator('entries', collection, collType)
+
+    for (const [key, val] of entries) {
+      if (!(await predicate(val, key, collection))) return false
+    }
+
+    return true
+  }
+}
+
+module.exports = pAll

package/dist/p-all.d.cts

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

package/dist/p-all.d.ts

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

package/dist/p-all.mjs

@@ -0,0 +1,23 @@
+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 pAll = predicate => {
+  assertArgIsType(predicate, 'predicate', 'function', 'pAll')
+
+  return async collection => {
+    const collType = getType(collection)
+    assertArgTypeIsOneOf(collType, 'collection', ct.collection, 'pAll')
+    const entries = getIterator('entries', collection, collType)
+
+    for (const [key, val] of entries) {
+      if (!(await predicate(val, key, collection))) return false
+    }
+
+    return true
+  }
+}
+
+export default pAll

package/dist/p-any.cjs

@@ -0,0 +1,23 @@
+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 pAny = predicate => {
+  assertArgIsType(predicate, 'predicate', 'function', 'pAny')
+
+  return async collection => {
+    const collType = getType(collection)
+    assertArgTypeIsOneOf(collType, 'collection', ct.collection, 'pAny')
+    const entries = getIterator('entries', collection, collType)
+
+    for (const [key, val] of entries) {
+      if (await predicate(val, key, collection)) return true
+    }
+
+    return false
+  }
+}
+
+module.exports = pAny

package/dist/p-any.d.cts

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

package/dist/p-any.d.ts

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

package/dist/p-any.mjs

@@ -0,0 +1,23 @@
+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 pAny = predicate => {
+  assertArgIsType(predicate, 'predicate', 'function', 'pAny')
+
+  return async collection => {
+    const collType = getType(collection)
+    assertArgTypeIsOneOf(collType, 'collection', ct.collection, 'pAny')
+    const entries = getIterator('entries', collection, collType)
+
+    for (const [key, val] of entries) {
+      if (await predicate(val, key, collection)) return true
+    }
+
+    return false
+  }
+}
+
+export default pAny

package/dist/p-compose.cjs

@@ -0,0 +1,18 @@
+const assertArgIsArrayOfType = require('@common-fp/shared-internals/assert-arg-is-array-of-type')
+
+const compose = fnArray => {
+  assertArgIsArrayOfType(fnArray, 'fnArray', 'function', 'compose')
+
+  return async (...args) => {
+    if (!fnArray.length) return args[0]
+
+    const [firstFn, ...restFns] = fnArray
+    let result = await firstFn(...args)
+    for (const fn of restFns) {
+      result = await fn(result)
+    }
+    return result
+  }
+}
+
+module.exports = compose

package/dist/p-compose.d.cts

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

package/dist/p-compose.d.ts

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

package/dist/p-compose.mjs

@@ -0,0 +1,18 @@
+import assertArgIsArrayOfType from '@common-fp/shared-internals/assert-arg-is-array-of-type'
+
+const compose = fnArray => {
+  assertArgIsArrayOfType(fnArray, 'fnArray', 'function', 'compose')
+
+  return async (...args) => {
+    if (!fnArray.length) return args[0]
+
+    const [firstFn, ...restFns] = fnArray
+    let result = await firstFn(...args)
+    for (const fn of restFns) {
+      result = await fn(result)
+    }
+    return result
+  }
+}
+
+export default compose

package/dist/p-discard-when.cjs

@@ -0,0 +1,64 @@
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+const getFn = require('@common-fp/shared-internals/get-fn')
+
+const pDiscardWhen = predicate => {
+  assertArgIsType(predicate, 'predicate', 'function', 'pDiscardWhen')
+
+  return async collection => {
+    const fn = getFn(typeToFn, collection, 'collection', 'pDiscardWhen')
+    return fn(collection, predicate)
+  }
+}
+
+const typeToFn = {
+  array: pDiscardWhen_array,
+  map: pDiscardWhen_map,
+  object: pDiscardWhen_object,
+  set: pDiscardWhen_set,
+}
+
+async function pDiscardWhen_array(arr, predicate) {
+  const shouldKeepArr = await Promise.all(
+    arr.map(async (el, i) => !(await predicate(el, i, arr)))
+  )
+
+  return arr.filter((_el, i) => shouldKeepArr[i])
+}
+
+async function pDiscardWhen_map(aMap, predicate) {
+  const result = new Map()
+  await Promise.all(
+    [...aMap].map(async ([key, val]) => {
+      const shouldKeep = !(await predicate(val, key, aMap))
+      if (shouldKeep) result.set(key, val)
+    })
+  )
+
+  return result
+}
+
+async function pDiscardWhen_object(obj, predicate) {
+  const result = {}
+  await Promise.all(
+    [...Object.entries(obj)].map(async ([key, val]) => {
+      const shouldKeep = !(await predicate(val, key, obj))
+      if (shouldKeep) result[key] = val
+    })
+  )
+
+  return result
+}
+
+async function pDiscardWhen_set(aSet, predicate) {
+  const result = new Set()
+  await Promise.all(
+    [...aSet].map(async val => {
+      const shouldKeep = !(await predicate(val, val, aSet))
+      if (shouldKeep) result.add(val)
+    })
+  )
+
+  return result
+}
+
+module.exports = pDiscardWhen

package/dist/p-discard-when.d.cts

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

package/dist/p-discard-when.d.ts

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

package/dist/p-discard-when.mjs

@@ -0,0 +1,64 @@
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+import getFn from '@common-fp/shared-internals/get-fn'
+
+const pDiscardWhen = predicate => {
+  assertArgIsType(predicate, 'predicate', 'function', 'pDiscardWhen')
+
+  return async collection => {
+    const fn = getFn(typeToFn, collection, 'collection', 'pDiscardWhen')
+    return fn(collection, predicate)
+  }
+}
+
+const typeToFn = {
+  array: pDiscardWhen_array,
+  map: pDiscardWhen_map,
+  object: pDiscardWhen_object,
+  set: pDiscardWhen_set,
+}
+
+async function pDiscardWhen_array(arr, predicate) {
+  const shouldKeepArr = await Promise.all(
+    arr.map(async (el, i) => !(await predicate(el, i, arr)))
+  )
+
+  return arr.filter((_el, i) => shouldKeepArr[i])
+}
+
+async function pDiscardWhen_map(aMap, predicate) {
+  const result = new Map()
+  await Promise.all(
+    [...aMap].map(async ([key, val]) => {
+      const shouldKeep = !(await predicate(val, key, aMap))
+      if (shouldKeep) result.set(key, val)
+    })
+  )
+
+  return result
+}
+
+async function pDiscardWhen_object(obj, predicate) {
+  const result = {}
+  await Promise.all(
+    [...Object.entries(obj)].map(async ([key, val]) => {
+      const shouldKeep = !(await predicate(val, key, obj))
+      if (shouldKeep) result[key] = val
+    })
+  )
+
+  return result
+}
+
+async function pDiscardWhen_set(aSet, predicate) {
+  const result = new Set()
+  await Promise.all(
+    [...aSet].map(async val => {
+      const shouldKeep = !(await predicate(val, val, aSet))
+      if (shouldKeep) result.add(val)
+    })
+  )
+
+  return result
+}
+
+export default pDiscardWhen

package/dist/p-find.cjs

@@ -0,0 +1,21 @@
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-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 pFind = predicate => {
+  assertArgIsType(predicate, 'predicate', 'function', 'pFind')
+
+  return async collection => {
+    const collType = getType(collection)
+    assertArgTypeIsOneOf(collType, 'collection', ct.collection, 'pFind')
+    const entries = getIterator('entries', collection, collType)
+
+    for (const [key, val] of entries) {
+      if (await predicate(val, key, collection)) return val
+    }
+  }
+}
+
+module.exports = pFind

package/dist/p-find.d.cts

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

package/dist/p-find.d.ts

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

package/dist/p-find.mjs

@@ -0,0 +1,21 @@
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-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 pFind = predicate => {
+  assertArgIsType(predicate, 'predicate', 'function', 'pFind')
+
+  return async collection => {
+    const collType = getType(collection)
+    assertArgTypeIsOneOf(collType, 'collection', ct.collection, 'pFind')
+    const entries = getIterator('entries', collection, collType)
+
+    for (const [key, val] of entries) {
+      if (await predicate(val, key, collection)) return val
+    }
+  }
+}
+
+export default pFind

package/dist/p-for-each.cjs

@@ -0,0 +1,21 @@
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-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 pForEach = fn => {
+  assertArgIsType(fn, 'fn', 'function', 'pForEach')
+
+  return async collection => {
+    const collType = getType(collection)
+    assertArgTypeIsOneOf(collType, 'collection', ct.collection, 'pForEach')
+
+    const entries = [...getIterator('entries', collection, collType)]
+    await Promise.all(entries.map(([key, val]) => fn(val, key, collection)))
+
+    return collection
+  }
+}
+
+module.exports = pForEach

package/dist/p-for-each.d.cts

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

package/dist/p-for-each.d.ts

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

package/dist/p-for-each.mjs

@@ -0,0 +1,21 @@
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-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 pForEach = fn => {
+  assertArgIsType(fn, 'fn', 'function', 'pForEach')
+
+  return async collection => {
+    const collType = getType(collection)
+    assertArgTypeIsOneOf(collType, 'collection', ct.collection, 'pForEach')
+
+    const entries = [...getIterator('entries', collection, collType)]
+    await Promise.all(entries.map(([key, val]) => fn(val, key, collection)))
+
+    return collection
+  }
+}
+
+export default pForEach