common-fp 0.1.0

package/dist/contained-in.cjs

@@ -0,0 +1,26 @@
+const getFnByType = require('@common-fp/shared-internals/get-fn-by-type')
+const getType = require('@common-fp/shared-internals/get-type')
+const containsTypeToFn = require('./internal/contains-type-to-fn.cjs')
+
+const containedIn = collection => {
+  const collType = getType(collection)
+  const fn = getFnByType(
+    containsTypeToFn,
+    collType,
+    'collection',
+    'containedIn'
+  )
+
+  return value => {
+    const valueType = getType(value)
+    if (collType === 'string' && valueType !== 'string') {
+      throw new Error(
+        `When calling containedIn with a string collection, value must also be a string` +
+          `\n  value type: ${valueType}`
+      )
+    }
+    return fn(collection, value)
+  }
+}
+
+module.exports = containedIn

package/dist/contained-in.d.cts

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

package/dist/contained-in.d.ts

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

package/dist/contained-in.mjs

@@ -0,0 +1,26 @@
+import getFnByType from '@common-fp/shared-internals/get-fn-by-type'
+import getType from '@common-fp/shared-internals/get-type'
+import containsTypeToFn from './internal/contains-type-to-fn.mjs'
+
+const containedIn = collection => {
+  const collType = getType(collection)
+  const fn = getFnByType(
+    containsTypeToFn,
+    collType,
+    'collection',
+    'containedIn'
+  )
+
+  return value => {
+    const valueType = getType(value)
+    if (collType === 'string' && valueType !== 'string') {
+      throw new Error(
+        `When calling containedIn with a string collection, value must also be a string` +
+          `\n  value type: ${valueType}`
+      )
+    }
+    return fn(collection, value)
+  }
+}
+
+export default containedIn

package/dist/contains.cjs

@@ -0,0 +1,28 @@
+const getFnByType = require('@common-fp/shared-internals/get-fn-by-type')
+const getType = require('@common-fp/shared-internals/get-type')
+const containsTypeToFn = require('./internal/contains-type-to-fn.cjs')
+
+const contains = value => {
+  const valueType = getType(value)
+
+  return collection => {
+    const collectionType = getType(collection)
+    const fn = getFnByType(
+      containsTypeToFn,
+      collectionType,
+      'collection',
+      'contains'
+    )
+
+    if (collectionType === 'string' && valueType !== 'string') {
+      throw new Error(
+        'When calling contains with a collection of type string, value must also be a string' +
+          `\n  value type: ${valueType}`
+      )
+    }
+
+    return fn(collection, value)
+  }
+}
+
+module.exports = contains

package/dist/contains.d.cts

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

package/dist/contains.d.ts

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

package/dist/contains.mjs

@@ -0,0 +1,28 @@
+import getFnByType from '@common-fp/shared-internals/get-fn-by-type'
+import getType from '@common-fp/shared-internals/get-type'
+import containsTypeToFn from './internal/contains-type-to-fn.mjs'
+
+const contains = value => {
+  const valueType = getType(value)
+
+  return collection => {
+    const collectionType = getType(collection)
+    const fn = getFnByType(
+      containsTypeToFn,
+      collectionType,
+      'collection',
+      'contains'
+    )
+
+    if (collectionType === 'string' && valueType !== 'string') {
+      throw new Error(
+        'When calling contains with a collection of type string, value must also be a string' +
+          `\n  value type: ${valueType}`
+      )
+    }
+
+    return fn(collection, value)
+  }
+}
+
+export default contains

package/dist/date-is-between.cjs

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

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

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

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

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

package/dist/date-is-between.mjs

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

package/dist/default-falsey-val-to.cjs

@@ -0,0 +1,3 @@
+const defaultFalseyValTo = defaultVal => val => val || defaultVal
+
+module.exports = defaultFalseyValTo

package/dist/default-falsey-val-to.d.cts

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

package/dist/default-falsey-val-to.d.ts

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

package/dist/default-falsey-val-to.mjs

@@ -0,0 +1,3 @@
+const defaultFalseyValTo = defaultVal => val => val || defaultVal
+
+export default defaultFalseyValTo

package/dist/default-nullish-val-to.cjs

@@ -0,0 +1,3 @@
+const defaultNullishValTo = defaultVal => someVal => someVal ?? defaultVal
+
+module.exports = defaultNullishValTo

package/dist/default-nullish-val-to.d.cts

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

package/dist/default-nullish-val-to.d.ts

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

