common-fp 0.1.0

package/dist/is-falsey.d.cts

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

package/dist/is-falsey.d.ts

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

package/dist/is-falsey.mjs

@@ -0,0 +1,3 @@
+const isFalsey = value => !value
+
+export default isFalsey

package/dist/is-laden.cjs

@@ -0,0 +1,28 @@
+const getFn = require('@common-fp/shared-internals/get-fn')
+
+const isLaden = collection => {
+  const fn = getFn(typeToFn, collection, 'collection', 'isLaden')
+  return fn(collection)
+}
+
+const typeToFn = {
+  array: isLaden_hasLength,
+  map: isLaden_hasSize,
+  object: isLaden_object,
+  set: isLaden_hasSize,
+  string: isLaden_hasLength,
+}
+
+function isLaden_hasSize(coll) {
+  return coll.size !== 0
+}
+
+function isLaden_hasLength(coll) {
+  return coll.length !== 0
+}
+
+function isLaden_object(coll) {
+  return Object.keys(coll).length !== 0
+}
+
+module.exports = isLaden

package/dist/is-laden.d.cts

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

package/dist/is-laden.d.ts

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

package/dist/is-laden.mjs

@@ -0,0 +1,28 @@
+import getFn from '@common-fp/shared-internals/get-fn'
+
+const isLaden = collection => {
+  const fn = getFn(typeToFn, collection, 'collection', 'isLaden')
+  return fn(collection)
+}
+
+const typeToFn = {
+  array: isLaden_hasLength,
+  map: isLaden_hasSize,
+  object: isLaden_object,
+  set: isLaden_hasSize,
+  string: isLaden_hasLength,
+}
+
+function isLaden_hasSize(coll) {
+  return coll.size !== 0
+}
+
+function isLaden_hasLength(coll) {
+  return coll.length !== 0
+}
+
+function isLaden_object(coll) {
+  return Object.keys(coll).length !== 0
+}
+
+export default isLaden

package/dist/is-truthy.cjs

@@ -0,0 +1,3 @@
+const isTruthy = value => Boolean(value)
+
+module.exports = isTruthy

package/dist/is-truthy.d.cts

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

package/dist/is-truthy.d.ts

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

package/dist/is-truthy.mjs

@@ -0,0 +1,3 @@
+const isTruthy = value => Boolean(value)
+
+export default isTruthy

package/dist/join-values.cjs

@@ -0,0 +1,18 @@
+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 joinValues = separator => {
+  assertArgIsType(separator, 'separator', 'string', 'joinValues')
+
+  return collection => {
+    const collType = getType(collection)
+    assertArgTypeIsOneOf(collType, 'collection', ct.collection, 'joinValues')
+    const values = getIterator('values', collection, collType)
+    return Array.from(values).join(separator)
+  }
+}
+
+module.exports = joinValues

package/dist/join-values.d.cts

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

package/dist/join-values.d.ts

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

package/dist/join-values.mjs

@@ -0,0 +1,18 @@
+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 joinValues = separator => {
+  assertArgIsType(separator, 'separator', 'string', 'joinValues')
+
+  return collection => {
+    const collType = getType(collection)
+    assertArgTypeIsOneOf(collType, 'collection', ct.collection, 'joinValues')
+    const values = getIterator('values', collection, collType)
+    return Array.from(values).join(separator)
+  }
+}
+
+export default joinValues

package/dist/keep-first-while.cjs

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

package/dist/keep-first-while.d.cts

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

package/dist/keep-first-while.d.ts

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

package/dist/keep-first-while.mjs

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

package/dist/keep-first.cjs

@@ -0,0 +1,14 @@
+const assertArgIsInt = require('@common-fp/shared-internals/assert-arg-is-int')
+const assertArgIsOneOfType = require('@common-fp/shared-internals/assert-arg-is-one-of-type')
+const ct = require('@common-fp/shared-internals/common-types')
+
+const keepFirst = num => {
+  assertArgIsInt(num, 'num', 'keepFirst', { nonNegative: true })
+
+  return sequence => {
+    assertArgIsOneOfType(sequence, 'sequence', ct.sequence, 'keepFirst')
+    return sequence.slice(0, num)
+  }
+}
+
+module.exports = keepFirst

package/dist/keep-first.d.cts

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

package/dist/keep-first.d.ts

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

package/dist/keep-first.mjs

@@ -0,0 +1,14 @@
+import assertArgIsInt from '@common-fp/shared-internals/assert-arg-is-int'
+import assertArgIsOneOfType from '@common-fp/shared-internals/assert-arg-is-one-of-type'
+import * as ct from '@common-fp/shared-internals/common-types'
+
+const keepFirst = num => {
+  assertArgIsInt(num, 'num', 'keepFirst', { nonNegative: true })
+
+  return sequence => {
+    assertArgIsOneOfType(sequence, 'sequence', ct.sequence, 'keepFirst')
+    return sequence.slice(0, num)
+  }
+}
+
+export default keepFirst

