common-fp 0.1.0

package/dist/add.cjs

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

package/dist/add.d.cts

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

package/dist/add.d.ts

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

package/dist/add.mjs

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

package/dist/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 all = predicate => {
+  assertArgIsType(predicate, 'predicate', 'function', 'all')
+
+  return collection => {
+    const collType = getType(collection)
+    assertArgTypeIsOneOf(collType, 'collection', ct.collection, 'all')
+    const iterator = getIterator('entries', collection, collType)
+
+    for (const [key, val] of iterator) {
+      if (!predicate(val, key, collection)) return false
+    }
+
+    return true
+  }
+}
+
+module.exports = all

package/dist/all.d.cts

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

package/dist/all.d.ts

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

package/dist/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 all = predicate => {
+  assertArgIsType(predicate, 'predicate', 'function', 'all')
+
+  return collection => {
+    const collType = getType(collection)
+    assertArgTypeIsOneOf(collType, 'collection', ct.collection, 'all')
+    const iterator = getIterator('entries', collection, collType)
+
+    for (const [key, val] of iterator) {
+      if (!predicate(val, key, collection)) return false
+    }
+
+    return true
+  }
+}
+
+export default all

package/dist/alter.cjs

@@ -0,0 +1,24 @@
+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 alter = (reducerFn, makeInitial) => {
+  assertArgIsType(reducerFn, 'reducerFn', 'function', 'alter')
+  assertArgIsType(makeInitial, 'makeInitial', 'function', 'alter')
+
+  return collection => {
+    const collType = getType(collection)
+    assertArgTypeIsOneOf(collType, 'collection', ct.collection, 'alter')
+    const iterator = getIterator('entries', collection, collType)
+
+    let result = makeInitial(collection)
+    for (const [key, val] of iterator) {
+      result = reducerFn(result, val, key, collection)
+    }
+    return result
+  }
+}
+
+module.exports = alter

package/dist/alter.d.cts

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

package/dist/alter.d.ts

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

package/dist/alter.mjs

@@ -0,0 +1,24 @@
+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 alter = (reducerFn, makeInitial) => {
+  assertArgIsType(reducerFn, 'reducerFn', 'function', 'alter')
+  assertArgIsType(makeInitial, 'makeInitial', 'function', 'alter')
+
+  return collection => {
+    const collType = getType(collection)
+    assertArgTypeIsOneOf(collType, 'collection', ct.collection, 'alter')
+    const iterator = getIterator('entries', collection, collType)
+
+    let result = makeInitial(collection)
+    for (const [key, val] of iterator) {
+      result = reducerFn(result, val, key, collection)
+    }
+    return result
+  }
+}
+
+export default alter

package/dist/any.cjs

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

package/dist/any.d.cts

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

package/dist/any.d.ts

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

package/dist/any.mjs

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

package/dist/append-all.cjs

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

package/dist/append-all.d.cts

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

package/dist/append-all.d.ts

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

package/dist/append-all.mjs

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

package/dist/append-one.cjs

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

package/dist/append-one.d.cts

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

package/dist/append-one.d.ts

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

package/dist/append-one.mjs

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

package/dist/append.cjs

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

package/dist/append.d.cts

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

package/dist/append.d.ts

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

package/dist/append.mjs

@@ -0,0 +1,13 @@
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+
+const append = end => {
+  assertArgIsType(end, 'end', 'string', 'append')
+
+  return base => {
+    assertArgIsType(base, 'base', 'string', 'append')
+
+    return base + end
+  }
+}
+
+export default append

package/dist/assign-defaults.cjs

@@ -0,0 +1,43 @@
+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 assignDefaults = defaults => {
+  const defaultsType = getType(defaults)
+  assertArgTypeIsOneOf(
+    defaultsType,
+    'defaults',
+    ct.keyedCollection,
+    'assignDefaults'
+  )
+
+  return base => {
+    const baseType = getType(base)
+    assertArgSharesTypeWith({
+      argName: 'base',
+      argType: baseType,
+      sharedArgName: 'defaults',
+      sharedArgType: defaultsType,
+      utilName: 'assignDefaults',
+    })
+
+    const fn = typeToFn[baseType]
+    return fn(base, defaults)
+  }
+}
+
+const typeToFn = {
+  map: assignDefaults_map,
+  object: assignDefaults_object,
+}
+
+function assignDefaults_map(base, defaults) {
+  return new Map([...defaults, ...base])
+}
+
+function assignDefaults_object(base, defaults) {
+  return Object.assign({}, defaults, base)
+}
+
+module.exports = assignDefaults

