common-fp 0.1.0

package/dist/m-fill-with.mjs

@@ -0,0 +1,32 @@
+import getFn from '@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
+}
+
+export default mFillWith

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

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

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

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

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

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

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

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

package/dist/m-keep-first.cjs

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

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

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

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

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

package/dist/m-keep-first.mjs

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

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

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

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

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

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

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

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

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

package/dist/m-keep-last.cjs

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

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

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

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

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

package/dist/m-keep-last.mjs

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

package/dist/m-keep-range.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 mKeepRange = ({ startIdx, endIdx } = {}) => {
+  validateRange(startIdx, endIdx, 'mKeepRange')
+
+  return anArray => {
+    assertArgIsType(anArray, 'anArray', 'array', 'mKeepRange')
+
+    const numToRemoveAtEnd = anArray.length - 1 - endIdx
+    anArray.splice(endIdx + 1, numToRemoveAtEnd)
+    anArray.splice(0, startIdx)
+
+    return anArray
+  }
+}
+
+module.exports = mKeepRange

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

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

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

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

package/dist/m-keep-range.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 mKeepRange = ({ startIdx, endIdx } = {}) => {
+  validateRange(startIdx, endIdx, 'mKeepRange')
+
+  return anArray => {
+    assertArgIsType(anArray, 'anArray', 'array', 'mKeepRange')
+
+    const numToRemoveAtEnd = anArray.length - 1 - endIdx
+    anArray.splice(endIdx + 1, numToRemoveAtEnd)
+    anArray.splice(0, startIdx)
+
+    return anArray
+  }
+}
+
+export default mKeepRange

package/dist/m-map-values.cjs

@@ -0,0 +1,47 @@
+/**
+ * This doesn't support Set since I'm unsure there's a solution without copying
+ * the set, and copying would be an unexpected implementation detail.
+ */
+
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+const getFn = require('@common-fp/shared-internals/get-fn')
+
+const mapValues = mapperFn => {
+  assertArgIsType(mapperFn, 'mapperFn', 'function', 'mMapValues')
+
+  return collection => {
+    const fn = getFn(typeToFn, collection, 'collection', 'mMapValues')
+    return fn(collection, mapperFn)
+  }
+}
+
+const typeToFn = {
+  array: mMapValues_array,
+  map: mMapValues_map,
+  object: mMapValues_object,
+}
+
+function mMapValues_array(arr, mapperFn) {
+  for (let i = 0; i < arr.length; i += 1) {
+    arr[i] = mapperFn(arr[i], i, arr)
+  }
+  return arr
+}
+
+function mMapValues_map(aMap, mapperFn) {
+  for (const [key, val] of aMap) {
+    aMap.set(key, mapperFn(val, key, aMap))
+  }
+
+  return aMap
+}
+
+function mMapValues_object(obj, mapperFn) {
+  for (const [key, val] of Object.entries(obj)) {
+    obj[key] = mapperFn(val, key, obj)
+  }
+
+  return obj
+}
+
+module.exports = mapValues

package/dist/m-map-values.d.cts

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

package/dist/m-map-values.d.ts

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

package/dist/m-map-values.mjs

@@ -0,0 +1,47 @@
+/**
+ * This doesn't support Set since I'm unsure there's a solution without copying
+ * the set, and copying would be an unexpected implementation detail.
+ */
+
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+import getFn from '@common-fp/shared-internals/get-fn'
+
+const mapValues = mapperFn => {
+  assertArgIsType(mapperFn, 'mapperFn', 'function', 'mMapValues')
+
+  return collection => {
+    const fn = getFn(typeToFn, collection, 'collection', 'mMapValues')
+    return fn(collection, mapperFn)
+  }
+}
+
+const typeToFn = {
+  array: mMapValues_array,
+  map: mMapValues_map,
+  object: mMapValues_object,
+}
+
+function mMapValues_array(arr, mapperFn) {
+  for (let i = 0; i < arr.length; i += 1) {
+    arr[i] = mapperFn(arr[i], i, arr)
+  }
+  return arr
+}
+
+function mMapValues_map(aMap, mapperFn) {
+  for (const [key, val] of aMap) {
+    aMap.set(key, mapperFn(val, key, aMap))
+  }
+
+  return aMap
+}
+
+function mMapValues_object(obj, mapperFn) {
+  for (const [key, val] of Object.entries(obj)) {
+    obj[key] = mapperFn(val, key, obj)
+  }
+
+  return obj
+}
+
+export default mapValues

package/dist/m-omit.cjs

