common-fp 0.1.0

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

@@ -0,0 +1,13 @@
+import assertArgIsType from '@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
+  }
+}
+
+export default lessThanOrEqualTo

package/dist/less-than.cjs

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

package/dist/less-than.d.cts

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

package/dist/less-than.d.ts

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

package/dist/less-than.mjs

@@ -0,0 +1,13 @@
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+
+const lessThan = right => {
+  assertArgIsType(right, 'right', 'number', 'lessThan')
+
+  return left => {
+    assertArgIsType(left, 'left', 'number', 'lessThan')
+
+    return left < right
+  }
+}
+
+export default lessThan

package/dist/m-append-all.cjs

@@ -0,0 +1,14 @@
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+
+const mAppendAll = appended => {
+  assertArgIsType(appended, 'appended', 'array', 'mAppendAll')
+
+  return base => {
+    assertArgIsType(base, 'base', 'array', 'mAppendAll')
+
+    base.push(...appended)
+    return base
+  }
+}
+
+module.exports = mAppendAll

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

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

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

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

package/dist/m-append-all.mjs

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

package/dist/m-append-one.cjs

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

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

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

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

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

package/dist/m-append-one.mjs

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

package/dist/m-assign-defaults.cjs

@@ -0,0 +1,51 @@
+const assertArgTypeIsOneOf = require('@common-fp/shared-internals/assert-arg-type-is-one-of')
+const assertArgSharesTypeWith = require('@common-fp/shared-internals/assert-arg-shares-type-with')
+const ct = require('@common-fp/shared-internals/common-types')
+const getType = require('@common-fp/shared-internals/get-type')
+
+const mAssignDefaults = defaults => {
+  const defaultsType = getType(defaults)
+  assertArgTypeIsOneOf(
+    defaultsType,
+    'defaults',
+    ct.keyedCollection,
+    'mAssignDefaults'
+  )
+
+  return base => {
+    const baseType = getType(base)
+    assertArgSharesTypeWith({
+      argName: 'base',
+      argType: baseType,
+      sharedArgName: 'defaults',
+      sharedArgType: defaultsType,
+      utilName: 'mAssignDefaults',
+    })
+
+    const fn = typeToFn[baseType]
+    return fn(base, defaults)
+  }
+}
+
+const typeToFn = {
+  map: mAssignDefaults_map,
+  object: mAssignDefaults_object,
+}
+
+function mAssignDefaults_map(base, defaults) {
+  for (const [key, val] of defaults) {
+    if (!base.has(key)) base.set(key, val)
+  }
+
+  return base
+}
+
+function mAssignDefaults_object(base, defaults) {
+  for (const [key, val] of Object.entries(defaults)) {
+    if (!Object.hasOwn(base, key)) base[key] = val
+  }
+
+  return base
+}
+
+module.exports = mAssignDefaults

package/dist/m-assign-defaults.d.cts

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

package/dist/m-assign-defaults.d.ts

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

package/dist/m-assign-defaults.mjs

@@ -0,0 +1,51 @@
+import assertArgTypeIsOneOf from '@common-fp/shared-internals/assert-arg-type-is-one-of'
+import assertArgSharesTypeWith from '@common-fp/shared-internals/assert-arg-shares-type-with'
+import * as ct from '@common-fp/shared-internals/common-types'
+import getType from '@common-fp/shared-internals/get-type'
+
+const mAssignDefaults = defaults => {
+  const defaultsType = getType(defaults)
+  assertArgTypeIsOneOf(
+    defaultsType,
+    'defaults',
+    ct.keyedCollection,
+    'mAssignDefaults'
+  )
+
+  return base => {
+    const baseType = getType(base)
+    assertArgSharesTypeWith({
+      argName: 'base',
+      argType: baseType,
+      sharedArgName: 'defaults',
+      sharedArgType: defaultsType,
+      utilName: 'mAssignDefaults',
+    })
+
+    const fn = typeToFn[baseType]
+    return fn(base, defaults)
+  }
+}
+
+const typeToFn = {
+  map: mAssignDefaults_map,
+  object: mAssignDefaults_object,
+}
+
+function mAssignDefaults_map(base, defaults) {
+  for (const [key, val] of defaults) {
+    if (!base.has(key)) base.set(key, val)
+  }
+
+  return base
+}
+
+function mAssignDefaults_object(base, defaults) {
+  for (const [key, val] of Object.entries(defaults)) {
+    if (!Object.hasOwn(base, key)) base[key] = val
+  }
+
+  return base
+}
+
+export default mAssignDefaults

package/dist/m-assign-overrides.cjs

