@common-fp/shared-internals 0.1.0

package/dist/a-or-an.cjs

@@ -0,0 +1,6 @@
+const aOrAn = str => {
+  const prefix = /[aeiouy]/.test(str[0]) ? 'an' : 'a'
+  return `${prefix} ${str}`
+}
+
+module.exports = aOrAn

package/dist/a-or-an.d.cts

@@ -0,0 +1,2 @@
+import { default as aOrAn } from '@common-fp/shared-internals-types/a-or-an'
+export = aOrAn

package/dist/a-or-an.d.ts

@@ -0,0 +1 @@
+export { default } from '@common-fp/shared-internals-types/a-or-an'

package/dist/a-or-an.mjs

@@ -0,0 +1,6 @@
+const aOrAn = str => {
+  const prefix = /[aeiouy]/.test(str[0]) ? 'an' : 'a'
+  return `${prefix} ${str}`
+}
+
+export default aOrAn

package/dist/assert-arg-has-values-of-type.cjs

@@ -0,0 +1,29 @@
+/**
+ * This assumes arg is a collection
+ * i.e. arg has already passed assertArgIsOneOfType -> commonTypes.collection
+ */
+
+const getIterator = require('./get-iterator.cjs')
+const getType = require('./get-type.cjs')
+
+const assertArgHasValuesOfType = (arg, argName, type, utilName) => {
+  let badTypeFound = false
+  let badValType
+
+  for (const val of getIterator('values', arg)) {
+    badValType = getType(val)
+    badTypeFound = badValType !== type
+    if (badTypeFound) {
+      break
+    }
+  }
+
+  if (badTypeFound) {
+    throw new Error(
+      `${utilName} reuqires argument ${argName} to contain only ${type}s` +
+        `\nAt least one value was found with type ${badValType}`
+    )
+  }
+}
+
+module.exports = assertArgHasValuesOfType

package/dist/assert-arg-has-values-of-type.d.cts

@@ -0,0 +1,2 @@
+import { default as assertArgHasValuesOfType } from '@common-fp/shared-internals-types/assert-arg-has-values-of-type'
+export = assertArgHasValuesOfType

package/dist/assert-arg-has-values-of-type.d.ts

@@ -0,0 +1 @@
+export { default } from '@common-fp/shared-internals-types/assert-arg-has-values-of-type'

package/dist/assert-arg-has-values-of-type.mjs

@@ -0,0 +1,29 @@
+/**
+ * This assumes arg is a collection
+ * i.e. arg has already passed assertArgIsOneOfType -> commonTypes.collection
+ */
+
+import getIterator from './get-iterator.mjs'
+import getType from './get-type.mjs'
+
+const assertArgHasValuesOfType = (arg, argName, type, utilName) => {
+  let badTypeFound = false
+  let badValType
+
+  for (const val of getIterator('values', arg)) {
+    badValType = getType(val)
+    badTypeFound = badValType !== type
+    if (badTypeFound) {
+      break
+    }
+  }
+
+  if (badTypeFound) {
+    throw new Error(
+      `${utilName} reuqires argument ${argName} to contain only ${type}s` +
+        `\nAt least one value was found with type ${badValType}`
+    )
+  }
+}
+
+export default assertArgHasValuesOfType

package/dist/assert-arg-is-array-of-accepted-types.cjs

@@ -0,0 +1,28 @@
+const assertArgIsType = require('./assert-arg-is-type.cjs')
+const getType = require('./get-type.cjs')
+const toEnglishList = require('./to-english-list.cjs')
+const ensureSet = require('./ensure-set.cjs')
+
+const assertArgIsArrayOfAcceptedTypes = (
+  arg,
+  argName,
+  acceptedTypes,
+  utilName
+) => {
+  assertArgIsType(arg, argName, 'array', utilName)
+
+  if (!arg.length) return
+
+  const acceptedTypesStr = toEnglishList('and', acceptedTypes)
+
+  const setOfAcceptedTypes = ensureSet(acceptedTypes)
+  for (const el of arg) {
+    const elType = getType(el)
+    if (!setOfAcceptedTypes.has(elType)) {
+      const msg = `${utilName} requires argument '${argName}' to be an array of ${acceptedTypesStr} - but found ${elType}`
+      throw new Error(msg)
+    }
+  }
+}
+
+module.exports = assertArgIsArrayOfAcceptedTypes

