common-fp 0.1.0

package/dist/discard.d.ts

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

package/dist/discard.mjs

@@ -0,0 +1,57 @@
+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 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
+}
+
+export default discard

package/dist/divide-by.cjs

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

package/dist/divide-by.d.cts

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

package/dist/divide-by.d.ts

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

package/dist/divide-by.mjs

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

package/dist/ends-with.cjs

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

package/dist/ends-with.d.cts

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

package/dist/ends-with.d.ts

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

package/dist/ends-with.mjs

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

package/dist/expand-end.cjs

@@ -0,0 +1,16 @@
+const assertArgIsChar = require('@common-fp/shared-internals/assert-arg-is-char')
+const assertArgIsInt = require('@common-fp/shared-internals/assert-arg-is-int')
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+
+const expandEnd = (length, char) => {
+  assertArgIsInt(length, 'length', 'expandEnd', { nonNegative: true })
+  assertArgIsChar(char, 'char', 'expandEnd')
+
+  return aString => {
+    assertArgIsType(aString, 'aString', 'string', 'expandEnd')
+
+    return aString.padEnd(length, char)
+  }
+}
+
+module.exports = expandEnd

package/dist/expand-end.d.cts

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

package/dist/expand-end.d.ts

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

package/dist/expand-end.mjs

@@ -0,0 +1,16 @@
+import assertArgIsChar from '@common-fp/shared-internals/assert-arg-is-char'
+import assertArgIsInt from '@common-fp/shared-internals/assert-arg-is-int'
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+
+const expandEnd = (length, char) => {
+  assertArgIsInt(length, 'length', 'expandEnd', { nonNegative: true })
+  assertArgIsChar(char, 'char', 'expandEnd')
+
+  return aString => {
+    assertArgIsType(aString, 'aString', 'string', 'expandEnd')
+
+    return aString.padEnd(length, char)
+  }
+}
+
+export default expandEnd

package/dist/expand-start.cjs

@@ -0,0 +1,16 @@
+const assertArgIsChar = require('@common-fp/shared-internals/assert-arg-is-char')
+const assertArgIsInt = require('@common-fp/shared-internals/assert-arg-is-int')
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+
+const expandStart = (length, char) => {
+  assertArgIsInt(length, 'length', 'expandStart', { nonNegative: true })
+  assertArgIsChar(char, 'char', 'expandStart')
+
+  return aString => {
+    assertArgIsType(aString, 'aString', 'string', 'expandStart')
+
+    return aString.padStart(length, char)
+  }
+}
+
+module.exports = expandStart

package/dist/expand-start.d.cts

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

package/dist/expand-start.d.ts

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

package/dist/expand-start.mjs

@@ -0,0 +1,16 @@
+import assertArgIsChar from '@common-fp/shared-internals/assert-arg-is-char'
+import assertArgIsInt from '@common-fp/shared-internals/assert-arg-is-int'
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+
+const expandStart = (length, char) => {
+  assertArgIsInt(length, 'length', 'expandStart', { nonNegative: true })
+  assertArgIsChar(char, 'char', 'expandStart')
+
+  return aString => {
+    assertArgIsType(aString, 'aString', 'string', 'expandStart')
+
+    return aString.padStart(length, char)
+  }
+}
+
+export default expandStart

package/dist/expand.cjs

@@ -0,0 +1,22 @@
+const assertArgIsChar = require('@common-fp/shared-internals/assert-arg-is-char')
+const assertArgIsInt = require('@common-fp/shared-internals/assert-arg-is-int')
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+
+const expand = (length, char) => {
+  assertArgIsInt(length, 'length', 'expand', { nonNegative: true })
+  assertArgIsChar(char, 'char', 'expand')
+
+  return aString => {
+    assertArgIsType(aString, 'aString', 'string', 'expand')
+
+    if (length <= aString.length) return aString
+
+    const nHalf = (length - aString.length) / 2
+    // fill end first since that's how lodash does it heh
+    const nEnd = Math.ceil(nHalf)
+    const nStart = Math.floor(nHalf)
+    return char.repeat(nStart) + aString + char.repeat(nEnd)
+  }
+}
+
+module.exports = expand

package/dist/expand.d.cts

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

package/dist/expand.d.ts

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

package/dist/expand.mjs

