@bemoje/cli 0.0.4 → 0.0.6

package/src/util/string-parsers/createBooleanParser.test.ts

@@ -0,0 +1,58 @@
+import { createBooleanParser } from './createBooleanParser'
+
+describe(createBooleanParser.name, () => {
+  it('should return a function', () => {
+    const parseBoolean = createBooleanParser()
+    expect(typeof parseBoolean).toBe('function')
+  })
+
+  describe('parseBoolean', () => {
+    it('should return true for true values', () => {
+      const parseBoolean = createBooleanParser()
+      expect(parseBoolean('TRUE')).toBe(true)
+      expect(parseBoolean('T')).toBe(true)
+      expect(parseBoolean('YES')).toBe(true)
+      expect(parseBoolean('Y')).toBe(true)
+      expect(parseBoolean('1')).toBe(true)
+    })
+
+    it('should return false for false values', () => {
+      const parseBoolean = createBooleanParser()
+      expect(parseBoolean('')).toBe(false)
+      expect(parseBoolean('FALSE')).toBe(false)
+      expect(parseBoolean('F')).toBe(false)
+      expect(parseBoolean('NO')).toBe(false)
+      expect(parseBoolean('N')).toBe(false)
+      expect(parseBoolean('0')).toBe(false)
+    })
+
+    it('should throw for unknown values', () => {
+      const parseBoolean = createBooleanParser()
+      expect(() => parseBoolean('UNKNOWN')).toThrow()
+    })
+
+    it('should return true for custom true values', () => {
+      const parseBoolean = createBooleanParser(['ON', 'ENABLED'])
+      expect(parseBoolean('ON')).toBe(true)
+      expect(parseBoolean('ENABLED')).toBe(true)
+    })
+
+    it('should return false for custom false values', () => {
+      const parseBoolean = createBooleanParser([], ['OFF', 'DISABLED'])
+      expect(parseBoolean('OFF')).toBe(false)
+      expect(parseBoolean('DISABLED')).toBe(false)
+    })
+
+    it('should throw for invalid values', () => {
+      const parseBoolean = createBooleanParser()
+      expect(() => parseBoolean('INVALID')).toThrow()
+    })
+
+    it('should include accepted values in the error message', () => {
+      const parseBoolean = createBooleanParser(['ON', 'ENABLED'], ['OFF', 'DISABLED'])
+      expect(() => parseBoolean('INVALID')).toThrowError(
+        'The value INVALID is not a valid boolean value. Accepted values are: ON, ENABLED, OFF, DISABLED'
+      )
+    })
+  })
+})

package/src/util/string-parsers/createBooleanParser.ts

@@ -0,0 +1,21 @@
+/**
+ * Creates a parser function that parses a string into a boolean.
+ *
+ * @param trueValues - An array of strings that are considered true. Defaults to ['TRUE', 'T', 'YES', 'Y', '1'].
+ * @param falseValues - An array of strings that are considered false. Defaults to ['', 'FALSE', 'F', 'NO', 'N', '0'].
+ */
+export function createBooleanParser(
+  trueValues: string[] = ['TRUE', 'T', 'YES', 'Y', '1'],
+  falseValues: string[] = ['', 'FALSE', 'F', 'NO', 'N', '0']
+): (string: string) => boolean {
+  return function parseBoolean(string: string): boolean {
+    string = string.toUpperCase()
+    if (falseValues.includes(string)) return false
+    if (trueValues.includes(string)) return true
+    throw new TypeError(
+      `The value ${string} is not a valid boolean value. Accepted values are: ${[...trueValues, ...falseValues].join(
+        ', '
+      )}`
+    )
+  }
+}

package/src/util/string-parsers/createTypedListParser.test.ts

@@ -0,0 +1,19 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { createTypedListParser } from './createTypedListParser'
+import { parseInteger } from './parseInteger'
+
+describe(createTypedListParser.name, () => {
+  const parse = createTypedListParser<number>(',', parseInteger)
+
+  it('should parse a delimited string into a list of typed values using the provided parser', () => {
+    expect(parse('1,2,3')).toEqual([1, 2, 3])
+  })
+
+  it('should trim whitespace from each value in the string', () => {
+    expect(parse(' 1, 2,3 ')).toEqual([1, 2, 3])
+  })
+
+  it('should throw on an empty string', () => {
+    expect(() => parse('')).toThrow()
+  })
+})