package/dist/assert-arg-is-array-of-accepted-types.d.cts

@@ -0,0 +1,2 @@
+import { default as assertArgIsArrayOfAcceptedTypes } from '@common-fp/shared-internals-types/assert-arg-is-array-of-accepted-types'
+export = assertArgIsArrayOfAcceptedTypes

package/dist/assert-arg-is-array-of-accepted-types.d.ts

@@ -0,0 +1 @@
+export { default } from '@common-fp/shared-internals-types/assert-arg-is-array-of-accepted-types'

package/dist/assert-arg-is-array-of-accepted-types.mjs

@@ -0,0 +1,28 @@
+import assertArgIsType from './assert-arg-is-type.mjs'
+import getType from './get-type.mjs'
+import toEnglishList from './to-english-list.mjs'
+import ensureSet from './ensure-set.mjs'
+
+const assertArgIsArrayOfAcceptedTypes = (
+  arg,
+  argName,
+  acceptedTypes,
+  utilName
+) => {
+  assertArgIsType(arg, argName, 'array', utilName)
+
+  if (!arg.length) return
+
+  const acceptedTypesStr = toEnglishList('and', acceptedTypes)
+
+  const setOfAcceptedTypes = ensureSet(acceptedTypes)
+  for (const el of arg) {
+    const elType = getType(el)
+    if (!setOfAcceptedTypes.has(elType)) {
+      const msg = `${utilName} requires argument '${argName}' to be an array of ${acceptedTypesStr} - but found ${elType}`
+      throw new Error(msg)
+    }
+  }
+}
+
+export default assertArgIsArrayOfAcceptedTypes

package/dist/assert-arg-is-array-of-same-type.cjs

@@ -0,0 +1,34 @@
+const assertArgIsType = require('./assert-arg-is-type.cjs')
+const ensureSet = require('./ensure-set.cjs')
+const getType = require('./get-type.cjs')
+const toEnglishList = require('./to-english-list.cjs')
+
+const assertArgIsArrayOfSameType = (arg, argName, acceptedTypes, utilName) => {
+  assertArgIsType(arg, argName, 'array', utilName)
+
+  if (!arg.length) {
+    throw new Error(
+      `${utilName} requires argument '${argName}' to have at least one element.  This is so it knows which type to return.`
+    )
+  }
+
+  const setOfAcceptedTypes = ensureSet(acceptedTypes)
+  const acceptedTypesStr = toEnglishList('or', acceptedTypes)
+
+  const firstType = getType(arg[0])
+  for (const el of arg) {
+    const elType = getType(el)
+    if (!setOfAcceptedTypes.has(elType)) {
+      throw new Error(
+        `${utilName} requires argument '${argName}' to be an array of ${acceptedTypesStr} - but found ${firstType}`
+      )
+    }
+    if (elType !== firstType) {
+      throw new Error(
+        `${utilName} requires argument '${argName}' to be an array of the same types - found both ${firstType} and ${elType}`
+      )
+    }
+  }
+}
+
+module.exports = assertArgIsArrayOfSameType

package/dist/assert-arg-is-array-of-same-type.d.cts

@@ -0,0 +1,2 @@
+import { default as assertArgIsArrayOfSameType } from '@common-fp/shared-internals-types/assert-arg-is-array-of-same-type'
+export = assertArgIsArrayOfSameType

package/dist/assert-arg-is-array-of-same-type.d.ts

@@ -0,0 +1 @@
+export { default } from '@common-fp/shared-internals-types/assert-arg-is-array-of-same-type'

package/dist/assert-arg-is-array-of-same-type.mjs

