@bemoje/cli 0.0.4 → 0.0.6

package/src/util/validation/isFunction.ts

@@ -0,0 +1,14 @@
+import type { TFunction } from '../types/TFunction'
+
+/**
+ * Checks if the given value is a function.
+ *
+ * @example ```ts
+ * isFunction(class {}); //=> true
+ * isFunction(function () {}); //=> true
+ * isFunction(() => {}); //=> true
+ * ```
+ */
+export function isFunction(value: unknown): value is TFunction {
+  return typeof value === 'function' && value !== Function.prototype
+}

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

@@ -0,0 +1,28 @@
+import { isNamedFunction } from './isNamedFunction'
+
+describe(isNamedFunction.name, () => {
+  describe('valid', () => {
+    it('named function', () => {
+      expect(isNamedFunction(function namedFunction() {})).toBe(true)
+    })
+
+    it('named arrow function', () => {
+      const arrowFunction = () => {}
+      expect(isNamedFunction(arrowFunction)).toBe(true)
+    })
+
+    it('constructor', () => {
+      expect(isNamedFunction(class Class {})).toBe(true)
+    })
+  })
+
+  describe('invalid', () => {
+    it('unnamed arrow function', () => {
+      expect(isNamedFunction(() => {})).toBe(false)
+    })
+
+    it('not a function', () => {
+      expect(isNamedFunction(1)).toBe(false)
+    })
+  })
+})

package/src/util/validation/isNamedFunction.ts

@@ -0,0 +1,8 @@
+import type { TFunction } from '../types/TFunction'
+
+/**
+ * Checks if the provided value is a named function.
+ */
+export function isNamedFunction(func: unknown): func is TFunction {
+  return typeof func === 'function' && !!func.name
+}

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

@@ -0,0 +1,14 @@
+import { isNamedFunctionArray } from './isNamedFunctionArray'
+
+describe(isNamedFunctionArray.name, () => {
+  describe('valid', () => {
+    it('named function array', () => {
+      expect(isNamedFunctionArray([function f() {}])).toBe(true)
+    })
+  })
+  describe('invalid', () => {
+    it('not named function array', () => {
+      expect(isNamedFunctionArray([() => {}])).toBe(false)
+    })
+  })
+})

package/src/util/validation/isNamedFunctionArray.ts

@@ -0,0 +1,5 @@
+import { isNamedFunction } from './isNamedFunction'
+
+export function isNamedFunctionArray(array: unknown): boolean {
+  return Array.isArray(array) && array.every(isNamedFunction)
+}

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

@@ -0,0 +1,57 @@
+import { isObject } from './isObject'
+
+describe(isObject.name, () => {
+  it('should return true for an object', () => {
+    expect(isObject({})).toBe(true)
+    expect(isObject({ key: 'value' })).toBe(true)
+  })
+
+  it('should return false for null', () => {
+    expect(isObject(null)).toBe(false)
+  })
+
+  it('should return false for undefined', () => {
+    expect(isObject(undefined)).toBe(false)
+  })
+
+  it('should return false for a number', () => {
+    expect(isObject(123)).toBe(false)
+  })
+
+  it('should return false for a string', () => {
+    expect(isObject('test')).toBe(false)
+  })
+
+  it('should return false for a boolean', () => {
+    expect(isObject(true)).toBe(false)
+    expect(isObject(false)).toBe(false)
+  })
+
+  it('should return false for an array', () => {
+    expect(isObject([])).toBe(false)
+    expect(isObject([1, 2, 3])).toBe(false)
+  })
+
+  it('should return false for a function', () => {
+    expect(isObject(() => 1)).toBe(false)
+  })
+
+  it('should be true when the value is an object.', function () {
+    expect(isObject({})).toBe(true)
+    expect(isObject(Object.create({}))).toBe(true)
+    expect(isObject(Object.create(Object.prototype))).toBe(true)
+    expect(isObject(Object.create(null))).toBe(true)
+    expect(isObject(/foo/)).toBe(true)
+    expect(isObject(new (class Foo {})())).toBe(true)
+  })
+
+  it('should be false when the value is not an object.', function () {
+    expect(isObject('whatever')).toBe(false)
+    expect(isObject(1)).toBe(false)
+    expect(isObject(function () {})).toBe(false)
+    expect(isObject([])).toBe(false)
+    expect(isObject(['foo', 'bar'])).toBe(false)
+    expect(isObject(undefined)).toBe(false)
+    expect(isObject(null)).toBe(false)
+  })
+})

package/src/util/validation/isObject.ts

@@ -0,0 +1,17 @@
+/**
+ * Checks if the provided value is an object (null, arrays and functions not included).
+ * @template T - The type of the value to check.
+ * @param value The value to check.
+ * @returns A boolean indicating whether the provided value is an object.
+ * @example ```ts
+ * isObject({});;
+ * //=> true
+ * isObject([1]);;
+ * //=> false
+ * isObject(123);;
+ * //=> false
+ * ```
+ */
+export function isObject(value: unknown): boolean {
+  return value != null && typeof value === 'object' && !Array.isArray(value)
+}

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