package/src/util/string-parsers/createTypedListParser.ts

@@ -0,0 +1,19 @@
+import type { TStringParser } from '../types/TStringParser'
+
+/**
+ * Creates a parser function that parses a delimited string into a list of typed values.
+ * The parser function takes a string and returns an array of typed values.
+ *
+ * @param delimiter - The delimiter used to split the string into individual values.
+ * @param parser - The function used to parse each individual value in the string.
+ * @returns A function that takes a delimited string and returns an array of typed values.
+ * @template T - The type of the values in the list.
+ */
+export function createTypedListParser<T>(delimiter: string, parser: TStringParser<T>): TStringParser<T[]> {
+  return function parseList(string: string) {
+    return string
+      .split(delimiter)
+      .map((str) => str.trim())
+      .map(parser)
+  }
+}

package/src/util/string-parsers/parseBoolean.test.ts

@@ -0,0 +1,30 @@
+import { parseBoolean } from './parseBoolean'
+
+describe(parseBoolean.name, () => {
+  describe('when input is a valid true value', () => {
+    it('should return true', () => {
+      expect(parseBoolean('TRUE')).toBe(true)
+      expect(parseBoolean('T')).toBe(true)
+      expect(parseBoolean('YES')).toBe(true)
+      expect(parseBoolean('Y')).toBe(true)
+      expect(parseBoolean('1')).toBe(true)
+    })
+  })
+
+  describe('when input is a valid false value', () => {
+    it('should return false', () => {
+      expect(parseBoolean('FALSE')).toBe(false)
+      expect(parseBoolean('F')).toBe(false)
+      expect(parseBoolean('NO')).toBe(false)
+      expect(parseBoolean('N')).toBe(false)
+      expect(parseBoolean('0')).toBe(false)
+    })
+  })
+
+  describe('when input is not a valid input', () => {
+    it('should throw', () => {
+      expect(() => parseBoolean('')).toThrow()
+      expect(() => parseBoolean('invalid')).toThrow()
+    })
+  })
+})

package/src/util/string-parsers/parseBoolean.ts

@@ -0,0 +1,12 @@
+import { createBooleanParser } from './createBooleanParser'
+
+/**
+ * Parses a string into a boolean.
+ *
+ * Accepted values (case insensitive):
+ * - true: 'TRUE', 'T', 'YES', 'Y', '1'
+ * - false: 'FALSE', 'F', 'NO', 'N', '0'
+ *
+ * @throws Will throw an error if the input string is not a valid input.
+ */
+export const parseBoolean = createBooleanParser(['TRUE', 'T', 'YES', 'Y', '1'], ['FALSE', 'F', 'NO', 'N', '0'])

package/src/util/string-parsers/parseInteger.test.ts

@@ -0,0 +1,52 @@
+import { parseInteger } from './parseInteger'
+
+describe(parseInteger.name, () => {
+  describe('valid', () => {
+    it('zero', () => {
+      expect(parseInteger('0')).toBe(0)
+    })
+
+    it('N', () => {
+      expect(parseInteger('3')).toBe(3)
+      expect(parseInteger('-3')).toBe(-3)
+    })
+
+    it('spaces', () => {
+      expect(parseInteger('1, 215')).toBe(1215)
+    })
+
+    it('thousand separator', () => {
+      expect(parseInteger('1,000,215')).toBe(1000215)
+    })
+
+    it('units', () => {
+      expect(parseInteger('$12')).toBe(12)
+    })
+  })
+
+  describe('throw on invalid', () => {
+    it('R', () => {
+      expect(() => parseInteger('3.1')).toThrow()
+    })
+
+    it('Infinity', () => {
+      expect(() => parseInteger('Infinity')).toThrow()
+    })
+
+    it('-Infinity', () => {
+      expect(() => parseInteger('-Infinity')).toThrow()
+    })
+
+    it('NaN', () => {
+      expect(() => parseInteger('NaN')).toThrow()
+    })
+
+    it('empty string', () => {
+      expect(() => parseInteger('')).toThrow()
+    })
+
+    it('alpha', () => {
+      expect(() => parseInteger('asdf')).toThrow()
+    })
+  })
+})