@@ -0,0 +1,34 @@
+import assertArgIsType from './assert-arg-is-type.mjs'
+import ensureSet from './ensure-set.mjs'
+import getType from './get-type.mjs'
+import toEnglishList from './to-english-list.mjs'
+
+const assertArgIsArrayOfSameType = (arg, argName, acceptedTypes, utilName) => {
+  assertArgIsType(arg, argName, 'array', utilName)
+
+  if (!arg.length) {
+    throw new Error(
+      `${utilName} requires argument '${argName}' to have at least one element.  This is so it knows which type to return.`
+    )
+  }
+
+  const setOfAcceptedTypes = ensureSet(acceptedTypes)
+  const acceptedTypesStr = toEnglishList('or', acceptedTypes)
+
+  const firstType = getType(arg[0])
+  for (const el of arg) {
+    const elType = getType(el)
+    if (!setOfAcceptedTypes.has(elType)) {
+      throw new Error(
+        `${utilName} requires argument '${argName}' to be an array of ${acceptedTypesStr} - but found ${firstType}`
+      )
+    }
+    if (elType !== firstType) {
+      throw new Error(
+        `${utilName} requires argument '${argName}' to be an array of the same types - found both ${firstType} and ${elType}`
+      )
+    }
+  }
+}
+
+export default assertArgIsArrayOfSameType

package/dist/assert-arg-is-array-of-type.cjs

@@ -0,0 +1,18 @@
+const assertArgIsType = require('./assert-arg-is-type.cjs')
+const getType = require('./get-type.cjs')
+
+const assertArgIsArrayOfType = (arg, argName, type, utilName) => {
+  assertArgIsType(arg, argName, 'array', utilName)
+
+  if (!arg.length) return
+
+  for (const el of arg) {
+    const elType = getType(el)
+    if (elType !== type) {
+      const errMsg = `${utilName} requires argument '${argName}' to contain only ${type}s - but a ${elType} was found`
+      throw new Error(errMsg)
+    }
+  }
+}
+
+module.exports = assertArgIsArrayOfType

package/dist/assert-arg-is-array-of-type.d.cts

@@ -0,0 +1,2 @@
+import { default as assertArgIsArrayOfType } from '@common-fp/shared-internals-types/assert-arg-is-array-of-type'
+export = assertArgIsArrayOfType

package/dist/assert-arg-is-array-of-type.d.ts

@@ -0,0 +1 @@
+export { default } from '@common-fp/shared-internals-types/assert-arg-is-array-of-type'

package/dist/assert-arg-is-array-of-type.mjs

@@ -0,0 +1,18 @@
+import assertArgIsType from './assert-arg-is-type.mjs'
+import getType from './get-type.mjs'
+
+const assertArgIsArrayOfType = (arg, argName, type, utilName) => {
+  assertArgIsType(arg, argName, 'array', utilName)
+
+  if (!arg.length) return
+
+  for (const el of arg) {
+    const elType = getType(el)
+    if (elType !== type) {
+      const errMsg = `${utilName} requires argument '${argName}' to contain only ${type}s - but a ${elType} was found`
+      throw new Error(errMsg)
+    }
+  }
+}
+
+export default assertArgIsArrayOfType

package/dist/assert-arg-is-char.cjs

@@ -0,0 +1,19 @@
+const getType = require('./get-type.cjs')
+const truncateToNChars = require('./truncate-to-n-chars.cjs')
+
+const assertArgIsChar = (aChar, argName, utilName) => {
+  const charType = getType(aChar)
+  if (charType !== 'string') {
+    throw new Error(
+      `${utilName} requires argument '${argName}' to be typeof string - but type ${charType} was passed`
+    )
+  }
+  if (aChar.length !== 1) {
+    const truncatedChar = truncateToNChars(10, aChar)
+    throw new Error(
+      `${utilName} requires argument '${argName}' to be a single character - but ${truncatedChar} was passed`
+    )
+  }
+}
+
+module.exports = assertArgIsChar

package/dist/assert-arg-is-char.d.cts

@@ -0,0 +1,2 @@
+import { default as assertArgIsChar } from '@common-fp/shared-internals-types/assert-arg-is-char'
+export = assertArgIsChar

package/dist/assert-arg-is-char.d.ts

@@ -0,0 +1 @@
+export { default } from '@common-fp/shared-internals-types/assert-arg-is-char'

package/dist/assert-arg-is-char.mjs

@@ -0,0 +1,19 @@
+import getType from './get-type.mjs'
+import truncateToNChars from './truncate-to-n-chars.mjs'
+
+const assertArgIsChar = (aChar, argName, utilName) => {
+  const charType = getType(aChar)
+  if (charType !== 'string') {
+    throw new Error(
+      `${utilName} requires argument '${argName}' to be typeof string - but type ${charType} was passed`
+    )
+  }
+  if (aChar.length !== 1) {
+    const truncatedChar = truncateToNChars(10, aChar)
+    throw new Error(
+      `${utilName} requires argument '${argName}' to be a single character - but ${truncatedChar} was passed`
+    )
+  }
+}
+
+export default assertArgIsChar