@@ -0,0 +1,47 @@
+const assertArgTypeIsOneOf = require('@common-fp/shared-internals/assert-arg-type-is-one-of')
+const assertArgSharesTypeWith = require('@common-fp/shared-internals/assert-arg-shares-type-with')
+const ct = require('@common-fp/shared-internals/common-types')
+const getType = require('@common-fp/shared-internals/get-type')
+
+const mAssignOverrides = overrides => {
+  const overridesType = getType(overrides)
+  assertArgTypeIsOneOf(
+    overridesType,
+    'overrides',
+    ct.keyedCollection,
+    'mAssignOverrides'
+  )
+
+  return base => {
+    const baseType = getType(base)
+    assertArgSharesTypeWith({
+      argName: 'base',
+      argType: baseType,
+      sharedArgName: 'overrides',
+      sharedArgType: overridesType,
+      utilName: 'mAssignOverrides',
+    })
+
+    const fn = typeToFn[baseType]
+    return fn(base, overrides)
+  }
+}
+
+const typeToFn = {
+  map: mAssignOverrides_map,
+  object: mAssignOverrides_object,
+}
+
+function mAssignOverrides_map(base, overrides) {
+  for (const [key, val] of overrides) {
+    base.set(key, val)
+  }
+
+  return base
+}
+
+function mAssignOverrides_object(base, overrides) {
+  return Object.assign(base, overrides)
+}
+
+module.exports = mAssignOverrides

package/dist/m-assign-overrides.d.cts

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

package/dist/m-assign-overrides.d.ts

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

package/dist/m-assign-overrides.mjs

@@ -0,0 +1,47 @@
+import assertArgTypeIsOneOf from '@common-fp/shared-internals/assert-arg-type-is-one-of'
+import assertArgSharesTypeWith from '@common-fp/shared-internals/assert-arg-shares-type-with'
+import * as ct from '@common-fp/shared-internals/common-types'
+import getType from '@common-fp/shared-internals/get-type'
+
+const mAssignOverrides = overrides => {
+  const overridesType = getType(overrides)
+  assertArgTypeIsOneOf(
+    overridesType,
+    'overrides',
+    ct.keyedCollection,
+    'mAssignOverrides'
+  )
+
+  return base => {
+    const baseType = getType(base)
+    assertArgSharesTypeWith({
+      argName: 'base',
+      argType: baseType,
+      sharedArgName: 'overrides',
+      sharedArgType: overridesType,
+      utilName: 'mAssignOverrides',
+    })
+
+    const fn = typeToFn[baseType]
+    return fn(base, overrides)
+  }
+}
+
+const typeToFn = {
+  map: mAssignOverrides_map,
+  object: mAssignOverrides_object,
+}
+
+function mAssignOverrides_map(base, overrides) {
+  for (const [key, val] of overrides) {
+    base.set(key, val)
+  }
+
+  return base
+}
+
+function mAssignOverrides_object(base, overrides) {
+  return Object.assign(base, overrides)
+}
+
+export default mAssignOverrides

package/dist/m-discard-first-while.cjs

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

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

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

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

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

package/dist/m-discard-first-while.mjs

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

package/dist/m-discard-first.cjs

@@ -0,0 +1,16 @@
+const assertArgIsInt = require('@common-fp/shared-internals/assert-arg-is-int')
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+
+const mDiscardFirst = num => {
+  assertArgIsInt(num, 'num', 'mDiscardFirst', {
+    nonNegative: true,
+  })
+
+  return anArray => {
+    assertArgIsType(anArray, 'anArray', 'array', 'mDiscardFirst')
+    anArray.splice(0, num)
+    return anArray
+  }
+}
+
+module.exports = mDiscardFirst

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

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

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

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

package/dist/m-discard-first.mjs

@@ -0,0 +1,16 @@
+import assertArgIsInt from '@common-fp/shared-internals/assert-arg-is-int'
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+
+const mDiscardFirst = num => {
+  assertArgIsInt(num, 'num', 'mDiscardFirst', {
+    nonNegative: true,
+  })
+
+  return anArray => {
+    assertArgIsType(anArray, 'anArray', 'array', 'mDiscardFirst')
+    anArray.splice(0, num)
+    return anArray
+  }
+}
+
+export default mDiscardFirst

package/dist/m-discard-last-while.cjs

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

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

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

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

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

package/dist/m-discard-last-while.mjs

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

package/dist/m-discard-last.cjs

@@ -0,0 +1,16 @@
+const assertArgIsInt = require('@common-fp/shared-internals/assert-arg-is-int')
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+
+const mDiscardLast = numToDiscard => {
+  assertArgIsInt(numToDiscard, 'numToDiscard', 'mDiscardLast', {
+    nonNegative: true,
+  })
+
+  return anArray => {
+    assertArgIsType(anArray, 'anArray', 'array', 'mDiscardLast')
+    anArray.splice(Math.max(0, anArray.length - numToDiscard), numToDiscard)
+    return anArray
+  }
+}
+
+module.exports = mDiscardLast

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

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

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

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

