common-fp 0.1.0

package/dist/p-keep-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 pKeepWhen = predicate => {
+  assertArgIsType(predicate, 'predicate', 'function', 'pKeepWhen')
+
+  return async collection => {
+    const fn = getFn(typeToFn, collection, 'collection', 'pKeepWhen')
+    return fn(collection, predicate)
+  }
+}
+
+const typeToFn = {
+  array: pKeepWhen_array,
+  map: pKeepWhen_map,
+  object: pKeepWhen_object,
+  set: pKeepWhen_set,
+}
+
+async function pKeepWhen_array(arr, predicate) {
+  const shouldKeepArr = await Promise.all(
+    arr.map((el, i) => predicate(el, i, arr))
+  )
+
+  return arr.filter((_el, i) => shouldKeepArr[i])
+}
+
+async function pKeepWhen_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 pKeepWhen_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 pKeepWhen_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 = pKeepWhen

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

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

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

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

package/dist/p-keep-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 pKeepWhen = predicate => {
+  assertArgIsType(predicate, 'predicate', 'function', 'pKeepWhen')
+
+  return async collection => {
+    const fn = getFn(typeToFn, collection, 'collection', 'pKeepWhen')
+    return fn(collection, predicate)
+  }
+}
+
+const typeToFn = {
+  array: pKeepWhen_array,
+  map: pKeepWhen_map,
+  object: pKeepWhen_object,
+  set: pKeepWhen_set,
+}
+
+async function pKeepWhen_array(arr, predicate) {
+  const shouldKeepArr = await Promise.all(
+    arr.map((el, i) => predicate(el, i, arr))
+  )
+
+  return arr.filter((_el, i) => shouldKeepArr[i])
+}
+
+async function pKeepWhen_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 pKeepWhen_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 pKeepWhen_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 pKeepWhen

package/dist/p-map-values.cjs

@@ -0,0 +1,57 @@
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+const getFn = require('@common-fp/shared-internals/get-fn')
+
+const pMapValues = mapperFn => {
+  assertArgIsType(mapperFn, 'mapperFn', 'function', 'pMapValues')
+
+  return async collection => {
+    const fn = getFn(typeToFn, collection, 'collection', 'pMapValues')
+    return fn(collection, mapperFn)
+  }
+}
+
+const typeToFn = {
+  array: pMapValues_array,
+  map: pMapValues_map,
+  object: pMapValues_object,
+  set: pMapValues_set,
+}
+
+async function pMapValues_array(arr, mapperFn) {
+  return Promise.all(arr.map((el, i) => mapperFn(el, i, arr)))
+}
+
+async function pMapValues_map(aMap, mapperFn) {
+  const result = new Map()
+  await Promise.all(
+    [...aMap].map(async ([key, val]) => {
+      result.set(key, await mapperFn(val, key, aMap))
+    })
+  )
+
+  return result
+}
+
+async function pMapValues_object(obj, mapperFn) {
+  const result = {}
+  await Promise.all(
+    [...Object.entries(obj)].map(async ([key, val]) => {
+      result[key] = await mapperFn(val, key, obj)
+    })
+  )
+
+  return result
+}
+
+async function pMapValues_set(aSet, mapperFn) {
+  const result = new Set()
+  await Promise.all(
+    [...aSet.entries()].map(async ([key, val]) => {
+      result.add(await mapperFn(val, key, aSet))
+    })
+  )
+
+  return result
+}
+
+module.exports = pMapValues

package/dist/p-map-values.d.cts

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

package/dist/p-map-values.d.ts

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

package/dist/p-map-values.mjs

@@ -0,0 +1,57 @@
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+import getFn from '@common-fp/shared-internals/get-fn'
+
+const pMapValues = mapperFn => {
+  assertArgIsType(mapperFn, 'mapperFn', 'function', 'pMapValues')
+
+  return async collection => {
+    const fn = getFn(typeToFn, collection, 'collection', 'pMapValues')
+    return fn(collection, mapperFn)
+  }
+}
+
+const typeToFn = {
+  array: pMapValues_array,
+  map: pMapValues_map,
+  object: pMapValues_object,
+  set: pMapValues_set,
+}
+
+async function pMapValues_array(arr, mapperFn) {
+  return Promise.all(arr.map((el, i) => mapperFn(el, i, arr)))
+}
+
+async function pMapValues_map(aMap, mapperFn) {
+  const result = new Map()
+  await Promise.all(
+    [...aMap].map(async ([key, val]) => {
+      result.set(key, await mapperFn(val, key, aMap))
+    })
+  )
+
+  return result
+}
+
+async function pMapValues_object(obj, mapperFn) {
+  const result = {}
+  await Promise.all(
+    [...Object.entries(obj)].map(async ([key, val]) => {
+      result[key] = await mapperFn(val, key, obj)
+    })
+  )
+
+  return result
+}
+
+async function pMapValues_set(aSet, mapperFn) {
+  const result = new Set()
+  await Promise.all(
+    [...aSet.entries()].map(async ([key, val]) => {
+      result.add(await mapperFn(val, key, aSet))
+    })
+  )
+
+  return result
+}
+
+export default pMapValues

