Extend is.prototype

is.extend({
  uppercase: function () {
    return this.actual.split('').every(x => x.match(/[A-Z]/));
  }
});

is('WORD').uppercase()     // true
is('Word').uppercase()     // false
is('Word').not.uppercase() // true

Validates with type predicate if object is array

const x: unknown = ...;

if (is.array(x)) {
  // x here is any[]
}

Validates if object is a plain object

is.object({ a: 1 })        // true
is.object(new Something()) // false`

Get the string representation of object and optionaly compare it against expected

is.representation(null) // '[object Null]'

is.representation(true, '[object Boolean]') // true

How it works?

If only object parameter is provided, return it's specific type

is.type([] | "[]");      // 'array'
is.type({} | "{}");      // 'object'
is.type(1 | "2");        // 'number'
is.type(true | "false"); // 'boolean'
is.type("something");    // 'string'
is.type(/[0-9]/g);       // 'regexp'

If object and expected are provides, returns boolean with a type predicate

const arg = process.argv[2];

if ( is.type(arg, 'array') ) {
  // true and arg is any[]
}

if ( is.type(arg, 'symbol') ) {
  // true and arg is symbol
}

But wait, actually ( "{}", "[]", "2" ) are strings

const arg = '{a: 1}'; // 'string'

// If `object` is of type 'string'
// with `expected` set to 'string'
// returns true, regardless it's content
is.type(arg, 'string') // true, with 'string' type predicate

// via `is.prototype.str`
is(arg).string() // true, but no type predicate

What the specific type is

For cli inputs and types wrapped in a string, try to extract and define it's type

Check with type predicate if object is typeof expected

is.typeOf(['a'], 'object')  // true
is.typeOf({a: 0}, 'object') // true
is.typeOf(null, 'object')   // true
is.typeOf('xyz', 'string')  // true
is.typeOf(0, 'number')      // true
is.typeOf(false, 'boolean') // true

The actual property is the parameter passed to is

The not property has the negated version of is.prototype

Type: Omit<is, ("not" | "actual")>

const x = '';
is(x).string()                   // true
is(x).not.string()               // false
is(x).not.string({empty: false}) // true

Checks if is.prototype.actual is array, with optional behavior for string array

is(['A']).array() // true
is('[1]').array({string: true}) // true

Checks if is.prototype.actual is boolean (true | false) with optional behavior for string boolean

is(true).boolean() // true
is('false').boolean({string: true}) // true

Checks if is.prototype.actual is function

is(() => {}).function() // true

Determines if is.prototype.actual in object or array, with optional strict check for ownProperties

const a = {one: 1};
const b = Object.create(a);
b.tow = 2;

is('a').in([1, 'a', true]) // true
is('one').in(b) // true
is('tow').in(b) // true
is('one').in(b, {mode: 'own'}) // false
is('tow').in(b, {mode: 'own'}) // true

Checks if is.prototype.actual is NaN, by default coerces the input to a number first with optional behavior for skips coercion (exact NaN check)

is('a').nan() // true
is(NaN).nan({strict: true}) // true
is('a').nan({strict: true}) // false

Checks if is.prototype.actual is null, with optional behavior for string null

is(null).null() // true
is('null').null({string: true}) // true

Checks if is.prototype.actual is number, with optional behavior for string number

is(1).number() // true
is('2').number({string: true}) // true

Checks if is.prototype.actual is object, with optional behavior for string object

is({a: 1}).object() // true
is('{a: 1}').object({string: true}) // true
is('{"a": "1"}').object({string: true}) // true

Check weather is.prototype.actual is type of expected, with optional string type matches

is('value').oftype('string') // true
is(true).oftype('boolean') // true
is('1').oftype('number', {string: true}) // true

Checks if is.prototype.actual is RegExp

is(/[a-z]/g).regexp() // true
is(new RegExp(/0-9/, 'g')).regexp() // true

Returns either the string representation of is.prototype.actual (if expected is omitted) or a boolean value indicating whether the string representations of is.prototype.actual and expected are equal

is('abc').representation() // '[object String]'

is(null).representation("[object Null]") // true
is([12]).representation("[object Null]") // false

Checks if is.prototype.actual is string, with optional behavior for empty strings

is('value').string() // true
is('').string({empty: false}) // false

Checks if is.prototype.actual is symbol

is(Symbol()).symbol() // true

Checks if is.prototype.actual is undefined, with optional behavior for string undefined

is().undefined() // true
is(undefined).undefined() // true
is('undefined').undefined({string: true}) // true