package/dist/m-discard-last.mjs

@@ -0,0 +1,16 @@
+import assertArgIsInt from '@common-fp/shared-internals/assert-arg-is-int'
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+
+const mDiscardLast = numToDiscard => {
+  assertArgIsInt(numToDiscard, 'numToDiscard', 'mDiscardLast', {
+    nonNegative: true,
+  })
+
+  return anArray => {
+    assertArgIsType(anArray, 'anArray', 'array', 'mDiscardLast')
+    anArray.splice(Math.max(0, anArray.length - numToDiscard), numToDiscard)
+    return anArray
+  }
+}
+
+export default mDiscardLast

package/dist/m-discard-range.cjs

@@ -0,0 +1,17 @@
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+const validateRange = require('@common-fp/shared-internals/validate-range')
+
+const mDiscardRange = ({ startIdx, endIdx } = {}) => {
+  validateRange(startIdx, endIdx, 'mDiscardRange')
+
+  return anArray => {
+    assertArgIsType(anArray, 'anArray', 'array', 'mDiscardRange')
+
+    const numToDiscard = endIdx + 1 - startIdx
+    anArray.splice(startIdx, numToDiscard)
+
+    return anArray
+  }
+}
+
+module.exports = mDiscardRange

package/dist/m-discard-range.d.cts

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

package/dist/m-discard-range.d.ts

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

package/dist/m-discard-range.mjs

@@ -0,0 +1,17 @@
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+import validateRange from '@common-fp/shared-internals/validate-range'
+
+const mDiscardRange = ({ startIdx, endIdx } = {}) => {
+  validateRange(startIdx, endIdx, 'mDiscardRange')
+
+  return anArray => {
+    assertArgIsType(anArray, 'anArray', 'array', 'mDiscardRange')
+
+    const numToDiscard = endIdx + 1 - startIdx
+    anArray.splice(startIdx, numToDiscard)
+
+    return anArray
+  }
+}
+
+export default mDiscardRange

package/dist/m-fill-range-with.cjs

@@ -0,0 +1,17 @@
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+const validateRange = require('@common-fp/shared-internals/validate-range')
+
+const mFillRangeWith = (anything, { startIdx, endIdx } = {}) => {
+  validateRange(startIdx, endIdx, 'mFillRangeWith')
+
+  return anArray => {
+    assertArgIsType(anArray, 'anArray', 'array', 'mFillRangeWith')
+
+    for (let i = startIdx; i <= endIdx; i += 1) {
+      anArray[i] = anything
+    }
+    return anArray
+  }
+}
+
+module.exports = mFillRangeWith

package/dist/m-fill-range-with.d.cts

@@ -0,0 +1,2 @@
+import { default as mFillRangeWith } from '@common-fp/common-fp-types/m-fill-range-with'
+export = mFillRangeWith

package/dist/m-fill-range-with.d.ts

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

package/dist/m-fill-range-with.mjs

@@ -0,0 +1,17 @@
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+import validateRange from '@common-fp/shared-internals/validate-range'
+
+const mFillRangeWith = (anything, { startIdx, endIdx } = {}) => {
+  validateRange(startIdx, endIdx, 'mFillRangeWith')
+
+  return anArray => {
+    assertArgIsType(anArray, 'anArray', 'array', 'mFillRangeWith')
+
+    for (let i = startIdx; i <= endIdx; i += 1) {
+      anArray[i] = anything
+    }
+    return anArray
+  }
+}
+
+export default mFillRangeWith

package/dist/m-fill-with.cjs

@@ -0,0 +1,32 @@
+const getFn = require('@common-fp/shared-internals/get-fn')
+
+const mFillWith = value => collection => {
+  const fn = getFn(typeToFn, collection, 'collection', 'mFillWith')
+  return fn(collection, value)
+}
+
+const typeToFn = {
+  array: mFillWith_array,
+  map: mFillWith_map,
+  object: mFillWith_object,
+}
+
+function mFillWith_array(arr, value) {
+  return arr.fill(value)
+}
+
+function mFillWith_map(aMap, value) {
+  for (const k of aMap.keys()) {
+    aMap.set(k, value)
+  }
+  return aMap
+}
+
+function mFillWith_object(obj, value) {
+  for (const k of Object.keys(obj)) {
+    obj[k] = value
+  }
+  return obj
+}
+
+module.exports = mFillWith

package/dist/m-fill-with.d.cts

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

package/dist/m-fill-with.d.ts

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