package/src/util/string-parsers/parseInteger.ts

@@ -0,0 +1,9 @@
+export function parseInteger(string: string): number {
+  const errMsg = 'Not an integer. Got: '
+  if (string.includes('.')) throw new TypeError(errMsg + string)
+  string = string.replace(/[^-0-9]/g, '')
+  if (!string) throw new TypeError(errMsg + string)
+  const int = parseInt(string)
+  if (isNaN(int)) throw new TypeError(errMsg + string)
+  return int
+}

package/src/util/string-parsers/parseNumber.test.ts

@@ -0,0 +1,53 @@
+import { parseNumber } from './parseNumber'
+
+describe(parseNumber.name, () => {
+  describe('valid', () => {
+    it('zero', () => {
+      expect(parseNumber('0')).toBe(0)
+    })
+
+    it('N', () => {
+      expect(parseNumber('3')).toBe(3)
+      expect(parseNumber('-3')).toBe(-3)
+    })
+
+    it('R', () => {
+      expect(parseNumber('3.1')).toBe(3.1)
+      expect(parseNumber('-3.1')).toBe(-3.1)
+    })
+
+    it('Infinity', () => {
+      expect(parseNumber('Infinity')).toBe(Infinity)
+    })
+
+    it('-Infinity', () => {
+      expect(parseNumber('-Infinity')).toBe(-Infinity)
+    })
+
+    it('NaN', () => {
+      expect(parseNumber('NaN')).toBe(NaN)
+    })
+
+    it('spaces', () => {
+      expect(parseNumber('1. 215')).toBe(1.215)
+    })
+
+    it('thousand separator', () => {
+      expect(parseNumber('1,000,215.25')).toBe(1000215.25)
+    })
+
+    it('units', () => {
+      expect(parseNumber('$12')).toBe(12)
+    })
+  })
+
+  describe('invalid', () => {
+    it('empty string', () => {
+      expect(parseNumber('')).toBe(NaN)
+    })
+
+    it('alpha', () => {
+      expect(parseNumber('asdf')).toBe(NaN)
+    })
+  })
+})

package/src/util/string-parsers/parseNumber.ts

@@ -0,0 +1,6 @@
+export function parseNumber(string: string): number {
+  if (string.endsWith('Infinity')) return Number(string)
+  string = string.replace(/[^-0-9.]/g, '')
+  if (!string) return NaN
+  return Number(string)
+}

package/src/util/string-parsers/parseString.test.ts

@@ -0,0 +1,7 @@
+import { parseString } from './parseString'
+
+describe(parseString.name, () => {
+  it('should return the string untouched', () => {
+    expect(parseString('foo')).toBe('foo')
+  })
+})

package/src/util/string-parsers/parseString.ts

@@ -0,0 +1,3 @@
+export function parseString<O = string>(string: string): O {
+  return string as O
+}

package/src/util/types/Any.ts

@@ -0,0 +1,2 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type Any = any

package/src/util/types/DeepArray.ts

@@ -0,0 +1,12 @@
+import type { DeepObject } from './DeepObject'
+import type { ObjectKey } from './ObjectKey'
+
+/**
+ * Recursively defined array that can contain objects+arrays with values of a given type V.
+ */
+export type DeepArray<V, K extends ObjectKey = string | symbol> = Array<V | DeepObject<V, K> | DeepArray<V, K>> | []
+
+/**
+ * Recursively defined array that can contain only arrays (excl. objects) with values of a given type V.
+ */
+export type StrictlyDeepArray<V> = Array<V | StrictlyDeepArray<V>>

package/src/util/types/DeepObject.ts