@@ -0,0 +1,21 @@
+import { isPlainObject } from './isPlainObject'
+
+describe(isPlainObject.name, () => {
+  it('should return `true` if the object is created by the `Object` constructor.', function () {
+    expect(isPlainObject(Object.create({}))).toBe(true)
+    expect(isPlainObject(Object.create(Object.prototype))).toBe(true)
+    expect(isPlainObject({ foo: 'bar' })).toBe(true)
+    expect(isPlainObject({})).toBe(true)
+    expect(isPlainObject(Object.create(null))).toBe(true)
+  })
+
+  it('should return `false` if the object is not created by the `Object` constructor.', function () {
+    expect(isPlainObject(/foo/)).toBe(false)
+    expect(isPlainObject(function () {})).toBe(false)
+    expect(isPlainObject(1)).toBe(false)
+    expect(isPlainObject(['foo', 'bar'])).toBe(false)
+    expect(isPlainObject([])).toBe(false)
+    expect(isPlainObject(new (class Foo {})())).toBe(false)
+    expect(isPlainObject(null)).toBe(false)
+  })
+})

package/src/util/validation/isPlainObject.ts

@@ -0,0 +1,14 @@
+import type { ObjectKey } from '../types/ObjectKey'
+import type { TPlainObject } from '../types/TPlainObject'
+/**
+ * Checks if the provided value is a plain object, i.e. an object created by the native base `Object` constructor.
+ */
+export function isPlainObject<K extends ObjectKey = ObjectKey, V = unknown>(
+  value: unknown
+): value is TPlainObject<K, V> {
+  if (Object.prototype.toString.call(value) !== '[object Object]') return false
+  if (!value?.constructor) return true
+  if (Object.prototype.toString.call(value.constructor.prototype) !== '[object Object]') return false
+  if (!Object.prototype.hasOwnProperty.call(value.constructor.prototype, 'isPrototypeOf')) return false
+  return true
+}

package/src/util/validation/isPrimitive.ts

@@ -0,0 +1,15 @@
+import type { TPrimitive } from '../types/TPrimitive'
+
+/**
+ * Checks if the provided value is a primitive type (null, undefined, bigint, boolean, number, string or symbol).
+ * @param value The value to check.
+ * @returns A boolean indicating whether the provided value is a primitive type.
+ * @example
+ * isPrimitive(123);
+ * //=> true
+ * isPrimitive({});
+ * //=> false
+ */
+export function isPrimitive(value: unknown): value is TPrimitive {
+  return (typeof value !== 'object' && typeof value !== 'function') || value === null
+}

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

@@ -0,0 +1,23 @@
+import { isString } from './isString'
+
+describe(isString.name, () => {
+  describe('valid', () => {
+    it('empty string', () => {
+      expect(isString('')).toBe(true)
+    })
+
+    it('string', () => {
+      expect(isString('hello')).toBe(true)
+    })
+  })
+
+  describe('invalid', () => {
+    it('non-string', () => {
+      expect(isString(true)).toBe(false)
+    })
+
+    it('string object', () => {
+      expect(isString(new String('hello'))).toBe(false)
+    })
+  })
+})

package/src/util/validation/isString.ts

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

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

@@ -0,0 +1,24 @@
+import { isStringArray } from './isStringArray'
+
+describe(isStringArray.name, () => {
+  describe('valid', () => {
+    it('string array', () => {
+      expect(isStringArray(['a'])).toBe(true)
+      expect(isStringArray(['a', 'b'])).toBe(true)
+    })
+
+    it('empty array', () => {
+      expect(isStringArray([])).toBe(true)
+    })
+  })
+
+  describe('invalid', () => {
+    it('not string array', () => {
+      expect(isStringArray([1, 2])).toBe(false)
+    })
+
+    it('not array', () => {
+      expect(isStringArray(new Set(['a']))).toBe(false)
+    })
+  })
+})

package/src/util/validation/isStringArray.ts

@@ -0,0 +1,8 @@
+import { isString } from './isString'
+
+/**
+ * Determine whether the input is a string array.
+ */
+export function isStringArray(value: unknown): value is string[] {
+  return Array.isArray(value) && value.every((v) => isString(v))
+}

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

@@ -0,0 +1,28 @@
+import { isStringWithNoSpacesOrDashes } from './isStringWithNoSpacesOrDashes'
+
+describe(isStringWithNoSpacesOrDashes.name, () => {
+  it('should return true if the value is a string with no spaces or dashes', () => {
+    expect(isStringWithNoSpacesOrDashes('hello')).toBe(true)
+    expect(isStringWithNoSpacesOrDashes('helloworld')).toBe(true)
+    expect(isStringWithNoSpacesOrDashes('hello123')).toBe(true)
+  })
+
+  it('should return false if the value is not a string', () => {
+    expect(isStringWithNoSpacesOrDashes(123)).toBe(false)
+    expect(isStringWithNoSpacesOrDashes(true)).toBe(false)
+    expect(isStringWithNoSpacesOrDashes(null)).toBe(false)
+    expect(isStringWithNoSpacesOrDashes(undefined)).toBe(false)
+    expect(isStringWithNoSpacesOrDashes({})).toBe(false)
+    expect(isStringWithNoSpacesOrDashes([])).toBe(false)
+  })
+
+  it('should return false if the value is a string with spaces', () => {
+    expect(isStringWithNoSpacesOrDashes('hello world')).toBe(false)
+    expect(isStringWithNoSpacesOrDashes('hello world 123')).toBe(false)
+  })
+
+  it('should return false if the value is a string with dashes', () => {
+    expect(isStringWithNoSpacesOrDashes('hello-world')).toBe(false)
+    expect(isStringWithNoSpacesOrDashes('hello-world-123')).toBe(false)
+  })
+})

