sfcode
An Online Competing and Development Environment
README

*nix build status Windows build status Tests coverage npm version

type

Runtime validation and processing of JavaScript types

  • Respects language nature and acknowledges its quirks
  • Allows coercion in restricted forms (rejects clearly invalid input, normalizes permissible type deviations)
  • No transpilation implied, written to work in all ECMAScript 3+ engines

Example usage

Bulletproof input arguments normalization and validation:

const ensureString = require('type/string/ensure')
, ensureDate = require('type/date/ensure')
, ensureNaturalNumber = require('type/natural-number/ensure')
, isObject = require('type/object/is');
module.exports = (path, options = { min: 0 }) {
path = ensureString(path, { errorMessage: "%v is not a path" });
if (!isObject(options)) options = {};
const min = ensureNaturalNumber(options.min, { default: 0 })
, max = ensureNaturalNumber(options.max, { isOptional: true })
, startTime = ensureDate(options.startTime, { isOptional: true });
// ...logic
};

Installation

npm install type

Utilities

Serves following kind of utilities:

*/coerce

Restricted coercion into primitive type. Returns coerced value or null if value is not coercible per rules.

*/is

Object type/kind confirmation, returns either true or false.

*/ensure

Value validation. Returns input value (in primitive cases possibly coerced) or if value doesn't meet the constraints throws TypeError .

Each */ensure utility, accepts following options (eventually passed with second argument):

  • isOptional - Makes null or undefined accepted as valid value. In such case instead of TypeError being thrown, null is returned.
  • default - A value to be returned if null or undefined is passed as an input value.
  • errorMessage - Custom error message (v can be used as a placeholder for input value)

Value

Value, any value that's neither null nor undefined .

<tt>value/is</tt>

Confirms whether passed argument is a value

const isValue = require("type/value/is");
isValue({}); // true
isValue(null); // false

<tt>value/ensure</tt>

Ensures if given argument is a value. If it's a value it is returned back, if not TypeError is thrown

const ensureValue = require("type/value/ensure");
const obj = {};
ensureValue(obj); // obj
ensureValue(null); // Thrown TypeError: Cannot use null

Object

Object, any non-primitive value

<tt>object/is</tt>

Confirms if passed value is an object

const isObject = require("type/object/is");
isObject({}); // true
isObject(true); // false
isObject(null); // false

<tt>object/ensure</tt>

If given argument is an object, it is returned back. Otherwise TypeError is thrown.

const ensureObject = require("type/object/ensure");
const obj = {};
ensureObject(obj); // obj
ensureString(null); // Thrown TypeError: null is not an object

String

string primitive

<tt>string/coerce</tt>

Restricted string coercion. Returns string presentation for every value that follows below constraints

  • is implicitly coercible to string
  • is neithernull nor undefined
  • its toString method is not Object.prototype.toString

For all other values null is returned

const coerceToString = require("type/string/coerce");
coerceToString(12); // "12"
coerceToString(undefined); // null

<tt>string/ensure</tt>

If given argument is a string coercible value (via string/coerce) returns result string. Otherwise TypeError is thrown.

const ensureString = require("type/string/ensure");
ensureString(12); // "12"
ensureString(null); // Thrown TypeError: null is not a string

Number

number primitive

<tt>number/coerce</tt>

Restricted number coercion. Returns number presentation for every value that follows below constraints

  • is implicitly coercible to number
  • is neither null nor undefined
  • is not NaN and doesn't coerce to NaN

For all other values null is returned

const coerceToNumber = require("type/number/coerce");
coerceToNumber("12"); // 12
coerceToNumber({}); // null
coerceToNumber(null); // null

<tt>number/ensure</tt>

If given argument is a number coercible value (via number/coerce) returns result number. Otherwise TypeError is thrown.

const ensureNumber = require("type/number/ensure");
ensureNumber(12); // "12"
ensureNumber(null); // Thrown TypeError: null is not a number

Finite Number

Finite number primitive

finite/coerce

Follows number/coerce additionally rejecting Infinity and -Infinity values (null is returned if given values coerces to them)

const coerceToFinite = require("type/finite/coerce");
coerceToFinite("12"); // 12
coerceToFinite(Infinity); // null
coerceToFinite(null); // null

finite/ensure

If given argument is a finite number coercible value (via finite/coerce) returns result number. Otherwise TypeError is thrown.

const ensureFinite = require("type/finite/ensure");
ensureFinite(12); // "12"
ensureFinite(null); // Thrown TypeError: null is not a finite number

Integer Number

Integer number primitive

integer/coerce

Follows finite/coerce additionally stripping decimal part from the number

const coerceToInteger = require("type/integer/coerce");
coerceToInteger("12.95"); // 12
coerceToInteger(Infinity); // null
coerceToInteger(null); // null

integer/ensure

If given argument is an integer coercible value (via integer/coerce) returns result number. Otherwise TypeError is thrown.

const ensureInteger = require("type/integer/ensure");
ensureInteger(12.93); // "12"
ensureInteger(null); // Thrown TypeError: null is not an integer

