@megaorm/test

MegaORM Test

This package is designed to assist developers in type checking and validation for various JavaScript values. It provides a collection of type-checking functions, and utilities to validate your values.

Table of Contents

• Type Functions
• Pattern Functions
• Content Functions

Type Functions

Type functions allow you to validate the type of a value. They return a boolean indicating whether the value matches the expected type.

• isSet(value: any): boolean Checks if a value is an instance of Set.

  console.log(isSet(new Set())); // true
  console.log(isSet([])); // false
  

• isMap(value: any): boolean Checks if a value is an instance of Map.

  console.log(isMap(new Map())); // true
  console.log(isMap({})); // false
  

• isWeakSet(value: any): boolean Checks if a value is an instance of WeakSet.

  console.log(isWeakSet(new WeakSet())); // true
  console.log(isWeakSet(new Set())); // false
  

• isWeakMap(value: any): boolean Checks if a value is an instance of WeakMap.

  console.log(isWeakMap(new WeakMap())); // true
  console.log(isWeakMap(new Map())); // false
  

• isArr(value: any): boolean Checks if a value is an array.

  console.log(isArr([])); // true
  console.log(isArr({})); // false
  

• isObj(value: any): boolean Checks if a value is a non-null object (excluding arrays).

  console.log(isObj({})); // true
  console.log(isObj([])); // false
  console.log(isObj(null)); // false
  

• isNum(value: any): boolean Checks if a value is a number.

  console.log(isNum(42)); // true
  console.log(isNum('42')); // false
  

• isTxt(value: any): boolean Checks if a value is a string.

  console.log(isTxt('hello')); // true
  console.log(isTxt(42)); // false
  

• isStr(value: any): boolean Alias for isTxt. Checks if a value is a string.

  console.log(isStr('hello')); // true
  console.log(isStr(42)); // false
  

• isBool(value: any): boolean Checks if a value is a boolean.

  console.log(isBool(true)); // true
  console.log(isBool('true')); // false
  

• isFunc(value: any): boolean Checks if a value is a function.

  console.log(isFunc(() => {})); // true
  console.log(isFunc({})); // false
  

• isSymbol(value: any): boolean Checks if a value is a symbol.

  console.log(isSymbol(Symbol())); // true
  console.log(isSymbol('symbol')); // false
  

• isInt(value: any): boolean Checks if a value is an integer.

  console.log(isInt(42)); // true
  console.log(isInt(42.42)); // false
  

• isFloat(value: any): boolean Checks if a value is a floating-point number.

  console.log(isFloat(42.42)); // true
  console.log(isFloat(42)); // false
  

• isNan(value: any): boolean Checks if a value is NaN (Not a Number).

  console.log(isNan(NaN)); // true
  console.log(isNan(42)); // false
  

• isNull(value: any): boolean Checks if a value is null.

  console.log(isNull(null)); // true
  console.log(isNull(undefined)); // false
  

• isUndefined(value: any): boolean Checks if a value is undefined.

  console.log(isUndefined(undefined)); // true
  console.log(isUndefined(null)); // false
  

• isDefined(value: any): boolean Checks if a value is defined (not undefined).

  console.log(isDefined(42)); // true
  console.log(isDefined(undefined)); // false
  

• isDefinedStrict(value: any): boolean Strictly checks if a value is defined (not null, undefined, or NaN).

  console.log(isDefinedStrict(42)); // true
  console.log(isDefinedStrict(null)); // false
  console.log(isDefinedStrict(NaN)); // false
  console.log(isDefinedStrict(undefined)); // false
  

• isInf(value: any): boolean Checks if a value is Infinity.

  console.log(isInf(Infinity)); // true
  console.log(isInf(42)); // false
  

• isFinite(value: any): boolean Checks if a value is a finite number.

  console.log(isFinite(42)); // true
  console.log(isFinite(Infinity)); // false
  

• isTruthy(value: any): boolean Checks if a value is truthy (not falsy).

  console.log(isTruthy(1)); // true
  console.log(isTruthy(0)); // false
  

• isFalsy(value: any): boolean Checks if a value is falsy (false, 0, "", null, undefined, or NaN).

  console.log(isFalsy(0)); // true
  console.log(isFalsy(1)); // false
  

• isFalse(value: any): boolean Checks if a value is strictly false.

  console.log(isFalse(false)); // true
  console.log(isFalse(true)); // false
  

• isTrue(value: any): boolean Checks if a value is strictly true.

  console.log(isTrue(true)); // true
  console.log(isTrue(false)); // false
  

