Neovictorian Paisley Menswear

    check-more-types
    TypeScript icon, indicating that this package has built-in type declarations

    2.24.0 • Public • Published

    check-more-types

    Large collection of predicates, inspired by check-types.js

    NPM

    manpm Build status dependencies devdependencies

    semantic-release Coverage Status Codacy Badge Code Climate issue

    See Readable conditions for advice and examples.

    Install

    node: npm install check-more-types --save

    var check = require('check-more-types');
    console.assert(check.bit(1), 'check.bit works');
    

    browser bower install check-more-types --save

    <script src="check-more-types.js"></script>
    

    check.number

    check.number is part of the check-types library, but as a note, it does not pass null, undefined or NaN values

    check.number(null); // false
    check.not.number(undefined); // true
    check.number(NaN); // false

    check.email

    Really simple regex email check. Should not be relied to be robust.

    check.email('me@foo.bar') // true
    check.email('me.foo.bar') // false

    check.extension (alias check.ext)

    Confirms that given file name has expected extension

    check.extension('txt', 'foo/bar.txt') // true

    It is curried, so you can create convenient methods

    const isJs = check.extension('js')
    isJs('script.js') // true

    There are a couple of convenient shortcuts, like check.isJs, check.isJson, check.isJpg

    check.odd and check.even

    Check if a number odd or even

    check.odd(2) // false
    check.odd(3) // true
    check.even(2) // true

    check.port

    Returns true if passed argument is positive number less or equal to largest allowed port number 65535

    check.systemPort

    Returns true if passed argument is number between 0 and 1024

    check.userPort

    Returns true if passed argument is a port number and larger than 1024

    check.error

    Returns true if given argument is an instance of type Error

    check.https (alias secure)

    Returns true if the provided url starts with https://. Alias secure.

    check.http

    Returns true if the provided url starts with http://

    check.webUrl (alias url)

    Returns true if the given string is http or https url.

    check.contains

    Returns true if given array contains an item, or given string contains substring.

    check.contains(['foo', 42], 'foo'); // true
    check.contains('apple', 'pp'); // true

    check.defined

    check.defined(0); // true
    check.defined(1); // true
    check.defined(true); // true
    check.defined(false); // true
    check.defined(null); // true
    check.defined(''); // true
    check.defined(); // false
    check.defined(root.doesNotExist); // false
    check.defined({}.doesNotExist); // false
    

    check.semver

    check.semver('1.0.2'); // true
    check.semver('1.0.2-alpha'); // false
    

    check.positiveNumber (alias check.positive)

    check.positive(100); // true
    check.not.positive(-1); // true

    check.negativeNumber (alias check.negative)

    check.negative(-10); // true
    check.not.negativeNumber(1); // true

    check.type

    check.type('string', 'foo'); // true
    check.type('number', 42); // true
    

    check.type is curried.


    check.bit

    check.bit(0); // true
    check.bit(1); // true
    check.bit('1'); // false
    check.bit(2); // false
    check.bit(true); // false
    

    check.primitive

    Returns true for primitive JavaScript types

    check.primitive(42); // true
    check.primitive(true); // true
    check.primitive('foo'); // true
    check.primitive([]); // false
    

    Also returns true for Symbol ES6 syntax.


    check.zero

    check.zero(0); // true
    check.zero(); // false
    check.zero(null); // false
    

    check.git

    check.git('url string');
    

    check.commitId


    check.shortCommitId


    check.index


    check.oneOf

    var colors = ['red', 'green', 'blue'];
    var color = 'green';
    check.oneOf(colors, color); // true
    check.oneOf(colors, 'brown'); // false
    

    Function is curried


    check.same

    var foo = {}
    var bar = {}
    check.same(foo, foo); // true
    check.same(foo, bar); // false
    // primitives are compared by value
    check.same(0, 0); // true
    check.same('foo', 'foo'); // true
    

    check.same should produce same result as ===.


    check.length

    Confirms length of a string or an Array. The function is curried and can guess the argument order

    check.length([1, 2], 2); // true
    check.length('foo', 3); // true
    // argument order
    check.length(3, 'foo'); // true
    // curried call
    check.length('foo')(3); // true
    check.length(3)('foo'); // true

    check.sameLength

    check.sameLength([1, 2], ['a', 'b']); // true
    check.sameLength('ab', 'cd'); // true
    // different types
    check.sameLength([1, 2], 'ab'); // false
    

    check.allSame

    var foo = {}
    var bar = {}
    check.allSame([foo, foo, foo]); // true
    check.allSame([foo, foo, bar]); // false
    // primitives are compared by value
    check.allSame([0, 0]); // true
    check.allSame(['foo', 'foo', 'foo']); // true
    check.allSame([false, 0]); // false
    

    check.unit

    check.unit(0); // true
    check.unit(1); // true
    check.unit(0.1); // true
    check.unit(1.2); // false
    check.unit(-0.1); // false
    

    check.hexRgb

    check.hexRgb('#FF00FF'); // true
    check.hexRgb('#000'); // true
    check.hexRgb('#aaffed'); // true
    check.hexRgb('#00aaffed'); // false
    check.hexRgb('aaffed'); // false
    

    check.bool

    check.bool(true); // true
    check.bool(false); // true
    check.bool(0); // false
    check.bool(1); // false
    check.bool('1'); // false
    check.bool(2); // false
    

    check.emptyString

    check.emptyString(''); // true
    check.emptyString(' '); // false
    check.emptyString(0); // false
    check.emptyString([]); // false
    

    check.empty

    check.empty([]); // true
    check.empty(''); // true
    check.empty({}); // true
    check.empty(0); // false
    check.empty(['foo']); // false
    

    check.unempty

    check.unempty([]); // false
    check.unempty(''); // false
    check.unempty({}); // false
    check.unempty(0); // true
    check.unempty(['foo']); // true
    check.unempty('foo'); // true
    

    check.unemptyArray

    check.unemptyArray(null); // false
    check.unemptyArray(1); // false
    check.unemptyArray({}); // false
    check.unemptyArray([]); // false
    check.unemptyArray(root.doesNotExist); // false
    check.unemptyArray([1]); // true
    check.unemptyArray(['foo', 'bar']); // true
    

    check.arrayOfStrings (alias strings)

    // second argument is checkLowerCase
    check.arrayOfStrings(['foo', 'Foo']); // true
    check.arrayOfStrings(['foo', 'Foo'], true); // false
    check.arrayOfStrings(['foo', 'bar'], true); // true
    check.arrayOfStrings(['FOO', 'BAR'], true); // false
    

    check.numbers

    Returns true if all items in an array are numbers

    check.arrayOf

    check.arrayOf(check.unemptyString, ['foo', '']); // false
    check.arrayOf(check.unemptyString, ['foo', 'bar']); // true
    // can be partially applied and combined with check.schema
    var person = {
      first: check.unemptyString,
      last: check.unemptyString
    };
    var isPerson = check.schema.bind(null, person);
    var arePeople = check.arrayOf.bind(null, isPerson);
    var people = [{
      first: 'foo',
      last: 'bar'
    }];
    arePeople(people); // true

    Why would you need check.arrayOf(predicate, x) and not simply use x.every(predicate)? Because x might not be an Array.

    check.badItems

    Finds items that do not pass predicate

    check.badItems(check.unemptyString, ['foo', '', 'bar']); // ['']

    check.arrayOfArraysOfStrings

    // second argument is checkLowerCase
    check.arrayOfArraysOfStrings([['foo'], ['bar'}}); // true
    check.arrayOfArraysOfStrings([['foo'], ['bar'}}, true); // true
    check.arrayOfArraysOfStrings([['foo'], ['BAR'}}, true); // false
    

    check.lowerCase

    check.lowerCase('foo bar'); // true
    check.lowerCase('*foo ^bar'); // true
    check.lowerCase('fooBar'); // false
    // non-strings return false
    check.lowerCase(10); // false
    

    check.has(obj, property)

    var obj = {
    foo: 'foo',
    bar: 0
    }
    check.has(obj, 'foo'); // true
    check.has(obj, 'bar'); // true
    check.has(obj, 'baz'); // false
    // non-object returns false
    check.has(5, 'foo'); // false
    check.has('foo', 'length'); // true
    

    check.all

    var obj = {
      foo: 'foo',
      bar: 'bar',
      baz: 'baz'
    }
    var predicates = {
      foo: check.unemptyString,
      bar: function(value) {
        return value === 'bar'
      }
    }
    check.all(obj, predicates); // true
    

    check.schema

    var obj = {
    foo: 'foo',
    bar: 'bar',
    baz: 'baz'
    }
    var schema = {
    foo: check.unemptyString,
    bar: function(value) {
    return value === 'bar'
    }
    }
    check.schema(schema, obj); // true
    check.schema(schema, {}); // false
    

    check.spec is equivalent to check.all but with arguments reversed. This makes it very convenient to create new validator functions using partial argument application

    The method is curried, thus you can easily create predicate function

    var hasName = check.schema({ name: check.unemptyString });
    hasName({ name: 'joe' }); // true

    check.schema bind

    var personSchema = {
    name: check.unemptyString,
    age: check.positiveNumber
    }
    var isValidPerson = check.schema.bind(null, personSchema)
    var h1 = {
    name: 'joe',
    age: 10
    }
    var h2 = {
    name: 'ann'
    // missing age property
    }
    isValidPerson(h1); // true
    isValidPerson(h2); // false
    

    If you want you can manually bind check.schema to first argument

    var personSchema = {
      name: check.unemptyString,
      age: check.positiveNumber
    };
    var isValidPerson = check.schema.bind(null, personSchema);
    var h1 = {
      name: 'joe',
      age: 10
    };
    var h2 = {
      name: 'ann'
        // missing age property
    };
    isValidPerson(h1); // true
    isValidPerson(h2); // false
    

    You can use Function.prototype.bind or any partial application method, for example _.partial(check.schema, personSchema);. Because bound schema parameter generates a valid function, you can nest checks using schema composition. For example let us combine the reuse isValidPerson as part of another check

    schema composition

    var teamSchema = {
    manager: isValidPerson,
    members: check.unemptyArray
    }
    var team = {
    manager: {
    name: 'jim',
    age: 20
    },
    members: ['joe', 'ann']
    }
    check.schema(teamSchema, team); // true
    

    check.raises(fn, validator)

    function foo() {
    throw new Error('foo')
    }
    
    function bar() {}
    
    function isValidError(err) {
    return err.message === 'foo'
    }
    
    function isInvalid(err) {
    check.instance(err, Error); // true
    return false
    }
    check.raises(foo); // true
    check.raises(bar); // false
    check.raises(foo, isValidError); // true
    check.raises(foo, isInvalid); // false
    

    Modifiers

    Every predicate function is also added to check.maybe object. The maybe predicate passes if the argument is null or undefined, or the predicate returns true.

    check.maybe

    check.maybe.bool(); // true
    check.maybe.bool('true'); // false
    var empty
    check.maybe.lowerCase(empty); // true
    check.maybe.unemptyArray(); // true
    check.maybe.unemptyArray([]); // false
    check.maybe.unemptyArray(['foo', 'bar']); // true
    

    Every function has a negated predicate in check.not object

    check.not

    check.not.bool(4); // true
    check.not.bool('true'); // true
    check.not.bool(true); // false
    

    Every predicate can also throw an exception if it fails

    check.verify

    check.verify.arrayOfStrings(['foo', 'bar'])
    check.verify.bit(1)
    
    function nonStrings() {
      check.verify.arrayOfStrings(['Foo', 1])
    }
    check.raises(nonStrings); // true
    function nonLowerCase() {
      check.verify.lowerCase('Foo')
    }
    check.raises(nonLowerCase); // true
    

    Adding your own predicates

    You can add new predicates to check, check.maybe, etc. by using check.mixin(predicate) method. If you do not pass a name, it will try using function's name.

    check.mixin(predicate, name)

    function isBar(a) {
      return a === 'bar'
    }
    check.mixin(isBar, 'bar')
    check.bar('bar'); // true
    check.bar('anything else'); // false
    // supports modifiers
    check.maybe.bar(); // true
    check.maybe.bar('bar'); // true
    check.not.bar('foo'); // true
    check.not.bar('bar'); // false
    

    Mixin will not override existing functions

    check.mixin does not override

    function isFoo(a) {
      return a === 'foo'
    }
    
    function isBar(a) {
      return a === 'bar'
    }
    check.mixin(isFoo, 'isFoo')
    check.isFoo; // isFoo
    check.mixin(isBar, 'isFoo')
    check.isFoo; // isFoo
    

    Defending a function

    Using check-more-types you can separate the inner function logic from checking input arguments. Instead of this

    function add(a, b) {
        la(check.number(a), 'first argument should be a number', a);
        la(check.number(a), 'second argument should be a number', b);
        return a + b;
    }

    you can use check.defend function

    check.defend(fn, predicates)

    function add(a, b) {
      return a + b
    }
    var safeAdd = check.defend(add, check.number, check.number)
    add('foo', 2); // 'foo2'
    // calling safeAdd('foo', 2) raises an exception
    check.raises(safeAdd.bind(null, 'foo', 2)); // true
    

    protects optional arguments

    function add(a, b) {
      if (typeof b === 'undefined') {
        return 'foo'
      }
      return a + b
    }
    add(2); // 'foo'
    var safeAdd = check.defend(add, check.number, check.maybe.number)
    safeAdd(2, 3); // 5
    safeAdd(2); // 'foo'
    

    You can add extra message after a predicate

    check.defend with messages

    function add(a, b) {
      return a + b
    }
    var safeAdd = check.defend(add, check.number, 'a should be a number', check.string, 'b should be a string')
    safeAdd(2, 'foo'); // '2foo'
    function addNumbers() {
      return safeAdd(2, 3)
    }
    
    function checkException(err) {
      err.message; // 'Argument 2: 3 does not pass predicate: b should be a string'
      return true
    }
    check.raises(addNumbers, checkException); // true
    

    This works great when combined with JavaScript module pattern as in this example

    check.defend in module pattern

    var add = (function() {
      // inner private function without any argument checks
      function add(a, b) {
          return a + b
        }
        // return defended function
      return check.defend(add, check.number, check.number)
    }())
    add(2, 3); // 5
    // trying to call with non-numbers raises an exception
    function callAddWithNonNumbers() {
      return add('foo', 'bar')
    }
    check.raises(callAddWithNonNumbers); // true
    

    Safe callback execution

    Sometimes we want to execute a function depending on the condition, but without throwing an exception. For these cases, there is check.then

    check.then

    function isSum10(a, b) {
      return a + b === 10
    }
    
    function sum(a, b) {
      return a + b
    }
    var onlyAddTo10 = check.then(isSum10, sum)
      // isSum10 returns true for these arguments
      // then sum is executed
    onlyAddTo10(3, 7); // 10
    onlyAddTo10(1, 2); // undefined
    // sum is never called because isSum10 condition is false
    

    check.found

    Great for quickly checking string or array search results

    check.found('foo'.indexOf('f')); // true
    check.found('foo bar'.indexOf('bar')); // true

    check.regexp

    Returns true if the passed value is a regular expression.

    check.promise

    Returns true if given object has promise methods (.then, etc)

    check.validDate

    Returns true if the given instance is a Date and is valid.

    check.equal

    Curried shallow strict comparison

    var foo = 'foo';
    check.equal(foo, 'foo'); // true
    var isFoo = check.equal('foo');
    isFoo('foo'); // true
    isFoo('bar'); // false

    check.or

    Combines multiple predicates into single one using OR logic

    var predicate = check.or(check.bool, check.unemptyString);
    predicate(true); // true
    predicate('foo'); // true
    predicate(42); // false

    It treats non-functions as boolean values

    var predicate = check.or(check.unemptyString, 42);
    // will always return true
    predicate('foo'); // true, because it is unempty string
    predicate(false); // true, because 42 is truthy

    Note: if there are any exceptions inside the individual predicate functions, they are treated as false values.

    check.and

    Combines multiple predicates using AND. If the predicate is not a function, evaluates it as a boolean value.

    function isFoo(x) { return x === 'foo'; }
    check.and(check.unemptyString, isFoo); // only true for "foo"

    Both check.or and check.and are very useful inside check.schema to create more powerful predicates on the fly.

    var isFirstLastNames = check.schema.bind(null, {
      first: check.unemptyString,
      last: check.unemptyString
    });
    var isValidPerson = check.schema.bind(null, {
      name: check.or(check.unemptyString, isFirstLastNames)
    });
    isValidPerson({ name: 'foo' }); // true
    isValidPerson({ name: {
      first: 'foo',
      last: 'bar'
    }}); // true

    Small print

    Author: Kensho © 2014

    Support: if you find any problems with this library, open issue on Github

    This documentation was generated using grunt-xplain and grunt-readme.

    MIT License

    The MIT License (MIT)

    Copyright (c) 2014 Kensho

    Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

    Install

    npm i check-more-types

    DownloadsWeekly Downloads

    3,343,152

    Version

    2.24.0

    License

    MIT

    Last publish

    Collaborators

    • josephong
    • bahmutov
    • mcamac