New Research: Supply Chain Attack on Axios Pulls Malicious Dependency from npm.Details → →

Book a Demo Sign in

megaorm-test

Package Overview

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies

Install

Package was removed

Sorry, it seems this package was removed from the registry

megaorm-test

MegaORM-Test is designed to assist developers in type checking and validation for various JavaScript values. It provides a collection type-checking functions, and utilities to determine the type of a given value. and more...

unpublished

latest

Source

npm

Version: 1.0.2

Version published: last year

Maintainers: 0

Created: last year

Source

MegaORM-Test

MegaORM-Test is a comprehensive package designed to assist developers in type checking and validation for various JavaScript values. It provides a collection type-checking functions, and utilities to determine the type of a given value. and more...

Type Symbols

MegaORM-Test defines a set of symbols to represent common JavaScript types. These symbols provide a standardized way to work with types programmatically.

Available Symbols

Symbol	Alias	Description
`STRING`	`STR`	Represents a string type.
`INTEGER`	`INT`	Represents an integer type.
`BOOLEAN`	`BOOL`	Represents a boolean type.
`OBJECT`	`OBJ`	Represents an object type.
`FUNCTION`	`FUNC`	Represents a function type.
`INFINITY`	`INF`	Represents an infinity value.
`FLOAT`	-	Represents a floating-point number type.
`SYMBOL`	-	Represents a symbol type.
`UNDEFINED`	-	Represents an undefined value.
`NULL`	-	Represents a null value.
`ARRAY`	-	Represents an array type.
`NAN`	-	Represents a Not-a-Number value.
`DATE`	-	Represents the `Date` type.
`REGEXP`	-	Represents the `RegExp` type.
`MAP`	-	Represents the `Map` type.
`SET`	-	Represents the `Set` type.
`PROMISE`	-	Represents the `Promise` type.
`ERROR`	-	Represents the `Error` type.

Type Determination

`type(value: any): Type`

Determines the symbolic type of a given value and returns the corresponding symbol.

console.log(type(123) === INTEGER); // true
console.log(type('hello world') === STRING); // true
console.log(type([]) === ARRAY); // true
console.log(type(new Error('Oops')) === ERROR); // true

Type Checking Functions

MegaORM-Test includes utility functions to check if a value belongs to a specific 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 Checking Functions

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 JavaScript 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

Empty or Full Functions

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

Array Functions

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
```

Object Functions

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
```

Content Functions

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

Keywords

FAQs

What is megaorm-test?

Is megaorm-test well maintained?

Package last updated on 16 Dec 2024

Did you know?

Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.

Install

megaorm-test

MegaORM-Test

Type Symbols

Available Symbols

Type Determination

type(value: any): Type

Type Checking Functions

Pattern Checking Functions

Empty or Full Functions

Array Functions

Object Functions

Content Functions

Keywords

Related posts

Axios Maintainer Confirms Social Engineering Attack Behind npm Compromise

Node.js Drops Bug Bounty Rewards After Funding Dries Up

`type(value: any): Type`