package/dist/assert-arg-is-int.cjs

@@ -0,0 +1,35 @@
+const getType = require('./get-type.cjs')
+
+const assertArgIsInt = (n, argName, utilName, furtherAssertions = {}) => {
+  const nType = getType(n)
+  const { nonNegative, positive } = furtherAssertions
+
+  if (nType !== 'number') {
+    throw new Error(
+      `${utilName} requires argument '${argName}' to be an integer - but a ${nType} was passed`
+    )
+  }
+  if (nonNegative) {
+    const isNonNegative = Number.isInteger(n) && n >= 0
+    if (!isNonNegative) {
+      throw new Error(
+        `${utilName} requires argument '${argName}' to be an integer greater than or equal to zero - but ${n} was passed`
+      )
+    }
+  } else if (positive) {
+    const isPositive = Number.isInteger(n) && n > 0
+    if (!isPositive) {
+      throw new Error(
+        `${utilName} requires argument '${argName}' to be a positive integer - but ${n} was passed`
+      )
+    }
+  } else {
+    if (!Number.isInteger(n)) {
+      throw new Error(
+        `${utilName} requires argument '${argName}' to be an integer - but ${n} was passed`
+      )
+    }
+  }
+}
+
+module.exports = assertArgIsInt

package/dist/assert-arg-is-int.d.cts

@@ -0,0 +1,2 @@
+import { default as assertArgIsInt } from '@common-fp/shared-internals-types/assert-arg-is-int'
+export = assertArgIsInt

package/dist/assert-arg-is-int.d.ts

@@ -0,0 +1 @@
+export { default } from '@common-fp/shared-internals-types/assert-arg-is-int'

package/dist/assert-arg-is-int.mjs

@@ -0,0 +1,35 @@
+import getType from './get-type.mjs'
+
+const assertArgIsInt = (n, argName, utilName, furtherAssertions = {}) => {
+  const nType = getType(n)
+  const { nonNegative, positive } = furtherAssertions
+
+  if (nType !== 'number') {
+    throw new Error(
+      `${utilName} requires argument '${argName}' to be an integer - but a ${nType} was passed`
+    )
+  }
+  if (nonNegative) {
+    const isNonNegative = Number.isInteger(n) && n >= 0
+    if (!isNonNegative) {
+      throw new Error(
+        `${utilName} requires argument '${argName}' to be an integer greater than or equal to zero - but ${n} was passed`
+      )
+    }
+  } else if (positive) {
+    const isPositive = Number.isInteger(n) && n > 0
+    if (!isPositive) {
+      throw new Error(
+        `${utilName} requires argument '${argName}' to be a positive integer - but ${n} was passed`
+      )
+    }
+  } else {
+    if (!Number.isInteger(n)) {
+      throw new Error(
+        `${utilName} requires argument '${argName}' to be an integer - but ${n} was passed`
+      )
+    }
+  }
+}
+
+export default assertArgIsInt

package/dist/assert-arg-is-one-of-type.cjs

@@ -0,0 +1,17 @@
+const aOrAn = require('./a-or-an.cjs')
+const getType = require('./get-type.cjs')
+const toEnglishList = require('./to-english-list.cjs')
+const containsType = require('./contains-type.cjs')
+
+const assertArgIsOneOfType = (arg, argName, expectedTypes, utilName) => {
+  const type = getType(arg)
+
+  if (!containsType(expectedTypes, type)) {
+    const expectedTypesStr = toEnglishList('or', expectedTypes)
+    throw new Error(
+      `${utilName} requires argument '${argName}' to be ${aOrAn(expectedTypesStr)} - but ${aOrAn(type)} was passed`
+    )
+  }
+}
+
+module.exports = assertArgIsOneOfType

package/dist/assert-arg-is-one-of-type.d.cts

@@ -0,0 +1,2 @@
+import { default as assertArgIsOneOfType } from '@common-fp/shared-internals-types/assert-arg-is-one-of-type'
+export = assertArgIsOneOfType

package/dist/assert-arg-is-one-of-type.d.ts