@@ -0,0 +1,22 @@
+import assertArgIsChar from '@common-fp/shared-internals/assert-arg-is-char'
+import assertArgIsInt from '@common-fp/shared-internals/assert-arg-is-int'
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+
+const expand = (length, char) => {
+  assertArgIsInt(length, 'length', 'expand', { nonNegative: true })
+  assertArgIsChar(char, 'char', 'expand')
+
+  return aString => {
+    assertArgIsType(aString, 'aString', 'string', 'expand')
+
+    if (length <= aString.length) return aString
+
+    const nHalf = (length - aString.length) / 2
+    // fill end first since that's how lodash does it heh
+    const nEnd = Math.ceil(nHalf)
+    const nStart = Math.floor(nHalf)
+    return char.repeat(nStart) + aString + char.repeat(nEnd)
+  }
+}
+
+export default expand

package/dist/fill-range-with.cjs

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

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

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

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

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

package/dist/fill-range-with.mjs

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

package/dist/fill-with.cjs

@@ -0,0 +1,34 @@
+const getFn = require('@common-fp/shared-internals/get-fn')
+
+const fillWith = value => collection => {
+  const fn = getFn(typeToFn, collection, 'collection', 'fillWith')
+  return fn(collection, value)
+}
+
+const typeToFn = {
+  array: fillWith_array,
+  map: fillWith_map,
+  object: fillWith_object,
+}
+
+function fillWith_array(arr, value) {
+  return new Array(arr.length).fill(value)
+}
+
+function fillWith_map(aMap, value) {
+  const result = new Map()
+  for (const k of aMap.keys()) {
+    result.set(k, value)
+  }
+  return result
+}
+
+function fillWith_object(obj, value) {
+  const result = {}
+  for (const k of Object.keys(obj)) {
+    result[k] = value
+  }
+  return result
+}
+
+module.exports = fillWith

package/dist/fill-with.d.cts

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

package/dist/fill-with.d.ts

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

package/dist/fill-with.mjs

@@ -0,0 +1,34 @@
+import getFn from '@common-fp/shared-internals/get-fn'
+
+const fillWith = value => collection => {
+  const fn = getFn(typeToFn, collection, 'collection', 'fillWith')
+  return fn(collection, value)
+}
+
+const typeToFn = {
+  array: fillWith_array,
+  map: fillWith_map,
+  object: fillWith_object,
+}
+
+function fillWith_array(arr, value) {
+  return new Array(arr.length).fill(value)
+}
+
+function fillWith_map(aMap, value) {
+  const result = new Map()
+  for (const k of aMap.keys()) {
+    result.set(k, value)
+  }
+  return result
+}
+
+function fillWith_object(obj, value) {
+  const result = {}
+  for (const k of Object.keys(obj)) {
+    result[k] = value
+  }
+  return result
+}
+
+export default fillWith

package/dist/find-key-with-val.cjs

@@ -0,0 +1,46 @@
+const getFnByType = require('@common-fp/shared-internals/get-fn-by-type')
+const getType = require('@common-fp/shared-internals/get-type')
+
+const findKeyWithVal = value => {
+  const valType = getType(value)
+
+  return collection => {
+    const colType = getType(collection)
+    const fn = getFnByType(typeToFn, colType, 'collection', 'findKeyWithVal')
+
+    if (colType === 'string' && valType !== 'string') {
+      throw new Error(
+        'When calling findKeyWithVal with a collection of type string, value must also be a string' +
+          `\n  value type: ${valType}`
+      )
+    }
+
+    return fn(collection, value)
+  }
+}
+
+const typeToFn = {
+  array: findKeyWithVal_indexOf,
+  map: findKeyWithVal_map,
+  object: findKeyWithVal_object,
+  string: findKeyWithVal_indexOf,
+}
+
+function findKeyWithVal_indexOf(sequence, value) {
+  const idx = sequence.indexOf(value)
+  return idx === -1 ? undefined : idx
+}
+
+function findKeyWithVal_map(aMap, value) {
+  for (const [key, val] of aMap.entries()) {
+    if (val === value) return key
+  }
+}
+
+function findKeyWithVal_object(obj, value) {
+  for (const [key, val] of Object.entries(obj)) {
+    if (val === value) return key
+  }
+}
+
+module.exports = findKeyWithVal