@@ -0,0 +1,16 @@
+import type { DeepArray } from './DeepArray'
+import type { ObjectKey } from './ObjectKey'
+
+/**
+ * Recursively defined object with objects+arrays with values of a given type V.
+ */
+export type DeepObject<V, K extends ObjectKey = string | symbol> = {
+  [_ in K]?: V | DeepObject<V, K> | DeepArray<V, K>
+}
+
+/**
+ * Recursively defined array that can contain only objects (excl. arrays) with values of a given type V.
+ */
+export type StrictlyDeepObject<V, K extends string | symbol = string | symbol> = {
+  [_ in K]?: V | StrictlyDeepObject<V, K>
+}

package/src/util/types/JsonArray.ts

@@ -0,0 +1,8 @@
+import type { DeepArray } from './DeepArray'
+import type { JsonRawPrimitive } from './JsonRawPrimitive'
+
+/**
+ * Return-type of parsed JSON array.
+ */
+
+export type JsonArray<P extends JsonRawPrimitive = JsonRawPrimitive> = DeepArray<P, string> | P[]

package/src/util/types/JsonDefinedPrimitive.ts

@@ -0,0 +1,5 @@
+/**
+ * All supported defined (!= null) primitive types in JSON.
+ */
+
+export type JsonDefinedPrimitive = string | number | boolean

package/src/util/types/JsonObject.ts

@@ -0,0 +1,8 @@
+import type { DeepObject } from './DeepObject'
+import type { JsonRawPrimitive } from './JsonRawPrimitive'
+
+/**
+ * Return-type of parsed JSON object.
+ */
+
+export type JsonObject<P extends JsonRawPrimitive = JsonRawPrimitive> = DeepObject<P, string> | Record<string, P>

package/src/util/types/JsonRawPrimitive.ts

@@ -0,0 +1,7 @@
+import type { JsonDefinedPrimitive } from './JsonDefinedPrimitive'
+
+/**
+ * All supported primitive types in JSON.
+ */
+
+export type JsonRawPrimitive = null | JsonDefinedPrimitive

package/src/util/types/JsonValue.ts

@@ -0,0 +1,14 @@
+import type { JsonArray } from './JsonArray'
+import type { JsonObject } from './JsonObject'
+import type { JsonRawPrimitive } from './JsonRawPrimitive'
+
+/**
+ * Any JSON value. Any JSON.parse() return value.
+ */
+
+export type JsonValue<P extends JsonRawPrimitive = JsonRawPrimitive> =
+  | P
+  | JsonObject<P>
+  | JsonArray<P>
+  | P[]
+  | Record<string, P>

package/src/util/types/ObjectKey.ts

@@ -0,0 +1 @@
+export type ObjectKey = string | number | symbol

package/src/util/types/TConstructor.ts

@@ -0,0 +1,6 @@
+import type { Any } from './Any'
+
+/**
+ * This type represents a constructor function. It is a function that can be called with the `new` keyword to create an instance of a certain type.
+ */
+export type TConstructor<R = Any, A extends Any[] = Any[]> = new (...args: A) => R

package/src/util/types/TFunction.ts

@@ -0,0 +1,5 @@
+import type { Any } from './Any'
+import type { TConstructor } from './TConstructor'
+import type { TFunctionNoNew } from './TFunctionNoNew'
+
+export type TFunction<R = Any, A extends Any[] = Any[]> = TConstructor<R, A> | TFunctionNoNew<R, A>

package/src/util/types/TFunctionNoNew.ts

@@ -0,0 +1,3 @@
+import type { Any } from './Any'
+
+export type TFunctionNoNew<R = Any, A extends Any[] = Any[]> = (...args: A) => R

package/src/util/types/TPlainObject.ts

@@ -0,0 +1,4 @@
+import type { ObjectKey } from './ObjectKey'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type TPlainObject<K extends ObjectKey = ObjectKey, V = any> = Record<K, V>

package/src/util/types/TPrimitive.ts

@@ -0,0 +1 @@
+export type TPrimitive = null | undefined | bigint | boolean | number | string | symbol

package/src/util/types/TStringParser.ts

@@ -0,0 +1 @@
+export type TStringParser<T> = (value: string) => T

package/src/util/types/TValidator.ts

@@ -0,0 +1,3 @@
+import type { Any } from './Any'
+
+export type TValidator<T = Any> = (value: T) => boolean