package/dist/p-pass-through.cjs

@@ -0,0 +1,12 @@
+const assertArgIsArrayOfType = require('@common-fp/shared-internals/assert-arg-is-array-of-type')
+
+const pPassThrough = async (value, fnArray) => {
+  assertArgIsArrayOfType(fnArray, 'fnArray', 'function', 'pPassThrough')
+
+  let result = value
+  for (const fn of fnArray) result = await fn(result)
+
+  return result
+}
+
+module.exports = pPassThrough

package/dist/p-pass-through.d.cts

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

package/dist/p-pass-through.d.ts

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

package/dist/p-pass-through.mjs

@@ -0,0 +1,12 @@
+import assertArgIsArrayOfType from '@common-fp/shared-internals/assert-arg-is-array-of-type'
+
+const pPassThrough = async (value, fnArray) => {
+  assertArgIsArrayOfType(fnArray, 'fnArray', 'function', 'pPassThrough')
+
+  let result = value
+  for (const fn of fnArray) result = await fn(result)
+
+  return result
+}
+
+export default pPassThrough

package/dist/p-resolve-values.cjs

@@ -0,0 +1,43 @@
+const getFn = require('@common-fp/shared-internals/get-fn')
+
+const pResolveValues = async collection => {
+  const typeFn = getFn(typeToFn, collection, 'collection', 'pResolveValues')
+  return typeFn(collection)
+}
+
+const typeToFn = {
+  array: pResolveValues_array,
+  map: pResolveValues_map,
+  object: pResolveValues_object,
+  set: pResolveValues_set,
+}
+
+function pResolveValues_array(arr) {
+  return Promise.all(arr)
+}
+
+async function pResolveValues_set(arr) {
+  return new Set(await Promise.all(arr))
+}
+
+async function pResolveValues_map(aMap) {
+  const keys = Array.from(aMap.keys())
+  const values = await Promise.all(aMap.values())
+  const result = new Map()
+
+  for (let i = 0; i < values.length; i += 1) result.set(keys[i], values[i])
+
+  return result
+}
+
+async function pResolveValues_object(obj) {
+  const keys = Object.keys(obj)
+  const values = await Promise.all(Object.values(obj))
+  const result = {}
+
+  for (let i = 0; i < values.length; i += 1) result[keys[i]] = values[i]
+
+  return result
+}
+
+module.exports = pResolveValues

package/dist/p-resolve-values.d.cts

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

package/dist/p-resolve-values.d.ts

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

package/dist/p-resolve-values.mjs

@@ -0,0 +1,43 @@
+import getFn from '@common-fp/shared-internals/get-fn'
+
+const pResolveValues = async collection => {
+  const typeFn = getFn(typeToFn, collection, 'collection', 'pResolveValues')
+  return typeFn(collection)
+}
+
+const typeToFn = {
+  array: pResolveValues_array,
+  map: pResolveValues_map,
+  object: pResolveValues_object,
+  set: pResolveValues_set,
+}
+
+function pResolveValues_array(arr) {
+  return Promise.all(arr)
+}
+
+async function pResolveValues_set(arr) {
+  return new Set(await Promise.all(arr))
+}
+
+async function pResolveValues_map(aMap) {
+  const keys = Array.from(aMap.keys())
+  const values = await Promise.all(aMap.values())
+  const result = new Map()
+
+  for (let i = 0; i < values.length; i += 1) result.set(keys[i], values[i])
+
+  return result
+}
+
+async function pResolveValues_object(obj) {
+  const keys = Object.keys(obj)
+  const values = await Promise.all(Object.values(obj))
+  const result = {}
+
+  for (let i = 0; i < values.length; i += 1) result[keys[i]] = values[i]
+
+  return result
+}
+
+export default pResolveValues

package/dist/p-wait-ms.cjs