package/dist/default-nullish-val-to.mjs

@@ -0,0 +1,3 @@
+const defaultNullishValTo = defaultVal => someVal => someVal ?? defaultVal
+
+export default defaultNullishValTo

package/dist/discard-first-while.cjs

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

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

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

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

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

package/dist/discard-first-while.mjs

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

package/dist/discard-first.cjs

@@ -0,0 +1,16 @@
+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 discardFirst = num => {
+  assertArgIsInt(num, 'num', 'discardFirst', {
+    nonNegative: true,
+  })
+
+  return sequence => {
+    assertArgIsOneOfType(sequence, 'sequence', ct.sequence, 'discardFirst')
+    return sequence.slice(num)
+  }
+}
+
+module.exports = discardFirst

package/dist/discard-first.d.cts

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

package/dist/discard-first.d.ts

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

package/dist/discard-first.mjs

@@ -0,0 +1,16 @@
+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 discardFirst = num => {
+  assertArgIsInt(num, 'num', 'discardFirst', {
+    nonNegative: true,
+  })
+
+  return sequence => {
+    assertArgIsOneOfType(sequence, 'sequence', ct.sequence, 'discardFirst')
+    return sequence.slice(num)
+  }
+}
+
+export default discardFirst

package/dist/discard-last-while.cjs

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

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

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

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

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

package/dist/discard-last-while.mjs

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

package/dist/discard-last.cjs

@@ -0,0 +1,16 @@
+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 discardLast = num => {
+  assertArgIsInt(num, 'num', 'discardLast', {
+    nonNegative: true,
+  })
+
+  return sequence => {
+    assertArgIsOneOfType(sequence, 'sequence', ct.sequence, 'discardLast')
+    return sequence.slice(0, Math.max(0, sequence.length - num))
+  }
+}
+
+module.exports = discardLast

package/dist/discard-last.d.cts

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

package/dist/discard-last.d.ts

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

package/dist/discard-last.mjs

@@ -0,0 +1,16 @@
+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 discardLast = num => {
+  assertArgIsInt(num, 'num', 'discardLast', {
+    nonNegative: true,
+  })
+
+  return sequence => {
+    assertArgIsOneOfType(sequence, 'sequence', ct.sequence, 'discardLast')
+    return sequence.slice(0, Math.max(0, sequence.length - num))
+  }
+}
+
+export default discardLast

package/dist/discard-range.cjs

@@ -0,0 +1,31 @@
+const getFn = require('@common-fp/shared-internals/get-fn')
+const validateRange = require('@common-fp/shared-internals/validate-range')
+
+const discardRange = ({ startIdx, endIdx } = {}) => {
+  validateRange(startIdx, endIdx, 'discardRange')
+
+  return sequence => {
+    const fn = getFn(typeToFn, sequence, 'sequence', 'discardRange')
+    return fn(sequence, startIdx, endIdx)
+  }
+}
+
+const typeToFn = {
+  array: discardRange_array,
+  string: discardRange_string,
+}
+
+function discardRange_array(sequence, startIdx, endIdx) {
+  const result = [...sequence]
+  const numToDiscard = endIdx + 1 - startIdx
+  result.splice(startIdx, numToDiscard)
+  return result
+}
+
+function discardRange_string(sequence, startIdx, endIdx) {
+  const start = sequence.slice(0, startIdx)
+  const end = sequence.slice(endIdx + 1)
+  return start + end
+}
+
+module.exports = discardRange

package/dist/discard-range.d.cts

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

package/dist/discard-range.d.ts

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

package/dist/discard-range.mjs

@@ -0,0 +1,31 @@
+import getFn from '@common-fp/shared-internals/get-fn'
+import validateRange from '@common-fp/shared-internals/validate-range'
+
+const discardRange = ({ startIdx, endIdx } = {}) => {
+  validateRange(startIdx, endIdx, 'discardRange')
+
+  return sequence => {
+    const fn = getFn(typeToFn, sequence, 'sequence', 'discardRange')
+    return fn(sequence, startIdx, endIdx)
+  }
+}
+
+const typeToFn = {
+  array: discardRange_array,
+  string: discardRange_string,
+}
+
+function discardRange_array(sequence, startIdx, endIdx) {
+  const result = [...sequence]
+  const numToDiscard = endIdx + 1 - startIdx
+  result.splice(startIdx, numToDiscard)
+  return result
+}
+
+function discardRange_string(sequence, startIdx, endIdx) {
+  const start = sequence.slice(0, startIdx)
+  const end = sequence.slice(endIdx + 1)
+  return start + end
+}
+
+export default discardRange