• isIterable(value: any): boolean Checks if a value is iterable (has an Symbol.iterator property).

  console.log(isIterable([1, 2, 3])); // true
  console.log(isIterable(42)); // false
  

• isEven(value: any): boolean Checks if a number is even.

  console.log(isEven(42)); // true
  console.log(isEven(43)); // false
  

• isOdd(value: any): boolean Checks if a number is odd.

  console.log(isOdd(43)); // true
  console.log(isOdd(42)); // false
  

• isError(value: any): boolean Checks if a value is an instance of the Error object.

  console.log(isError(new Error())); // true
  console.log(isError('Error')); // false
  

• isChildOf(child: any, parent: any): boolean Checks if an object is a child of the given class (instanceof).

  class Parent {}
  const child = new Parent();
  console.log(isChildOf(child, Parent)); // true
  

• isClass(value: any): boolean Checks if a value is a class (constructor function).

  console.log(isClass(class MyClass {})); // true
  console.log(isClass(function myFunc() {})); // false
  

• isSubclass(child: any, parent: any): boolean Checks if a class is a subclass of another class.

  class Parent {}
  class Child extends Parent {}
  console.log(isSubclass(Child, Parent)); // true
  

• isDate(value: any): boolean Checks if a value is a valid Date object.

  console.log(isDate(new Date())); // true
  console.log(isDate('2021-01-01')); // false
  

• isRegex(value: any): boolean Checks if a value is a valid RegExp (Regular Expression).

  console.log(isRegex(/abc/)); // true
  console.log(isRegex('abc')); // false
  

• isPromise(value: any): boolean Checks if a value is a Promise.

  console.log(isPromise(Promise.resolve())); // true
  console.log(isPromise(function () {})); // false
  

Pattern Functions

Pattern functions allow you to validate whether a value follows a specific pattern.

• isCamelCase(value: any): boolean Checks if a string is in camelCase format.

  console.log(isCamelCase('camelCase')); // true
  console.log(isCamelCase('snake_case')); // false
  

• isPascalCase(value: any): boolean Checks if a string is in PascalCase format.

  console.log(isPascalCase('PascalCase')); // true
  console.log(isPascalCase('pascalCase')); // false
  

• isSnakeCase(value: any): boolean Checks if a string is in snake_case format.

  console.log(isSnakeCase('snake_case')); // true
  console.log(isSnakeCase('snakeCase')); // false
  

• iskababCase(value: any): boolean Checks if a string is in kebab-case format.

  console.log(iskababCase('kebab-case')); // true
  console.log(iskababCase('kebabCase')); // false
  

• isIso(value: any): boolean Checks if a string is in ISO 8601 format (e.g., "2024-11-28T12:30:00.000Z").

  console.log(isIso('2024-11-28T12:30:00.000Z')); // true
  console.log(isIso('2024-11-28')); // false
  

• isDateTime(value: any): boolean Checks if a string is in the datetime format (e.g., "2024-11-28 12:30:00").

  console.log(isDateTime('2024-11-28 12:30:00')); // true
  console.log(isDateTime('2024-11-28')); // false
  

• isDateStr(date: any): boolean Checks if a string is in the date format (e.g., "2024-11-28").

  console.log(isDateStr('2024-11-28')); // true
  console.log(isDateStr('2024-11-28 12:30:00')); // false
  

• isTimeStr(date: any): boolean Checks if a string is in the time format (e.g., "12:30:00").

  console.log(isTimeStr('12:30:00')); // true
  console.log(isTimeStr('12:30')); // false
  

• isPropExp(value: any): boolean Checks if a string is a valid property name (e.g., a valid js variable name).

  console.log(isPropExp('myVar')); // true
  console.log(isPropExp('123var')); // false
  

• isNumExp(value: any): boolean Checks if a string is a valid number (including integers and floats).

  console.log(isNumExp('123')); // true
  console.log(isNumExp('123.45')); // true
  console.log(isNumExp('abc')); // false
  

• isIntExp(value: any): boolean Checks if a string is a valid integer.

  console.log(isIntExp('123')); // true
  console.log(isIntExp('123.45')); // false
  

• isFloatExp(value: any): boolean Checks if a string is a valid float (decimal number).

  console.log(isFloatExp('123.45')); // true
  console.log(isFloatExp('123')); // false
  

• isStrExp(value: any): boolean Checks if a string is a valid string literal (single or double-quoted).

  console.log(isStrExp("'hello'")); // true
  console.log(isStrExp('"world"')); // true
  console.log(isStrExp('hello')); // false
  

• isDotExp(value: any): boolean Checks if a string is a valid dot notation expression for property access.

  console.log(isDotExp('object.property')); // true
  console.log(isDotExp('object.123property')); // false
  

