Type-inspect NPM

TypeInspect

The TypeInspect module returns information about the data type of a Javascript object. It inspects any supported datatype and returns an object with the type, which is a typeof call, kind the real data type and the value.

import TypeInspect from 'type-inspect'

const inspected = TypeInspect.inspect('foo')

// inspected === {
//   type: 'string',
//   kind: 'string',
//   value: 'foo'
// }


const inspected = TypeInspect.inspect({ bla: 'blubb' })

// inspected === {
//   type: 'object',
//   kind: 'object',
//   value: {
//      bla: {
//        type: 'string',
//        kind: 'string'
//        value: 'blubb'
//      }
//   }
// }


const inspected = TypeInspect.inspect(['one', 2])

// inspected === {
//   type: 'object',
//   kind: 'array',
//   value: [
//     { type: 'string', kind: 'string', value: 'one' },
//     { type: 'number', kind: 'number', value: 2 }
//   ]
// }

Supported datatypes:

Input	Type	Kind	Description
`undefined`	undefined	undefined	Javascripts `undefined` property
`null`	object	null	Javascripts `null` object
`number`	number	number	Number object
`NaN`	number	nan	NaN object
`string`	string	string	String object
`boolean`	boolean	boolean	Boolean object
`object`	object	object	Object object
`regexp`	object	regexp	Reguler expression object
`array`	object	array	Array Object
`date`	object	date	Date object
`map`	object	map	Map object
`set`	object	set	Set object
`promise`	object	promise	Promise object
`function`	function	function	Function Object
`generator`	function	generator	Generator function object
`async`	function	async	Async function object
`class`	function	class	Class object

Methods

diff(any left, any right)

The diff method goes recursive through two input values and calculates the difference. It returns an instance of TypeDiff

const left = {
  bla: 'Bla',
  blub: 'Blubb',
  blob: undefined
}

const right = {
  bla: 'Bla',
  blub: 'Blobb',
  blab: null
}

const diff = TypeInspect.diff(left, right)
diff.print()

TypeDiff object

Properties

obj diffResult

Holds the diff result.

{
  type: 'object',
  kind: 'object',
  values: [{
    type: 'string',
    kind: 'string',
    value: 'Bla',
    key: 'bla',
    isDifferent: false
  }, {
    type: 'string',
    kind: 'string',
    valueAdded: 'Blubb',
    valueRemoved: 'Blobb',
    key: 'blub',
    isDifferent: true
  }, {
    type: 'undefined',
    typeAdded: 'undefined',
    kind: 'undefined',
    kindAdded: 'undefined',
    value: undefined,
    key: 'blob',
    keyAdded: 'blob',
    isDifferent: true
  }, {
    type: 'object',
    typeRemoved: 'object',
    kind: 'null',
    kindRemoved: 'null',
    valueAdded: undefined,
    valueRemoved: null,
    key: 'blab',
    keyRemoved: 'blab',
    isDifferent: true
  }],
  isDifferent: true
}

Methods

diff(any left, any right)

Compares two datatypes and returns a TypeDiff instance. The flag isDifferent indicates that the node or the node's child has differences. You can check the flag on the root level to make sure the whole trees are identical or not.

print(bool printColors)

Print diff result.

parse(bool printColors)

Parse a diff result and returns value as string.

Matcher

With version v2.2.0 matcher support was introduced. A matcher allows to match a value by it's data type, it can be placed in the right side of a diff call.

const {Matcher, TypeInspect} = require('type-inspect')

const left = {
  name: 'Banana',
  isFruit: true
}

const matcher = new Matcher()
const right = {
  name: matcher.isString(),
  isFruit: matcher.isBoolean()
}

const diff = TypeInspect.diff(left, right)
if (diff.isDifferent === false) {
  console.log('Left and right is identical')
}

Supported matchers:

Name	Description
`isArray()`	Value is a Array
`isAsync()`	Value is a Async function
`isBoolean()`	Value is a Boolean
`isClass()`	Value is a Class
`isDate()`	Value is a Date
`isFunction()`	Value is a Function
`isGenerator()`	Value is a Generator function
`isMap()`	Value is a Map
`isNaN()`	Value is `NaN`
`isNull()`	Value is `null` object
`isNumber()`	Value is a Number
`isObject()`	Value is an Object
`isPromise()`	Value is a Promise
`isRegExp()`	Value is a reguler expression
`isSet()`	Value is a Set
`isString()`	Value is a String
`isUndefined()`	Value is `undefined`