package/src/util/validation/createTypedArrayValidator.test.ts

@@ -0,0 +1,34 @@
+import { createTypedArrayValidator } from './createTypedArrayValidator'
+import { isString } from './isString'
+
+describe(createTypedArrayValidator.name, () => {
+  const isLengthOf2 = (value: unknown) => (value as string).length === 2
+  const isValid = createTypedArrayValidator([isLengthOf2, isString])
+
+  it('should return true for valid arrays', () => {
+    expect(isValid(['ab'])).toBe(true)
+    expect(isValid(['ab', 'cd'])).toBe(true)
+  })
+
+  it('should return false for invalid arrays', () => {
+    expect(isValid(['a'])).toBe(false)
+    expect(isValid(['ab', 'c'])).toBe(false)
+  })
+
+  it('should have the default name if none provided', () => {
+    expect(isValid.name).toBe('isArrayWhereEachIsLengthOf2AndIsString')
+  })
+
+  it('should have the given name if provided', () => {
+    const isValid = createTypedArrayValidator([isLengthOf2, isString], 'isArrOfLength2Strings')
+    expect(isValid.name).toBe('isArrOfLength2Strings')
+  })
+
+  it('should throw if no name provided and not all validators are named functions', () => {
+    expect(() => createTypedArrayValidator([() => true])).toThrow()
+  })
+
+  it('should not throw if a name provided but not all validators are named functions', () => {
+    expect(() => createTypedArrayValidator([() => true], 'isAnything')).not.toThrow()
+  })
+})

package/src/util/validation/createTypedArrayValidator.ts

@@ -0,0 +1,25 @@
+import { ensureThat } from './ensureThat'
+import { funSetName } from '../function/funSetName'
+import { isNamedFunctionArray } from './isNamedFunctionArray'
+import { strFirstCharToUpperCase } from '../string/strFirstCharToUpperCase'
+
+/**
+ * Creates a validator function that checks whether the input is an array where all elements are valid according to every validator provided.
+ *
+ * @param validators - An array of validator functions.
+ * @param name - The name of the validator function. If not provided, the name will be derived from the validator functions.
+ *
+ * @throws TypeError - if no name is provided and not all validators are named functions.
+ */
+export function createTypedArrayValidator<O>(
+  validators: ((value: O) => boolean)[],
+  name?: string
+): (array: unknown) => boolean {
+  if (!name) {
+    ensureThat(validators, isNamedFunctionArray)
+    name = 'isArrayWhereEach' + validators.map((fun) => strFirstCharToUpperCase(fun.name)).join('And')
+  }
+  return funSetName(name, function (array: unknown): boolean {
+    return Array.isArray(array) && array.every((value) => validators.every((isValid) => isValid(value)))
+  })
+}

package/src/util/validation/ensureThat.test.ts

@@ -0,0 +1,37 @@
+import { ensureThat } from './ensureThat'
+
+describe(ensureThat.name, () => {
+  it('should validate with validator that returns boolean', () => {
+    const isPositive = (n: number) => n >= 0
+    try {
+      ensureThat(-5, isPositive)
+    } catch (error) {
+      const err = error as Error
+      expect(err).toBeInstanceOf(Error)
+      expect(err.message).toBe(`Expected '${isPositive.name}'. Got: -5`)
+    }
+  })
+  it('should validate with validator that returns boolean or string', () => {
+    const isPositive = (n: number) => (n >= 0 ? true : 'Not positive')
+    try {
+      ensureThat(-5, isPositive)
+    } catch (error) {
+      const err = error as Error
+      expect(err).toBeInstanceOf(Error)
+      expect(err.message).toBe(`Not positive. Got: -5`)
+    }
+  })
+  it('should throw the provided error type', () => {
+    const isPositive = (n: number) => (n >= 0 ? true : 'Not positive')
+    try {
+      ensureThat(-5, isPositive, { Err: TypeError })
+    } catch (error) {
+      expect(error).toBeInstanceOf(TypeError)
+    }
+  })
+  it('should validate correctly using additional args', () => {
+    const isLargerThan = (n: number, min: number) => n > min
+    expect(() => ensureThat(5, isLargerThan, { args: [3] })).not.toThrow()
+    expect(() => ensureThat(5, isLargerThan, { args: [7] })).toThrow()
+  })
+})