package/src/util/validation/isStringWithNoSpacesOrDashes.ts

@@ -0,0 +1,5 @@
+import { isString } from './isString'
+
+export function isStringWithNoSpacesOrDashes(value: unknown) {
+  return isString(value) && /^[^\s-]+$/i.test(value)
+}

package/src/util/validation/numbers/isInteger.test.ts

@@ -0,0 +1,25 @@
+import { isInteger } from './isInteger'
+
+describe('isInteger', () => {
+  it('should return true for integer values', () => {
+    expect(isInteger(0)).toBe(true)
+    expect(isInteger(1)).toBe(true)
+    expect(isInteger(-1)).toBe(true)
+    expect(isInteger(1234567890)).toBe(true)
+  })
+
+  it('should return false for non-integer values', () => {
+    expect(isInteger(0.1)).toBe(false)
+    expect(isInteger(-0.1)).toBe(false)
+    expect(isInteger(Math.PI)).toBe(false)
+  })
+
+  it('should return false for NaN', () => {
+    expect(isInteger(NaN)).toBe(false)
+  })
+
+  it('should return false for Infinity', () => {
+    expect(isInteger(Infinity)).toBe(false)
+    expect(isInteger(-Infinity)).toBe(false)
+  })
+})

package/src/util/validation/numbers/isInteger.ts

@@ -0,0 +1,13 @@
+/**
+ * Checks if the provided number is an integer.
+ * @remarks This function uses the built-in `Number.isInteger` method.
+ * @param int The number to check.
+ * @returns A boolean indicating whether the provided number is an integer.
+ * @example ```ts
+ * isInteger(5);
+ * //=> true
+ * isInteger(5.5);
+ * //=> false
+ * ```
+ */
+export const isInteger = Number.isInteger

package/src/util/validation/numbers/isValidNumber.test.ts

@@ -0,0 +1,20 @@
+import { isValidNumber } from './isValidNumber'
+
+describe('isValidNumber', () => {
+  it('should return true for valid numbers', () => {
+    expect(isValidNumber(0)).toBe(true)
+    expect(isValidNumber(123)).toBe(true)
+    expect(isValidNumber(-123)).toBe(true)
+    expect(isValidNumber(1.23)).toBe(true)
+    expect(isValidNumber(-1.23)).toBe(true)
+  })
+
+  it('should return false for Infinity', () => {
+    expect(isValidNumber(Infinity)).toBe(false)
+    expect(isValidNumber(-Infinity)).toBe(false)
+  })
+
+  it('should return false for NaN', () => {
+    expect(isValidNumber(NaN)).toBe(false)
+  })
+})

package/src/util/validation/numbers/isValidNumber.ts

@@ -0,0 +1,17 @@
+/**
+ * Checks if the provided value is a valid number.
+ * @remarks This function checks if the provided value is a finite number and not NaN.
+ * @param number The value to check.
+ * @returns A boolean indicating whether the provided value is a valid number.
+ * @example ```ts
+ * isValidNumber(123);
+ * //=> true
+ * isValidNumber(NaN);
+ * //=> false
+ * isValidNumber(Infinity);
+ * //=> false
+ * ```
+ */
+export function isValidNumber(number: number): boolean {
+  return isFinite(number) && !isNaN(number)
+}

package/tsconfig.json

@@ -0,0 +1,32 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "module": "CommonJS",
+    "target": "ES2022",
+    "strict": true,
+    "verbatimModuleSyntax": false,
+    "declaration": true,
+    "sourceMap": true,
+    "declarationMap": true,
+    "sourceRoot": "src",
+
+    // "module": "commonjs",
+    "forceConsistentCasingInFileNames": true,
+    "disableSourceOfProjectReferenceRedirect": true,
+    // "strict": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,18 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "declaration": true,
+    "types": [
+      "node"
+    ]
+  },
+  "include": [
+    "src/**/*.ts"
+  ],
+  "exclude": [
+    "jest.config.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.ts"
+  ]
+}

package/tsconfig.spec.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "module": "commonjs",
+    "types": ["jest", "node"],
+    "lib": ["ES2022", "DOM"]
+  },
+  "include": ["jest.config.ts", "src/**/*.test.ts", "src/**/*.spec.ts", "src/**/*.d.ts"]
+}

package/index.cjs.d.ts

@@ -1 +0,0 @@
-export * from "./src\\index";