Safe Integer Number

Safe integer number primitive

safe-integer/coerce

Follows integer/coerce but returns null in place of values which are beyond Number.MIN_SAFE_INTEGER and Number.MAX_SAFE_INTEGER range.

const coerceToSafeInteger = require("type/safe-integer/coerce");
coerceToInteger("12.95"); // 12
coerceToInteger(9007199254740992); // null
coerceToInteger(null); // null

safe-integer/ensure

If given argument is a safe integer coercible value (via safe-integer/coerce) returns result number. Otherwise TypeError is thrown.

const ensureSafeInteger = require("type/safe-integer/ensure");
ensureSafeInteger(12.93); // "12"
ensureSafeInteger(9007199254740992); // Thrown TypeError: null is not a safe integer

Natural Number

Natural number primitive

natural-number/coerce

Follows integer/coerce but returns null for values below 0

const coerceToNaturalNumber = require("type/natural-number/coerce");
coerceToNaturalNumber("12.95"); // 12
coerceToNaturalNumber(-120); // null
coerceToNaturalNumber(null); // null

natural-number/ensure

If given argument is a natural number coercible value (via natural-number/coerce) returns result number. Otherwise TypeError is thrown.

const ensureNaturalNumber = require("type/natural-number/ensure");
ensureNaturalNumber(12.93); // "12"
ensureNaturalNumber(-230); // Thrown TypeError: null is not a natural number

Plain Object

A plain object

  • Inherits directly from Object.prototype or null
  • Is not a constructor's prototype property

<tt>plain-object/is</tt>

Confirms if given object is a plain object

const isPlainObject = require("type/plain-object/is");
isPlainObject({}); // true
isPlainObject(Object.create(null)); // true
isPlainObject([]); // false

<tt>plain-object/ensure</tt>

If given argument is a plain object it is returned back. Otherwise TypeError is thrown.

const ensurePlainObject = require("type/plain-object/ensure");
ensurePlainObject({}); // {}
ensureArray("foo"); // Thrown TypeError: foo is not a plain object

Array

Array instance

<tt>array/is</tt>

Confirms if given object is a native array

const isArray = require("type/array/is");
isArray([]); // true
isArray({}); // false
isArray("foo"); // false

<tt>array/ensure</tt>

If given argument is an array, it is returned back. Otherwise TypeError is thrown.

const ensureArray = require("type/array/ensure");
ensureArray(["foo"]); // ["foo"]
ensureArray("foo"); // Thrown TypeError: foo is not an array

Array Like

Array-like value (any value with length property)

<tt>array-like/is</tt>

Restricted array-like confirmation. Returns true for every value that meets following contraints

  • is an object (or with allowString option, a string)
  • is not a function
  • Exposes length that meets array-length constraints
const isArrayLike = require("type/array-like/is");
isArrayLike([]); // true
isArrayLike({}); // false
isArrayLike({ length: 0 }); // true
isArrayLike("foo"); // false
isArrayLike("foo", { allowString: true }); // true

<tt>array-like/ensure</tt>

If given argument is an array-like, it is returned back. Otherwise TypeError is thrown.

const ensureArrayLike = require("type/array-like/ensure");
ensureArrayLike({ length: 0 }); // { length: 0 }
ensureArrayLike("foo", { allowString: true }); // "foo"
ensureArrayLike({}); // Thrown TypeError: null is not an iterable

Array length

number primitive that conforms as valid array length

array-length/coerce

Follows safe-integer/coerce but returns null in place of values which are below 0

const coerceToArrayLength = require("type/safe-integer/coerce");
coerceToArrayLength("12.95"); // 12
coerceToArrayLength(9007199254740992); // null
coerceToArrayLength(null); // null

array-length/ensure

If given argument is an array length coercible value (via array-length/coerce) returns result number. Otherwise TypeError is thrown.

const ensureArrayLength = require("type/array-length/ensure");
ensureArrayLength(12.93); // "12"
ensureArrayLength(9007199254740992); // Thrown TypeError: null is not a valid array length

Iterable

Value which implements iterable protocol

<tt>iterable/is</tt>

Confirms if given object is an iterable and is not a string (unless allowString option is passed)

const isIterable = require("type/iterable/is");
isIterable([]); // true
isIterable({}); // false
isIterable("foo"); // false
isIterable("foo", { allowString: true }); // true

Supports also denyEmpty option

isIterable([], { denyEmpty: true }); // false
isIterable(["foo"], { denyEmpty: true }); // true

<tt>iterable/ensure</tt>

If given argument is an iterable, it is returned back. Otherwise TypeError is thrown.

const ensureIterable = require("type/iterable/ensure");
ensureIterable([]); // []
ensureIterable("foo", { allowString: true }); // "foo"
ensureIterable({}); // Thrown TypeError: null is not expected iterable

Additionally items can be coreced with coerceItem option. Note that in this case:

  • A newly created array with coerced values is returned
  • Validation crashes if any of the items is not coercible