package/dist/keep-last-while.cjs

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

package/dist/keep-last-while.d.cts

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

package/dist/keep-last-while.d.ts

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

package/dist/keep-last-while.mjs

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

package/dist/keep-last.cjs

@@ -0,0 +1,14 @@
+const assertArgIsInt = require('@common-fp/shared-internals/assert-arg-is-int')
+const assertArgIsOneOfType = require('@common-fp/shared-internals/assert-arg-is-one-of-type')
+const ct = require('@common-fp/shared-internals/common-types')
+
+const keepLast = numToKeep => {
+  assertArgIsInt(numToKeep, 'numToKeep', 'keepLast', { nonNegative: true })
+
+  return sequence => {
+    assertArgIsOneOfType(sequence, 'sequence', ct.sequence, 'keepLast')
+    return sequence.slice(Math.max(0, sequence.length - numToKeep))
+  }
+}
+
+module.exports = keepLast

package/dist/keep-last.d.cts

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

package/dist/keep-last.d.ts

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

package/dist/keep-last.mjs

@@ -0,0 +1,14 @@
+import assertArgIsInt from '@common-fp/shared-internals/assert-arg-is-int'
+import assertArgIsOneOfType from '@common-fp/shared-internals/assert-arg-is-one-of-type'
+import * as ct from '@common-fp/shared-internals/common-types'
+
+const keepLast = numToKeep => {
+  assertArgIsInt(numToKeep, 'numToKeep', 'keepLast', { nonNegative: true })
+
+  return sequence => {
+    assertArgIsOneOfType(sequence, 'sequence', ct.sequence, 'keepLast')
+    return sequence.slice(Math.max(0, sequence.length - numToKeep))
+  }
+}
+
+export default keepLast

package/dist/keep-range.cjs

@@ -0,0 +1,14 @@
+const assertArgIsOneOfType = require('@common-fp/shared-internals/assert-arg-is-one-of-type')
+const ct = require('@common-fp/shared-internals/common-types')
+const validateRange = require('@common-fp/shared-internals/validate-range')
+
+const keepRange = ({ startIdx, endIdx } = {}) => {
+  validateRange(startIdx, endIdx, 'keepRange')
+
+  return sequence => {
+    assertArgIsOneOfType(sequence, 'sequence', ct.sequence, 'keepRange')
+    return sequence.slice(startIdx, endIdx + 1)
+  }
+}
+
+module.exports = keepRange

package/dist/keep-range.d.cts

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

package/dist/keep-range.d.ts

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

package/dist/keep-range.mjs

@@ -0,0 +1,14 @@
+import assertArgIsOneOfType from '@common-fp/shared-internals/assert-arg-is-one-of-type'
+import * as ct from '@common-fp/shared-internals/common-types'
+import validateRange from '@common-fp/shared-internals/validate-range'
+
+const keepRange = ({ startIdx, endIdx } = {}) => {
+  validateRange(startIdx, endIdx, 'keepRange')
+
+  return sequence => {
+    assertArgIsOneOfType(sequence, 'sequence', ct.sequence, 'keepRange')
+    return sequence.slice(startIdx, endIdx + 1)
+  }
+}
+
+export default keepRange

package/dist/keep-when.cjs

@@ -0,0 +1,54 @@
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+const getFn = require('@common-fp/shared-internals/get-fn')
+
+const keepWhen = predicate => {
+  assertArgIsType(predicate, 'predicate', 'function', 'keepWhen')
+
+  return collection => {
+    const fn = getFn(typeToFn, collection, 'collection', 'keepWhen')
+    return fn(collection, predicate)
+  }
+}
+
+const typeToFn = {
+  array: keepWhen_array,
+  map: keepWhen_map,
+  object: keepWhen_object,
+  set: keepWhen_set,
+}
+
+function keepWhen_array(coll, predicate) {
+  return coll.filter(predicate)
+}
+
+function keepWhen_map(aMap, predicate) {
+  const result = new Map()
+
+  for (const [key, val] of aMap.entries()) {
+    if (predicate(val, key, aMap)) result.set(key, val)
+  }
+
+  return result
+}
+
+function keepWhen_object(obj, predicate) {
+  const result = {}
+
+  for (const [key, val] of Object.entries(obj)) {
+    if (predicate(val, key, obj)) result[key] = val
+  }
+
+  return result
+}
+
+function keepWhen_set(aSet, predicate) {
+  const result = new Set()
+
+  for (const val of aSet) {
+    if (predicate(val, val, aSet)) result.add(val)
+  }
+
+  return result
+}
+
+module.exports = keepWhen

package/dist/keep-when.d.cts

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

package/dist/keep-when.d.ts

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

package/dist/keep-when.mjs