package/dist/assign-defaults.d.cts

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

package/dist/assign-defaults.d.ts

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

package/dist/assign-defaults.mjs

@@ -0,0 +1,43 @@
+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 assignDefaults = defaults => {
+  const defaultsType = getType(defaults)
+  assertArgTypeIsOneOf(
+    defaultsType,
+    'defaults',
+    ct.keyedCollection,
+    'assignDefaults'
+  )
+
+  return base => {
+    const baseType = getType(base)
+    assertArgSharesTypeWith({
+      argName: 'base',
+      argType: baseType,
+      sharedArgName: 'defaults',
+      sharedArgType: defaultsType,
+      utilName: 'assignDefaults',
+    })
+
+    const fn = typeToFn[baseType]
+    return fn(base, defaults)
+  }
+}
+
+const typeToFn = {
+  map: assignDefaults_map,
+  object: assignDefaults_object,
+}
+
+function assignDefaults_map(base, defaults) {
+  return new Map([...defaults, ...base])
+}
+
+function assignDefaults_object(base, defaults) {
+  return Object.assign({}, defaults, base)
+}
+
+export default assignDefaults

package/dist/assign-overrides.cjs

@@ -0,0 +1,43 @@
+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 assignOverrides = overrides => {
+  const overridesType = getType(overrides)
+  assertArgTypeIsOneOf(
+    overridesType,
+    'overrides',
+    ct.keyedCollection,
+    'assignOverrides'
+  )
+
+  return base => {
+    const baseType = getType(base)
+    assertArgSharesTypeWith({
+      argName: 'base',
+      argType: baseType,
+      sharedArgName: 'overrides',
+      sharedArgType: overridesType,
+      utilName: 'assignOverrides',
+    })
+
+    const fn = typeToFn[baseType]
+    return fn(base, overrides)
+  }
+}
+
+const typeToFn = {
+  map: assignOverrides_map,
+  object: assignOverrides_object,
+}
+
+function assignOverrides_map(base, overrides) {
+  return new Map([...base, ...overrides])
+}
+
+function assignOverrides_object(base, overrides) {
+  return Object.assign({}, base, overrides)
+}
+
+module.exports = assignOverrides

package/dist/assign-overrides.d.cts

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

package/dist/assign-overrides.d.ts

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

package/dist/assign-overrides.mjs

@@ -0,0 +1,43 @@
+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 assignOverrides = overrides => {
+  const overridesType = getType(overrides)
+  assertArgTypeIsOneOf(
+    overridesType,
+    'overrides',
+    ct.keyedCollection,
+    'assignOverrides'
+  )
+
+  return base => {
+    const baseType = getType(base)
+    assertArgSharesTypeWith({
+      argName: 'base',
+      argType: baseType,
+      sharedArgName: 'overrides',
+      sharedArgType: overridesType,
+      utilName: 'assignOverrides',
+    })
+
+    const fn = typeToFn[baseType]
+    return fn(base, overrides)
+  }
+}
+
+const typeToFn = {
+  map: assignOverrides_map,
+  object: assignOverrides_object,
+}
+
+function assignOverrides_map(base, overrides) {
+  return new Map([...base, ...overrides])
+}
+
+function assignOverrides_object(base, overrides) {
+  return Object.assign({}, base, overrides)
+}
+
+export default assignOverrides

package/dist/compare-by-path.cjs