• isBracketExp(value: any): boolean Checks if a string is a valid bracket notation expression for property access.

  console.log(isBracketExp('object["property"]')); // true
  console.log(isBracketExp('object["123"]')); // false
  

• isAnyExp(value: any): boolean Checks if a string is a valid combination of dot and bracket notations.

  console.log(isAnyExp('object.property[0]')); // true
  console.log(isAnyExp('object.property["key"]')); // true
  console.log(isAnyExp('object.123property[0]')); // false
  

Content Functions

Content functions help determine if the content of an object, array, or string matches the expected structure or value.

• isFullObj(value: any): boolean Checks if an object is non-empty (has at least one property).

  console.log(isFullObj({ key: 'value' })); // true
  console.log(isFullObj({})); // false
  

• isFullArr(value: any): boolean Checks if an array is non-empty (has at least one element).

  console.log(isFullArr([1, 2, 3])); // true
  console.log(isFullArr([])); // false
  

• isFullStr(value: any): boolean Checks if a string is non-empty (contains at least one non-whitespace character).

  console.log(isFullStr('Hello')); // true
  console.log(isFullStr('   ')); // false
  

• isEmptyObj(value: any): boolean Checks if an object is empty (has no properties).

  console.log(isEmptyObj({})); // true
  console.log(isEmptyObj({ key: 'value' })); // false
  

• isEmptyArr(value: any): boolean Checks if an array is empty (contains no elements).

  console.log(isEmptyArr([])); // true
  console.log(isEmptyArr([1])); // false
  

• isEmptyStr(value: any): boolean Checks if a string is empty (contains non-whitespace characters).

  console.log(isEmptyStr('')); // true
  console.log(isEmptyStr('   ')); // true
  console.log(isEmptyStr('sss')); // true
  console.log(isEmptyStr('Hello')); // false
  

• isArrOfNum(value: any): boolean Checks if an array is non-empty and contains only numbers.

  console.log(isArrOfNum([1, 2, 3.3])); // true
  console.log(isArrOfNum([1, 'two', 3.3])); // false
  

• isArrOfInt(value: any): boolean Checks if an array is non-empty and contains only integers.

  console.log(isArrOfInt([1, 2, 3])); // true
  console.log(isArrOfInt([1, 2.5, 3])); // false
  

• isArrOfFloat(value: any): boolean Checks if an array is non-empty and contains only floating-point numbers.

  console.log(isArrOfFloat([1.5, 2.7, 3.2])); // true
  console.log(isArrOfFloat([1, 2.5, '3'])); // false
  

• isArrOfStr(value: any): boolean Checks if an array is non-empty and contains only strings.

  console.log(isArrOfStr(['hello', 'world'])); // true
  console.log(isArrOfStr(['hello', 123])); // false
  

• isArrOfArr(value: any): boolean Checks if an array is non-empty and contains only arrays.

  console.log(isArrOfArr([[], []])); // true
  console.log(isArrOfArr([[], 'two'])); // false
  

• isArrOfObj(value: any): boolean Checks if an array is non-empty and contains only objects.

  console.log(isArrOfObj([{}, {}])); // true
  console.log(isArrOfObj([{}, 1])); // false
  

• isArrOfFunc(value: any): boolean Checks if an array is non-empty and contains only functions.

  console.log(isArrOfFunc([() => {}, () => {}])); // true
  console.log(isArrOfFunc([() => {}, 'string'])); // false
  

• isArrOfBool(value: any): boolean Checks if an array is non-empty and contains only booleans.

  console.log(isArrOfBool([true, false, true])); // true
  console.log(isArrOfBool([true, 'false'])); // false
  

• isArrOfAny(value: any): boolean Checks if an array is non-empty and allows any type of value (no type restriction).

  console.log(isArrOfAny([1, 'string', true])); // true
  console.log(isArrOfAny([])); // false
  

• isObjOfNum(value: any): boolean Checks if an object is non-empty and contains only numeric values.

  console.log(isObjOfNum({ a: 1, b: 2.2 })); // true
  console.log(isObjOfNum({ a: 1, b: 'two' })); // false
  

• isObjOfInt(value: any): boolean Checks if an object is non-empty and contains only integer values.

  console.log(isObjOfInt({ a: 1, b: 2 })); // true
  console.log(isObjOfInt({ a: 1, b: 2.5 })); // false
  

• isObjOfFloat(value: any): boolean Checks if an object is non-empty and contains only floating-point values.

  console.log(isObjOfFloat({ a: 1.1, b: 2.5 })); // true
  console.log(isObjOfFloat({ a: 1, b: '2.5' })); // false
  