@@ -0,0 +1 @@
+export { default } from '@common-fp/shared-internals-types/assert-arg-is-one-of-type'

package/dist/assert-arg-is-one-of-type.mjs

@@ -0,0 +1,17 @@
+import aOrAn from './a-or-an.mjs'
+import getType from './get-type.mjs'
+import toEnglishList from './to-english-list.mjs'
+import containsType from './contains-type.mjs'
+
+const assertArgIsOneOfType = (arg, argName, expectedTypes, utilName) => {
+  const type = getType(arg)
+
+  if (!containsType(expectedTypes, type)) {
+    const expectedTypesStr = toEnglishList('or', expectedTypes)
+    throw new Error(
+      `${utilName} requires argument '${argName}' to be ${aOrAn(expectedTypesStr)} - but ${aOrAn(type)} was passed`
+    )
+  }
+}
+
+export default assertArgIsOneOfType

package/dist/assert-arg-is-type.cjs

@@ -0,0 +1,12 @@
+const getType = require('./get-type.cjs')
+
+const assertArgIsType = (arg, argName, expectedType, utilName) => {
+  const argType = getType(arg)
+
+  if (argType !== expectedType)
+    throw new Error(
+      `${utilName} requires argument '${argName}' to be a ${expectedType} - but a ${argType} was passed`
+    )
+}
+
+module.exports = assertArgIsType

package/dist/assert-arg-is-type.d.cts

@@ -0,0 +1,2 @@
+import { default as assertArgIsType } from '@common-fp/shared-internals-types/assert-arg-is-type'
+export = assertArgIsType

package/dist/assert-arg-is-type.d.ts

@@ -0,0 +1 @@
+export { default } from '@common-fp/shared-internals-types/assert-arg-is-type'

package/dist/assert-arg-is-type.mjs

@@ -0,0 +1,12 @@
+import getType from './get-type.mjs'
+
+const assertArgIsType = (arg, argName, expectedType, utilName) => {
+  const argType = getType(arg)
+
+  if (argType !== expectedType)
+    throw new Error(
+      `${utilName} requires argument '${argName}' to be a ${expectedType} - but a ${argType} was passed`
+    )
+}
+
+export default assertArgIsType

package/dist/assert-arg-shares-type-with.cjs

@@ -0,0 +1,12 @@
+const assertArgSharesTypeWith = argObj => {
+  const { argType, argName, sharedArgType, sharedArgName, utilName } = argObj
+
+  if (argType !== sharedArgType)
+    throw new Error(
+      `${utilName} requires the '${argName}' type to match '${sharedArgName}'.\n` +
+        `  ${sharedArgName} has type ${sharedArgType}\n` +
+        `  ${argName} has type ${argType}`
+    )
+}
+
+module.exports = assertArgSharesTypeWith

package/dist/assert-arg-shares-type-with.d.cts

@@ -0,0 +1,2 @@
+import { default as assertArgSharesTypeWith } from '@common-fp/shared-internals-types/assert-arg-shares-type-with'
+export = assertArgSharesTypeWith

package/dist/assert-arg-shares-type-with.d.ts

@@ -0,0 +1 @@
+export { default } from '@common-fp/shared-internals-types/assert-arg-shares-type-with'

package/dist/assert-arg-shares-type-with.mjs

@@ -0,0 +1,12 @@
+const assertArgSharesTypeWith = argObj => {
+  const { argType, argName, sharedArgType, sharedArgName, utilName } = argObj
+
+  if (argType !== sharedArgType)
+    throw new Error(
+      `${utilName} requires the '${argName}' type to match '${sharedArgName}'.\n` +
+        `  ${sharedArgName} has type ${sharedArgType}\n` +
+        `  ${argName} has type ${argType}`
+    )
+}
+
+export default assertArgSharesTypeWith

package/dist/assert-arg-type-is-one-of.cjs

@@ -0,0 +1,14 @@
+const aOrAn = require('./a-or-an.cjs')
+const toEnglishList = require('./to-english-list.cjs')
+const containsType = require('./contains-type.cjs')
+
+const assertArgTypeIsOneOf = (argType, argName, expectedTypes, utilName) => {
+  if (!containsType(expectedTypes, argType)) {
+    const expectedTypesStr = toEnglishList('or', expectedTypes)
+    throw new Error(
+      `${utilName} requires argument '${argName}' to be ${aOrAn(expectedTypesStr)} - but ${aOrAn(argType)} was passed`
+    )
+  }
+}
+
+module.exports = assertArgTypeIsOneOf