@@ -0,0 +1,62 @@
+const assertArgIsOneOfType = require('@common-fp/shared-internals/assert-arg-is-one-of-type')
+const ct = require('@common-fp/shared-internals/common-types')
+const ensureNumber = require('@common-fp/shared-internals/ensure-number')
+const ensureSet = require('@common-fp/shared-internals/ensure-set')
+const getFn = require('@common-fp/shared-internals/get-fn')
+const validateArrayKeys = require('@common-fp/shared-internals/validate-array-keys')
+const validateObjectKeys = require('@common-fp/shared-internals/validate-object-keys')
+
+const mOmit = keys => {
+  assertArgIsOneOfType(keys, 'keys', ct.valueCollection, 'mOmit')
+  const setOfKeys = ensureSet(keys)
+
+  return collection => {
+    const fn = getFn(typeToFn, collection, 'collection', 'mOmit')
+    return fn(collection, setOfKeys)
+  }
+}
+
+const typeToFn = {
+  array: mOmit_array,
+  map: mOmit_map,
+  object: mOmit_object,
+}
+
+function mOmit_array(arr, keys) {
+  validateArrayKeys(keys, 'mOmit')
+
+  const descendingKeys = getDescendingArrayKeys(arr, keys)
+  for (const k of descendingKeys) {
+    arr.splice(k, 1)
+  }
+
+  return arr
+}
+
+function getDescendingArrayKeys(arr, keys) {
+  const descending = (l, r) => r - l
+  return [...keys]
+    .map(ensureNumber)
+    .filter(k => k < arr.length)
+    .sort(descending)
+}
+
+function mOmit_map(aMap, keys) {
+  for (const k of aMap.keys()) {
+    if (keys.has(k)) aMap.delete(k)
+  }
+
+  return aMap
+}
+
+function mOmit_object(obj, keys) {
+  validateObjectKeys(keys, 'mOmit')
+
+  for (const k of Object.keys(obj)) {
+    if (keys.has(k)) delete obj[k]
+  }
+
+  return obj
+}
+
+module.exports = mOmit

package/dist/m-omit.d.cts

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

package/dist/m-omit.d.ts

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

package/dist/m-omit.mjs

@@ -0,0 +1,62 @@
+import assertArgIsOneOfType from '@common-fp/shared-internals/assert-arg-is-one-of-type'
+import * as ct from '@common-fp/shared-internals/common-types'
+import ensureNumber from '@common-fp/shared-internals/ensure-number'
+import ensureSet from '@common-fp/shared-internals/ensure-set'
+import getFn from '@common-fp/shared-internals/get-fn'
+import validateArrayKeys from '@common-fp/shared-internals/validate-array-keys'
+import validateObjectKeys from '@common-fp/shared-internals/validate-object-keys'
+
+const mOmit = keys => {
+  assertArgIsOneOfType(keys, 'keys', ct.valueCollection, 'mOmit')
+  const setOfKeys = ensureSet(keys)
+
+  return collection => {
+    const fn = getFn(typeToFn, collection, 'collection', 'mOmit')
+    return fn(collection, setOfKeys)
+  }
+}
+
+const typeToFn = {
+  array: mOmit_array,
+  map: mOmit_map,
+  object: mOmit_object,
+}
+
+function mOmit_array(arr, keys) {
+  validateArrayKeys(keys, 'mOmit')
+
+  const descendingKeys = getDescendingArrayKeys(arr, keys)
+  for (const k of descendingKeys) {
+    arr.splice(k, 1)
+  }
+
+  return arr
+}
+
+function getDescendingArrayKeys(arr, keys) {
+  const descending = (l, r) => r - l
+  return [...keys]
+    .map(ensureNumber)
+    .filter(k => k < arr.length)
+    .sort(descending)
+}
+
+function mOmit_map(aMap, keys) {
+  for (const k of aMap.keys()) {
+    if (keys.has(k)) aMap.delete(k)
+  }
+
+  return aMap
+}
+
+function mOmit_object(obj, keys) {
+  validateObjectKeys(keys, 'mOmit')
+
+  for (const k of Object.keys(obj)) {
+    if (keys.has(k)) delete obj[k]
+  }
+
+  return obj
+}
+
+export default mOmit

package/dist/m-order.cjs

@@ -0,0 +1,13 @@
+const assertArgIsType = require('@common-fp/shared-internals/assert-arg-is-type')
+
+const mOrder = compareFn => {
+  assertArgIsType(compareFn, 'compareFn', 'function', 'mOrder')
+
+  return anArray => {
+    assertArgIsType(anArray, 'anArray', 'array', 'mOrder')
+
+    return anArray.sort(compareFn)
+  }
+}
+
+module.exports = mOrder

package/dist/m-order.d.cts

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

package/dist/m-order.d.ts

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

package/dist/m-order.mjs

@@ -0,0 +1,13 @@
+import assertArgIsType from '@common-fp/shared-internals/assert-arg-is-type'
+
+const mOrder = compareFn => {
+  assertArgIsType(compareFn, 'compareFn', 'function', 'mOrder')
+
+  return anArray => {
+    assertArgIsType(anArray, 'anArray', 'array', 'mOrder')
+
+    return anArray.sort(compareFn)
+  }
+}
+
+export default mOrder