@@ -0,0 +1,24 @@
+const assertArgIsArrayOfAcceptedTypes = require('@common-fp/shared-internals/assert-arg-is-array-of-accepted-types')
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+const ct = require('@common-fp/shared-internals/common-types')
+const getAtPath = require('./internal/get-at-path.cjs')
+
+const compareByPath = (path, compareFn) => {
+  assertArgIsArrayOfAcceptedTypes(path, 'path', ct.propertyKey, 'compareByPath')
+  assertArgIsType(compareFn, 'compareFn', 'function', 'compareByPath')
+
+  return (left, right) => {
+    const leftProp = getAtPath(path, left)
+    const rightProp = getAtPath(path, right)
+
+    // spec defines how to handle undefined here
+    // https://tc39.es/ecma262/#sec-comparearrayelements
+    if (leftProp === undefined && rightProp === undefined) return 0
+    if (leftProp === undefined) return 1
+    if (rightProp === undefined) return -1
+
+    return compareFn(leftProp, rightProp)
+  }
+}
+
+module.exports = compareByPath

package/dist/compare-by-path.d.cts

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

package/dist/compare-by-path.d.ts

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

package/dist/compare-by-path.mjs

@@ -0,0 +1,24 @@
+import assertArgIsArrayOfAcceptedTypes from '@common-fp/shared-internals/assert-arg-is-array-of-accepted-types'
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+import * as ct from '@common-fp/shared-internals/common-types'
+import getAtPath from './internal/get-at-path.mjs'
+
+const compareByPath = (path, compareFn) => {
+  assertArgIsArrayOfAcceptedTypes(path, 'path', ct.propertyKey, 'compareByPath')
+  assertArgIsType(compareFn, 'compareFn', 'function', 'compareByPath')
+
+  return (left, right) => {
+    const leftProp = getAtPath(path, left)
+    const rightProp = getAtPath(path, right)
+
+    // spec defines how to handle undefined here
+    // https://tc39.es/ecma262/#sec-comparearrayelements
+    if (leftProp === undefined && rightProp === undefined) return 0
+    if (leftProp === undefined) return 1
+    if (rightProp === undefined) return -1
+
+    return compareFn(leftProp, rightProp)
+  }
+}
+
+export default compareByPath

package/dist/compare-by-prop.cjs

@@ -0,0 +1,23 @@
+const assertArgIsOneOfType = require('@common-fp/shared-internals/assert-arg-is-one-of-type')
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+const ct = require('@common-fp/shared-internals/common-types')
+
+const compareByProp = (key, compareFn) => {
+  assertArgIsOneOfType(key, 'key', ct.propertyKey, 'compareByProp')
+  assertArgIsType(compareFn, 'compareFn', 'function', 'compareByProp')
+
+  return (left, right) => {
+    const leftVal = left?.[key]
+    const rightVal = right?.[key]
+
+    // spec defines how to handle undefined here
+    // https://tc39.es/ecma262/#sec-comparearrayelements
+    if (leftVal === undefined && rightVal === undefined) return 0
+    if (leftVal === undefined) return 1
+    if (rightVal === undefined) return -1
+
+    return compareFn(leftVal, rightVal)
+  }
+}
+
+module.exports = compareByProp

package/dist/compare-by-prop.d.cts

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

package/dist/compare-by-prop.d.ts

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

package/dist/compare-by-prop.mjs

@@ -0,0 +1,23 @@
+import assertArgIsOneOfType from '@common-fp/shared-internals/assert-arg-is-one-of-type'
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+import * as ct from '@common-fp/shared-internals/common-types'
+
+const compareByProp = (key, compareFn) => {
+  assertArgIsOneOfType(key, 'key', ct.propertyKey, 'compareByProp')
+  assertArgIsType(compareFn, 'compareFn', 'function', 'compareByProp')
+
+  return (left, right) => {
+    const leftVal = left?.[key]
+    const rightVal = right?.[key]
+
+    // spec defines how to handle undefined here
+    // https://tc39.es/ecma262/#sec-comparearrayelements
+    if (leftVal === undefined && rightVal === undefined) return 0
+    if (leftVal === undefined) return 1
+    if (rightVal === undefined) return -1
+
+    return compareFn(leftVal, rightVal)
+  }
+}
+
+export default compareByProp

package/dist/compose.cjs

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

package/dist/compose.d.cts

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

package/dist/compose.d.ts

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

package/dist/compose.mjs

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