package/dist/assert-arg-type-is-one-of.d.cts

@@ -0,0 +1,2 @@
+import { default as assertArgTypeIsOneOf } from '@common-fp/shared-internals-types/assert-arg-type-is-one-of'
+export = assertArgTypeIsOneOf

package/dist/assert-arg-type-is-one-of.d.ts

@@ -0,0 +1 @@
+export { default } from '@common-fp/shared-internals-types/assert-arg-type-is-one-of'

package/dist/assert-arg-type-is-one-of.mjs

@@ -0,0 +1,14 @@
+import aOrAn from './a-or-an.mjs'
+import toEnglishList from './to-english-list.mjs'
+import containsType from './contains-type.mjs'
+
+const assertArgTypeIsOneOf = (argType, argName, expectedTypes, utilName) => {
+  if (!containsType(expectedTypes, argType)) {
+    const expectedTypesStr = toEnglishList('or', expectedTypes)
+    throw new Error(
+      `${utilName} requires argument '${argName}' to be ${aOrAn(expectedTypesStr)} - but ${aOrAn(argType)} was passed`
+    )
+  }
+}
+
+export default assertArgTypeIsOneOf

package/dist/common-types.cjs

@@ -0,0 +1,39 @@
+/**
+ * ReadonlySet is a quick naive solution to preventing downstream libs from
+ * mutating these values.  We can create a more robust solution if/when needed.
+ */
+
+class ReadonlySet extends Set {
+  constructor(iterable) {
+    super()
+    for (const el of iterable) super.add(el)
+  }
+
+  add() {
+    throw new Error('Cannot add to ReadonlySet')
+  }
+  clear() {
+    throw new Error('Cannot clear ReadonlySet')
+  }
+  delete() {
+    throw new Error('Cannot delete with ReadonlySet')
+  }
+}
+
+const collection = new ReadonlySet(['array', 'object', 'map', 'set'])
+const entryCollection = new ReadonlySet(['array', 'object', 'map'])
+const keyedCollection = new ReadonlySet(['object', 'map'])
+const objectKey = new ReadonlySet(['string', 'number'])
+const propertyKey = new ReadonlySet(['string', 'number', 'symbol'])
+const sequence = new ReadonlySet(['array', 'string'])
+const valueCollection = new ReadonlySet(['array', 'set'])
+
+module.exports = {
+  collection,
+  entryCollection,
+  keyedCollection,
+  objectKey,
+  propertyKey,
+  sequence,
+  valueCollection,
+}

package/dist/common-types.d.cts

@@ -0,0 +1,2 @@
+import * as commonTypes from '@common-fp/shared-internals-types/common-types'
+export = commonTypes

package/dist/common-types.d.ts

@@ -0,0 +1 @@
+export * from '@common-fp/shared-internals-types/common-types'

package/dist/common-types.mjs

@@ -0,0 +1,39 @@
+/**
+ * ReadonlySet is a quick naive solution to preventing downstream libs from
+ * mutating these values.  We can create a more robust solution if/when needed.
+ */
+
+class ReadonlySet extends Set {
+  constructor(iterable) {
+    super()
+    for (const el of iterable) super.add(el)
+  }
+
+  add() {
+    throw new Error('Cannot add to ReadonlySet')
+  }
+  clear() {
+    throw new Error('Cannot clear ReadonlySet')
+  }
+  delete() {
+    throw new Error('Cannot delete with ReadonlySet')
+  }
+}
+
+const collection = new ReadonlySet(['array', 'object', 'map', 'set'])
+const entryCollection = new ReadonlySet(['array', 'object', 'map'])
+const keyedCollection = new ReadonlySet(['object', 'map'])
+const objectKey = new ReadonlySet(['string', 'number'])
+const propertyKey = new ReadonlySet(['string', 'number', 'symbol'])
+const sequence = new ReadonlySet(['array', 'string'])
+const valueCollection = new ReadonlySet(['array', 'set'])
+
+export {
+  collection,
+  entryCollection,
+  keyedCollection,
+  objectKey,
+  propertyKey,
+  sequence,
+  valueCollection,
+}