package/dist/discard-when.cjs

@@ -0,0 +1,55 @@
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+const getFn = require('@common-fp/shared-internals/get-fn')
+const negate = require('@common-fp/shared-internals/negate')
+
+const discardWhen = predicate => {
+  assertArgIsType(predicate, 'predicate', 'function', 'discardWhen')
+
+  return collection => {
+    const fn = getFn(typeToFn, collection, 'collection', 'discardWhen')
+    return fn(collection, predicate)
+  }
+}
+
+const typeToFn = {
+  array: discardWhen_array,
+  map: discardWhen_map,
+  object: discardWhen_object,
+  set: discardWhen_set,
+}
+
+function discardWhen_array(arr, predicate) {
+  return arr.filter(negate(predicate))
+}
+
+function discardWhen_map(aMap, predicate) {
+  const result = new Map()
+
+  for (const [key, val] of aMap) {
+    if (!predicate(val, key, aMap)) result.set(key, val)
+  }
+
+  return result
+}
+
+function discardWhen_object(obj, predicate) {
+  const result = {}
+
+  for (const key of Object.keys(obj)) {
+    if (!predicate(obj[key], key, obj)) result[key] = obj[key]
+  }
+
+  return result
+}
+
+function discardWhen_set(aSet, predicate) {
+  const result = new Set()
+
+  for (const val of aSet) {
+    if (!predicate(val, val, aSet)) result.add(val)
+  }
+
+  return result
+}
+
+module.exports = discardWhen

package/dist/discard-when.d.cts

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

package/dist/discard-when.d.ts

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

package/dist/discard-when.mjs

@@ -0,0 +1,55 @@
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+import getFn from '@common-fp/shared-internals/get-fn'
+import negate from '@common-fp/shared-internals/negate'
+
+const discardWhen = predicate => {
+  assertArgIsType(predicate, 'predicate', 'function', 'discardWhen')
+
+  return collection => {
+    const fn = getFn(typeToFn, collection, 'collection', 'discardWhen')
+    return fn(collection, predicate)
+  }
+}
+
+const typeToFn = {
+  array: discardWhen_array,
+  map: discardWhen_map,
+  object: discardWhen_object,
+  set: discardWhen_set,
+}
+
+function discardWhen_array(arr, predicate) {
+  return arr.filter(negate(predicate))
+}
+
+function discardWhen_map(aMap, predicate) {
+  const result = new Map()
+
+  for (const [key, val] of aMap) {
+    if (!predicate(val, key, aMap)) result.set(key, val)
+  }
+
+  return result
+}
+
+function discardWhen_object(obj, predicate) {
+  const result = {}
+
+  for (const key of Object.keys(obj)) {
+    if (!predicate(obj[key], key, obj)) result[key] = obj[key]
+  }
+
+  return result
+}
+
+function discardWhen_set(aSet, predicate) {
+  const result = new Set()
+
+  for (const val of aSet) {
+    if (!predicate(val, val, aSet)) result.add(val)
+  }
+
+  return result
+}
+
+export default discardWhen

package/dist/discard.cjs

@@ -0,0 +1,57 @@
+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 discard = values => {
+  assertArgIsOneOfType(values, 'values', ct.valueCollection, 'discard')
+  const setOfVals = ensureSet(values)
+
+  return collection => {
+    const fn = getFn(typeToFn, collection, 'collection', 'discard')
+    return fn(collection, setOfVals)
+  }
+}
+
+const typeToFn = {
+  array: discard_array,
+  map: discard_map,
+  object: discard_object,
+  set: discard_set,
+}
+
+function discard_array(arr, vals) {
+  return arr.filter(v => !vals.has(v))
+}
+
+function discard_map(aMap, vals) {
+  const result = new Map()
+
+  for (const [k, v] of aMap) {
+    if (!vals.has(v)) result.set(k, v)
+  }
+
+  return result
+}
+
+function discard_object(obj, vals) {
+  const result = {}
+
+  for (const [k, v] of Object.entries(obj)) {
+    if (!vals.has(v)) result[k] = v
+  }
+
+  return result
+}
+
+function discard_set(aSet, vals) {
+  const result = new Set()
+
+  for (const v of aSet) {
+    if (!vals.has(v)) result.add(v)
+  }
+
+  return result
+}
+
+module.exports = discard

package/dist/discard.d.cts

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