package/src/util/validation/ensureThat.ts

@@ -0,0 +1,14 @@
+import type { Any } from '../types/Any'
+import type { TConstructor } from '../types/TConstructor'
+
+export function ensureThat<T>(
+  value: T,
+  validator: ((value: T, ...args: any[]) => boolean | string) | ((value: T, ...args: any[]) => boolean),
+  options: { Err?: TConstructor; args?: Any[] } = {}
+): T {
+  const result = validator(value, ...(options.args ?? []))
+  if (result === true) return value
+  const message =
+    typeof result === 'string' ? `${result}. Got: ${value}` : `Expected '${validator.name}'. Got: ${value}`
+  throw new (options.Err ?? Error)(message)
+}

package/src/util/validation/isArray.test.ts

@@ -0,0 +1,7 @@
+import { isArray } from './isArray'
+
+describe(isArray.name, () => {
+  it('should be Array.isArray', () => {
+    expect(isArray).toBe(Array.isArray)
+  })
+})

package/src/util/validation/isArray.ts

@@ -0,0 +1 @@
+export const isArray = Array.isArray

package/src/util/validation/isBoolean.test.ts

@@ -0,0 +1,31 @@
+import { isBoolean } from './isBoolean'
+
+describe(isBoolean.name, () => {
+  describe('valid', () => {
+    it('true', () => {
+      expect(isBoolean(true)).toBe(true)
+    })
+
+    it('false', () => {
+      expect(isBoolean(false)).toBe(true)
+    })
+  })
+
+  describe('invalid', () => {
+    it('null', () => {
+      expect(isBoolean(null)).toBe(false)
+    })
+
+    it('undefined', () => {
+      expect(isBoolean(undefined)).toBe(false)
+    })
+
+    it('zero', () => {
+      expect(isBoolean(0)).toBe(false)
+    })
+
+    it('empty string', () => {
+      expect(isBoolean('')).toBe(false)
+    })
+  })
+})

package/src/util/validation/isBoolean.ts

@@ -0,0 +1,3 @@
+export function isBoolean(value: unknown): value is boolean {
+  return typeof value === 'boolean'
+}

package/src/util/validation/isFunction.test.ts

@@ -0,0 +1,54 @@
+/* eslint-disable @typescript-eslint/no-empty-function */
+import { isFunction } from './isFunction'
+
+describe(isFunction.name, () => {
+  describe('true', () => {
+    it('class constructor', () => {
+      expect(isFunction(class {})).toBe(true)
+    })
+
+    it('new Function()', () => {
+      expect(isFunction(new Function())).toBe(true)
+    })
+
+    it('built-in constructors', () => {
+      expect(isFunction(Function)).toBe(true)
+      expect(isFunction(Array)).toBe(true)
+    })
+
+    it('named function', () => {
+      expect(isFunction(function () {})).toBe(true)
+    })
+
+    it('arrow function', () => {
+      expect(isFunction(() => {})).toBe(true)
+    })
+
+    it('bound constructors', function () {
+      const clazz = { method() {} }
+      clazz.method = clazz.method.bind(clazz)
+      expect(isFunction(clazz.method)).toBe(true)
+    })
+
+    it('function with prototype not being a prototype-object', () => {
+      function Test() {}
+      Test.prototype = {}
+      expect(isFunction(Test)).toBe(true)
+    })
+  })
+
+  describe('false', () => {
+    it('prototype objects', () => {
+      expect(isFunction(Function.prototype)).toBe(false)
+      expect(isFunction(Array.prototype)).toBe(false)
+    })
+
+    it('primitives', () => {
+      expect(isFunction(null)).toBe(false)
+      expect(isFunction(undefined)).toBe(false)
+      expect(isFunction(1)).toBe(false)
+      expect(isFunction('string')).toBe(false)
+      expect(isFunction(false)).toBe(false)
+    })
+  })
+})