ensureIterable(new Set(["foo", 12])); // ["foo", "12"]
ensureIterable(new Set(["foo", {}])); // Thrown TypeError: Set({ "foo", {} }) is not expected iterable

Date

Date instance

<tt>date/is</tt>

Confirms if given object is a native date, and is not an Invalid Date

const isDate = require("type/date/is");
isDate(new Date()); // true
isDate(new Date("Invalid date")); // false
isDate(Date.now()); // false
isDate("foo"); // false

<tt>date/ensure</tt>

If given argument is a date object, it is returned back. Otherwise TypeError is thrown.

const ensureDate = require("type/date/ensure");
const date = new Date();
ensureDate(date); // date
ensureDate(123123); // Thrown TypeError: 123123 is not a date object

Time value

number primitive which is a valid time value (as used internally in Date instances)

<tt>time-value/coerce</tt>

Follows integer/coerce but returns null in place of values which go beyond 100 000 0000 days from unix epoch

const coerceToTimeValue = require("type/time-value/coerce");
coerceToTimeValue(12312312); // true
coerceToTimeValue(Number.MAX_SAFE_INTEGER); // false
coerceToTimeValue("foo"); // false

time-value/ensure

If given argument is a time value coercible value (via time-value/coerce) returns result number. Otherwise TypeError is thrown.

const ensureTimeValue = require("type/time-value/ensure");
ensureTimeValue(12.93); // "12"
ensureTimeValue(Number.MAX_SAFE_INTEGER); // Thrown TypeError: null is not a natural number

Function

Function instance

<tt>function/is</tt>

Confirms if given object is a native function

const isFunction = require("type/function/is");
isFunction(function () {}); // true
isFunction(() => {}); // true
isFunction(class {}); // true
isFunction("foo"); // false

<tt>function/ensure</tt>

If given argument is a function object, it is returned back. Otherwise TypeError is thrown.

const ensureFunction = require("type/function/ensure");
const fn = function () {};
ensureFunction(fn); // fn
ensureFunction(/foo/); // Thrown TypeError: /foo/ is not a function

Plain Function

A Function instance that is not a Class

plain-function/is

Confirms if given object is a plain function

const isPlainFunction = require("type/plain-function/is");
isPlainFunction(function () {}); // true
isPlainFunction(() => {}); // true
isPlainFunction(class {}); // false
isPlainFunction("foo"); // false

plain-function/ensure

If given argument is a plain function object, it is returned back. Otherwise TypeError is thrown.

const ensurePlainFunction = require("type/function/ensure");
const fn = function () {};
ensurePlainFunction(fn); // fn
ensurePlainFunction(class {}); // Thrown TypeError: class is not a plain function

RegExp

RegExp instance

<tt>reg-exp/is</tt>

Confirms if given object is a native regular expression object

const isRegExp = require("type/reg-exp/is");
isRegExp(/foo/);
isRegExp({}); // false
isRegExp("foo"); // false

<tt>reg-exp/ensure</tt>

If given argument is a regular expression object, it is returned back. Otherwise TypeError is thrown.

const ensureRegExp = require("type/reg-exp/ensure");
ensureRegExp(/foo/); // /foo/
ensureRegExp("foo"); // Thrown TypeError: null is not a regular expression object

Promise

Promise instance

<tt>promise/is</tt>

Confirms if given object is a native promise

const isPromise = require("type/promise/is");
isPromise(Promise.resolve()); // true
isPromise({ then: () => {} }); // false
isPromise({}); // false

promise/ensure

If given argument is a promise, it is returned back. Otherwise TypeError is thrown.

const ensurePromise = require("type/promise/ensure");
const promise = Promise.resolve();
ensurePromise(promise); // promise
eensurePromise({}); // Thrown TypeError: [object Object] is not a promise

Thenable

Thenable object (an object with then method)

thenable/is

Confirms if given object is a thenable

const isThenable = require("type/thenable/is");
isThenable(Promise.resolve()); // true
isThenable({ then: () => {} }); // true
isThenable({}); // false

thenable/ensure

If given argument is a thenable object, it is returned back. Otherwise TypeError is thrown.

const ensureThenable = require("type/thenable/ensure");
const promise = Promise.resolve();
ensureThenable(promise); // promise
ensureThenable({}); // Thrown TypeError: [object Object] is not a thenable object

Error

Error instance

<tt>error/is</tt>

Confirms if given object is a native error object

const isError = require("type/error/is");
isError(new Error()); // true
isError({ message: "Fake error" }); // false

<tt>error/ensure</tt>

If given argument is an error object, it is returned back. Otherwise TypeError is thrown.

const ensureError = require("type/error/ensure");
const someError = new Error("Some error");
ensureError(someError); // someError
ensureError({ message: "Fake error" }); // Thrown TypeError: [object Object] is not an error object

Prototype

Some constructor's prototype property

<tt>prototype/is</tt>

Confirms if given object serves as a prototype property

const isPrototype = require("type/prototype/is");
isPrototype({}); // false
isPrototype(Object.prototype); // true
isPrototype(Array.prototype); // true

Tests

$ npm test