package/dist/m-pick.cjs

@@ -0,0 +1,67 @@
+const assertArgIsOneOfType = require('@common-fp/shared-internals/assert-arg-is-one-of-type')
+const ct = require('@common-fp/shared-internals/common-types')
+const ensureNumber = require('@common-fp/shared-internals/ensure-number')
+const ensureSet = require('@common-fp/shared-internals/ensure-set')
+const getFn = require('@common-fp/shared-internals/get-fn')
+const validateArrayKeys = require('@common-fp/shared-internals/validate-array-keys')
+const validateObjectKeys = require('@common-fp/shared-internals/validate-object-keys')
+
+const mPick = keys => {
+  assertArgIsOneOfType(keys, 'keys', ct.valueCollection, 'mPick')
+  const setOfKeys = ensureSet(keys)
+
+  return collection => {
+    const fn = getFn(typeToFn, collection, 'collection', 'mPick')
+    return fn(collection, setOfKeys)
+  }
+}
+
+const typeToFn = {
+  array: mPick_array,
+  map: mPick_map,
+  object: mPick_object,
+}
+
+function mPick_array(arr, keys) {
+  validateArrayKeys(keys, 'mPick')
+
+  const descendingKeys = getDescendingArrayKeys(arr, keys)
+  let boundary = arr.length
+  for (const k of descendingKeys) {
+    const deleteIdx = k + 1
+    const numToDelete = boundary - deleteIdx
+    boundary = k
+    if (numToDelete) arr.splice(deleteIdx, numToDelete)
+  }
+  if (boundary) arr.splice(0, boundary)
+
+  return arr
+}
+
+function getDescendingArrayKeys(arr, keys) {
+  const descending = (l, r) => r - l
+  return [...keys]
+    .map(ensureNumber)
+    .filter(k => k < arr.length)
+    .sort(descending)
+}
+
+function mPick_map(aMap, keys) {
+  for (const k of aMap.keys()) {
+    if (!keys.has(k)) aMap.delete(k)
+  }
+
+  return aMap
+}
+
+function mPick_object(obj, keys) {
+  validateObjectKeys(keys, 'mPick')
+
+  for (const k of Object.keys(obj)) {
+    if (!keys.has(k)) delete obj[k]
+  }
+
+  return obj
+}
+
+module.exports = mPick

package/dist/m-pick.d.cts

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

package/dist/m-pick.d.ts

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

package/dist/m-pick.mjs

@@ -0,0 +1,67 @@
+import assertArgIsOneOfType from '@common-fp/shared-internals/assert-arg-is-one-of-type'
+import * as ct from '@common-fp/shared-internals/common-types'
+import ensureNumber from '@common-fp/shared-internals/ensure-number'
+import ensureSet from '@common-fp/shared-internals/ensure-set'
+import getFn from '@common-fp/shared-internals/get-fn'
+import validateArrayKeys from '@common-fp/shared-internals/validate-array-keys'
+import validateObjectKeys from '@common-fp/shared-internals/validate-object-keys'
+
+const mPick = keys => {
+  assertArgIsOneOfType(keys, 'keys', ct.valueCollection, 'mPick')
+  const setOfKeys = ensureSet(keys)
+
+  return collection => {
+    const fn = getFn(typeToFn, collection, 'collection', 'mPick')
+    return fn(collection, setOfKeys)
+  }
+}
+
+const typeToFn = {
+  array: mPick_array,
+  map: mPick_map,
+  object: mPick_object,
+}
+
+function mPick_array(arr, keys) {
+  validateArrayKeys(keys, 'mPick')
+
+  const descendingKeys = getDescendingArrayKeys(arr, keys)
+  let boundary = arr.length
+  for (const k of descendingKeys) {
+    const deleteIdx = k + 1
+    const numToDelete = boundary - deleteIdx
+    boundary = k
+    if (numToDelete) arr.splice(deleteIdx, numToDelete)
+  }
+  if (boundary) arr.splice(0, boundary)
+
+  return arr
+}
+
+function getDescendingArrayKeys(arr, keys) {
+  const descending = (l, r) => r - l
+  return [...keys]
+    .map(ensureNumber)
+    .filter(k => k < arr.length)
+    .sort(descending)
+}
+
+function mPick_map(aMap, keys) {
+  for (const k of aMap.keys()) {
+    if (!keys.has(k)) aMap.delete(k)
+  }
+
+  return aMap
+}
+
+function mPick_object(obj, keys) {
+  validateObjectKeys(keys, 'mPick')
+
+  for (const k of Object.keys(obj)) {
+    if (!keys.has(k)) delete obj[k]
+  }
+
+  return obj
+}
+
+export default mPick