@bemoje/cli 0.0.6 → 0.0.8

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

@@ -1,58 +0,0 @@
-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

@@ -1,21 +0,0 @@
-/**
- * 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

@@ -1,19 +0,0 @@
-/* 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

@@ -1,19 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

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

package/src/util/types/Any.ts

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

package/src/util/types/DeepArray.ts

@@ -1,12 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

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

package/src/util/types/JsonObject.ts

@@ -1,8 +0,0 @@
-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

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

package/src/util/types/JsonValue.ts

@@ -1,14 +0,0 @@
-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

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

package/src/util/types/TConstructor.ts

@@ -1,6 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

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

package/src/util/types/TPlainObject.ts

@@ -1,4 +0,0 @@
-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

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

package/src/util/types/TStringParser.ts

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

package/src/util/types/TValidator.ts

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

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

@@ -1,34 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

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

package/src/util/validation/isArray.ts

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

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

@@ -1,31 +0,0 @@
-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

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

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

@@ -1,54 +0,0 @@
-/* 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)
-    })
-  })
-})