@@ -0,0 +1,54 @@
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+import getFn from '@common-fp/shared-internals/get-fn'
+
+const keepWhen = predicate => {
+  assertArgIsType(predicate, 'predicate', 'function', 'keepWhen')
+
+  return collection => {
+    const fn = getFn(typeToFn, collection, 'collection', 'keepWhen')
+    return fn(collection, predicate)
+  }
+}
+
+const typeToFn = {
+  array: keepWhen_array,
+  map: keepWhen_map,
+  object: keepWhen_object,
+  set: keepWhen_set,
+}
+
+function keepWhen_array(coll, predicate) {
+  return coll.filter(predicate)
+}
+
+function keepWhen_map(aMap, predicate) {
+  const result = new Map()
+
+  for (const [key, val] of aMap.entries()) {
+    if (predicate(val, key, aMap)) result.set(key, val)
+  }
+
+  return result
+}
+
+function keepWhen_object(obj, predicate) {
+  const result = {}
+
+  for (const [key, val] of Object.entries(obj)) {
+    if (predicate(val, key, obj)) result[key] = val
+  }
+
+  return result
+}
+
+function keepWhen_set(aSet, predicate) {
+  const result = new Set()
+
+  for (const val of aSet) {
+    if (predicate(val, val, aSet)) result.add(val)
+  }
+
+  return result
+}
+
+export default keepWhen

package/dist/keep.cjs

@@ -0,0 +1,63 @@
+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 keep = values => {
+  assertArgIsOneOfType(values, 'values', ct.valueCollection, 'keep')
+  const setOfValues = ensureSet(values)
+
+  return collection => {
+    const fn = getFn(typeToFn, collection, 'collection', 'keep')
+    return fn(collection, setOfValues)
+  }
+}
+
+const typeToFn = {
+  array: keep_array,
+  map: keep_map,
+  object: keep_object,
+  set: keep_set,
+}
+
+function keep_array(arr, values) {
+  const result = []
+
+  for (const el of arr) {
+    if (values.has(el)) result.push(el)
+  }
+
+  return result
+}
+
+function keep_map(aMap, values) {
+  const result = new Map()
+
+  for (const [key, val] of aMap) {
+    if (values.has(val)) result.set(key, val)
+  }
+
+  return result
+}
+
+function keep_object(obj, values) {
+  const result = {}
+
+  for (const [key, val] of Object.entries(obj)) {
+    if (values.has(val)) result[key] = val
+  }
+
+  return result
+}
+
+function keep_set(aSet, values) {
+  const result = new Set()
+
+  for (const el of aSet) {
+    if (values.has(el)) result.add(el)
+  }
+
+  return result
+}
+
+module.exports = keep

package/dist/keep.d.cts

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

package/dist/keep.d.ts

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

package/dist/keep.mjs

@@ -0,0 +1,63 @@
+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'
+
+const keep = values => {
+  assertArgIsOneOfType(values, 'values', ct.valueCollection, 'keep')
+  const setOfValues = ensureSet(values)
+
+  return collection => {
+    const fn = getFn(typeToFn, collection, 'collection', 'keep')
+    return fn(collection, setOfValues)
+  }
+}
+
+const typeToFn = {
+  array: keep_array,
+  map: keep_map,
+  object: keep_object,
+  set: keep_set,
+}
+
+function keep_array(arr, values) {
+  const result = []
+
+  for (const el of arr) {
+    if (values.has(el)) result.push(el)
+  }
+
+  return result
+}
+
+function keep_map(aMap, values) {
+  const result = new Map()
+
+  for (const [key, val] of aMap) {
+    if (values.has(val)) result.set(key, val)
+  }
+
+  return result
+}
+
+function keep_object(obj, values) {
+  const result = {}
+
+  for (const [key, val] of Object.entries(obj)) {
+    if (values.has(val)) result[key] = val
+  }
+
+  return result
+}
+
+function keep_set(aSet, values) {
+  const result = new Set()
+
+  for (const el of aSet) {
+    if (values.has(el)) result.add(el)
+  }
+
+  return result
+}
+
+export default keep

package/dist/last.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 'tail'
+const last = sequence => {
+  assertArgIsOneOfType(sequence, 'sequence', ct.sequence, 'last')
+  return sequence[sequence.length - 1]
+}
+
+module.exports = last

package/dist/last.d.cts

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

package/dist/last.d.ts

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

package/dist/last.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 'tail'
+const last = sequence => {
+  assertArgIsOneOfType(sequence, 'sequence', ct.sequence, 'last')
+  return sequence[sequence.length - 1]
+}
+
+export default last

package/dist/less-than-or-equal-to.cjs

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

package/dist/less-than-or-equal-to.d.cts

@@ -0,0 +1,2 @@
+import { default as lessThanOrEqualTo } from '@common-fp/common-fp-types/less-than-or-equal-to'
+export = lessThanOrEqualTo

package/dist/less-than-or-equal-to.d.ts

@@ -0,0 +1 @@
+export { default } from '@common-fp/common-fp-types/less-than-or-equal-to'