• isObjOfStr(value: any): boolean Checks if an object is non-empty and contains only string values.

  console.log(isObjOfStr({ a: 'apple', b: 'banana' })); // true
  console.log(isObjOfStr({ a: 'apple', b: 123 })); // false
  

• isObjOfArr(value: any): boolean Checks if an object is non-empty and contains only arrays as values.

  console.log(isObjOfArr({ a: [1, 2], b: [3, 4] })); // true
  console.log(isObjOfArr({ a: [1, 2], b: 'string' })); // false
  

• isObjOfObj(value: any): boolean Checks if an object is non-empty and contains only objects as values.

  console.log(isObjOfObj({ a: { x: 1 }, b: { y: 2 } })); // true
  console.log(isObjOfObj({ a: { x: 1 }, b: 'string' })); // false
  

• isObjOfFunc(value: any): boolean Checks if an object is non-empty and contains only functions as values.

  console.log(isObjOfFunc({ a: () => {}, b: () => {} })); // true
  console.log(isObjOfFunc({ a: () => {}, b: 'string' })); // false
  

• isObjOfBool(value: any): boolean Checks if an object is non-empty and contains only boolean values.

  console.log(isObjOfBool({ a: true, b: false })); // true
  console.log(isObjOfBool({ a: true, b: 'false' })); // false
  

• isObjOfAny(value: any): boolean Checks if an object is non-empty and allows any type of value (no type restriction).

  console.log(isObjOfAny({ a: 1, b: 'string' })); // true
  console.log(isObjOfAny({})); // false
  

• hasProp(object: any, property: any): boolean Checks if an object has a specific property.

  console.log(hasProp({ a: 1, b: 2 }, 'a')); // true
  console.log(hasProp({ a: 1, b: 2 }, 'c')); // false
  

• hasProps(object: any, ...properties: Array<any>): boolean Checks if an object has all specified properties.

  console.log(hasProps({ a: 1, b: 2 }, 'a', 'b')); // true
  console.log(hasProps({ a: 1, b: 2 }, 'a', 'c')); // false
  

• hasIndex(target: any, index: any): boolean Checks if an index is within the range of a target (array, string, or object).

  console.log(hasIndex([1, 2, 3], 1)); // true
  console.log(hasIndex([1, 2, 3], 3)); // false
  console.log(hasIndex('hello', 1)); // true
  console.log(hasIndex('hello', 5)); // false
  

• hasLength(target: any, length: any): boolean Checks if the length of a target (array, string, or object) matches a specified length.

  console.log(hasLength([1, 2, 3], 3)); // true
  console.log(hasLength([1, 2, 3], 2)); // false
  console.log(hasLength('hello', 5)); // true
  console.log(hasLength('hello', 4)); // false
  console.log(hasLength({ a: 1, b: 2 }, 2)); // true
  console.log(hasLength({ a: 1, b: 2 }, 1)); // false
  

• hasFlag(regex: any, flag: any): boolean Checks if a regex has a specific flag.

  console.log(hasFlag(/abc/i, 'i')); // true
  console.log(hasFlag(/abc/i, 'g')); // false
  

• hasKey(object: any, key: any): boolean Checks if an object has a specific key (property name).

  console.log(hasKey({ a: 1, b: 2 }, 'a')); // true
  console.log(hasKey({ a: 1, b: 2 }, 'c')); // false
  

• hasKeys(object: any, ...keys: Array<any>): boolean Checks if an object contains all of the specified keys (property names).

  console.log(hasKeys({ a: 1, b: 2 }, 'a', 'b')); // true
  console.log(hasKeys({ a: 1, b: 2 }, 'a', 'c')); // false
  console.log(hasKeys({ a: 1, b: 2, c: 3 }, 'a', 'b')); // true
  

• hasValue(target: any, value: any): boolean Checks if an (object|array|string) has a specific value.

  console.log(hasValue({ a: 1, b: 2 }, 2)); // true
  console.log(hasValue([1, 2, 3], 2)); // true
  console.log(hasValue('hello world', 'world')); // true
  console.log(hasValue({ a: 1, b: 2 }, 3)); // false
  

• hasValues(target: any, ...values: Array<any>): boolean Checks if an (object|array|string) contains all of the specified values.

  console.log(hasValues({ a: 1, b: 2 }, 1, 2)); // true
  console.log(hasValues([1, 2, 3], 1, 3)); // true
  console.log(hasValues('hello world', 'hello', 'world')); // true
  console.log(hasValues(['hello', 'foo'], 'hello', 'bar')); // false