package/dist/find-key-with-val.d.cts

@@ -0,0 +1,2 @@
+import { default as findKeyWithVal } from '@common-fp/common-fp-types/find-key-with-val'
+export = findKeyWithVal

package/dist/find-key-with-val.d.ts

@@ -0,0 +1 @@
+export { default } from '@common-fp/common-fp-types/find-key-with-val'

package/dist/find-key-with-val.mjs

@@ -0,0 +1,46 @@
+import getFnByType from '@common-fp/shared-internals/get-fn-by-type'
+import getType from '@common-fp/shared-internals/get-type'
+
+const findKeyWithVal = value => {
+  const valType = getType(value)
+
+  return collection => {
+    const colType = getType(collection)
+    const fn = getFnByType(typeToFn, colType, 'collection', 'findKeyWithVal')
+
+    if (colType === 'string' && valType !== 'string') {
+      throw new Error(
+        'When calling findKeyWithVal with a collection of type string, value must also be a string' +
+          `\n  value type: ${valType}`
+      )
+    }
+
+    return fn(collection, value)
+  }
+}
+
+const typeToFn = {
+  array: findKeyWithVal_indexOf,
+  map: findKeyWithVal_map,
+  object: findKeyWithVal_object,
+  string: findKeyWithVal_indexOf,
+}
+
+function findKeyWithVal_indexOf(sequence, value) {
+  const idx = sequence.indexOf(value)
+  return idx === -1 ? undefined : idx
+}
+
+function findKeyWithVal_map(aMap, value) {
+  for (const [key, val] of aMap.entries()) {
+    if (val === value) return key
+  }
+}
+
+function findKeyWithVal_object(obj, value) {
+  for (const [key, val] of Object.entries(obj)) {
+    if (val === value) return key
+  }
+}
+
+export default findKeyWithVal

package/dist/find-key.cjs

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

package/dist/find-key.d.cts

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

package/dist/find-key.d.ts

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

package/dist/find-key.mjs

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

package/dist/find-last-key-with-val.cjs

@@ -0,0 +1,23 @@
+const assertArgTypeIsOneOf = require('@common-fp/shared-internals/assert-arg-type-is-one-of')
+const ct = require('@common-fp/shared-internals/common-types')
+const getType = require('@common-fp/shared-internals/get-type')
+
+const findLastKeyWithVal = value => {
+  const valType = getType(value)
+
+  return sequence => {
+    const seqType = getType(sequence)
+    assertArgTypeIsOneOf(seqType, 'sequence', ct.sequence, 'findLastKeyWithVal')
+    if (seqType === 'string' && valType !== 'string') {
+      throw new Error(
+        'When calling findLastKeyWithVal with a sequence of type string, value must also be a string' +
+          `\n  value type: ${valType}`
+      )
+    }
+
+    const idx = sequence.lastIndexOf(value)
+    return idx === -1 ? undefined : idx
+  }
+}
+
+module.exports = findLastKeyWithVal

package/dist/find-last-key-with-val.d.cts

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

package/dist/find-last-key-with-val.d.ts

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

package/dist/find-last-key-with-val.mjs

@@ -0,0 +1,23 @@
+import assertArgTypeIsOneOf from '@common-fp/shared-internals/assert-arg-type-is-one-of'
+import * as ct from '@common-fp/shared-internals/common-types'
+import getType from '@common-fp/shared-internals/get-type'
+
+const findLastKeyWithVal = value => {
+  const valType = getType(value)
+
+  return sequence => {
+    const seqType = getType(sequence)
+    assertArgTypeIsOneOf(seqType, 'sequence', ct.sequence, 'findLastKeyWithVal')
+    if (seqType === 'string' && valType !== 'string') {
+      throw new Error(
+        'When calling findLastKeyWithVal with a sequence of type string, value must also be a string' +
+          `\n  value type: ${valType}`
+      )
+    }
+
+    const idx = sequence.lastIndexOf(value)
+    return idx === -1 ? undefined : idx
+  }
+}
+
+export default findLastKeyWithVal

package/dist/find-last-key.cjs

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

package/dist/find-last-key.d.cts

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

package/dist/find-last-key.d.ts

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

package/dist/find-last-key.mjs

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