@megaorm/test NPM

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.

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

megaorm type-checking validation type-validation javascript typescript type-safety value-checking data-validation type-utils data-type utility-functions megaorm-test type-checker js-validation ts-validation type-helpers type-check data-checking

@megaorm/mysql @megaorm/pg @megaorm/pool @megaorm/seeder @megaorm/sqlite @megaorm/utc @megaorm/utils @megaorm/builder @megaorm/cli @megaorm/cluster @megaorm/core @megaorm/faker @megaorm/gen @megaorm/model

12 months ago

12 months ago

12 months ago

12 months ago

12 months ago

@megaorm/test v1.2.0

MegaORM Test

Table of Contents

Type Functions

Pattern Functions

Content Functions