@@ -0,0 +1,8 @@
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+
+const pWaitMs = ms => {
+  assertArgIsType(ms, 'ms', 'number', 'pWaitMs')
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+module.exports = pWaitMs

package/dist/p-wait-ms.d.cts

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

package/dist/p-wait-ms.d.ts

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

package/dist/p-wait-ms.mjs

@@ -0,0 +1,8 @@
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+
+const pWaitMs = ms => {
+  assertArgIsType(ms, 'ms', 'number', 'pWaitMs')
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+export default pWaitMs

package/dist/pass-through.cjs

@@ -0,0 +1,9 @@
+const assertArgIsArrayOfType = require('@common-fp/shared-internals/assert-arg-is-array-of-type')
+
+const passThrough = (value, fnArray) => {
+  assertArgIsArrayOfType(fnArray, 'fnArray', 'function', 'passThrough')
+
+  return fnArray.reduce((result, fn) => fn(result), value)
+}
+
+module.exports = passThrough

package/dist/pass-through.d.cts

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

package/dist/pass-through.d.ts

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

package/dist/pass-through.mjs

@@ -0,0 +1,9 @@
+import assertArgIsArrayOfType from '@common-fp/shared-internals/assert-arg-is-array-of-type'
+
+const passThrough = (value, fnArray) => {
+  assertArgIsArrayOfType(fnArray, 'fnArray', 'function', 'passThrough')
+
+  return fnArray.reduce((result, fn) => fn(result), value)
+}
+
+export default passThrough

package/dist/peek.cjs

@@ -0,0 +1,13 @@
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+
+// also known as 'tap'
+const peek = fn => {
+  assertArgIsType(fn, 'fn', 'function', 'peek')
+
+  return prevResult => {
+    fn(prevResult)
+    return prevResult
+  }
+}
+
+module.exports = peek

package/dist/peek.d.cts

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

package/dist/peek.d.ts

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

package/dist/peek.mjs

@@ -0,0 +1,13 @@
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+
+// also known as 'tap'
+const peek = fn => {
+  assertArgIsType(fn, 'fn', 'function', 'peek')
+
+  return prevResult => {
+    fn(prevResult)
+    return prevResult
+  }
+}
+
+export default peek

package/dist/pick.cjs

@@ -0,0 +1,50 @@
+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 pick = keys => {
+  assertArgIsOneOfType(keys, 'keys', ct.valueCollection, 'pick')
+  const setOfKeys = ensureSet(keys)
+
+  return collection => {
+    const fn = getFn(typeToFn, collection, 'collection', 'pick')
+    return fn(collection, setOfKeys)
+  }
+}
+
+const typeToFn = {
+  array: pick_array,
+  map: pick_map,
+  object: pick_object,
+}
+
+function pick_array(arr, keys) {
+  validateArrayKeys(keys, 'pick')
+  return arr.filter((_el, i) => keys.has(i))
+}
+
+function pick_map(aMap, keys) {
+  const result = new Map()
+
+  for (const k of keys) {
+    if (aMap.has(k)) result.set(k, aMap.get(k))
+  }
+
+  return result
+}
+
+function pick_object(obj, keys) {
+  validateObjectKeys(keys, 'pick')
+  const result = {}
+
+  for (const k of keys) {
+    if (Object.hasOwn(obj, k)) result[k] = obj[k]
+  }
+
+  return result
+}
+
+module.exports = pick

package/dist/pick.d.cts

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

package/dist/pick.d.ts

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

package/dist/pick.mjs

@@ -0,0 +1,50 @@
+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 pick = keys => {
+  assertArgIsOneOfType(keys, 'keys', ct.valueCollection, 'pick')
+  const setOfKeys = ensureSet(keys)
+
+  return collection => {
+    const fn = getFn(typeToFn, collection, 'collection', 'pick')
+    return fn(collection, setOfKeys)
+  }
+}
+
+const typeToFn = {
+  array: pick_array,
+  map: pick_map,
+  object: pick_object,
+}
+
+function pick_array(arr, keys) {
+  validateArrayKeys(keys, 'pick')
+  return arr.filter((_el, i) => keys.has(i))
+}
+
+function pick_map(aMap, keys) {
+  const result = new Map()
+
+  for (const k of keys) {
+    if (aMap.has(k)) result.set(k, aMap.get(k))
+  }
+
+  return result
+}
+
+function pick_object(obj, keys) {
+  validateObjectKeys(keys, 'pick')
+  const result = {}
+
+  for (const k of keys) {
+    if (Object.hasOwn(obj, k)) result[k] = obj[k]
+  }
+
+  return result
+}
+
+export default pick

package/dist/prepend-all.cjs

@@ -0,0 +1,13 @@
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+
+const prependAll = prepended => {
+  assertArgIsType(prepended, 'prepended', 'array', 'prependAll')
+
+  return base => {
+    assertArgIsType(base, 'base', 'array', 'prependAll')
+
+    return prepended.concat(base)
+  }
+}
+
+module.exports = prependAll

package/dist/prepend-all.d.cts

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

package/dist/prepend-all.d.ts

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

package/dist/prepend-all.mjs

@@ -0,0 +1,13 @@
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+
+const prependAll = prepended => {
+  assertArgIsType(prepended, 'prepended', 'array', 'prependAll')
+
+  return base => {
+    assertArgIsType(base, 'base', 'array', 'prependAll')
+
+    return prepended.concat(base)
+  }
+}
+
+export default prependAll

package/dist/prepend-one.cjs

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

package/dist/prepend-one.d.cts

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

package/dist/prepend-one.d.ts

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

package/dist/prepend-one.mjs

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

package/dist/prepend.cjs

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