@fpc/types

This package exposes a few utilities for dynamic type checking. The aim is to provide a better developer experience to users who haven't adopted a static type system like typescript.

Consider the following code:

const fetchWeather = () =>
  fetch('https://api.weather.gov/stations/KPTK/observations/latest')
    .then(resp => resp.json());

const listeners = [];

const addWeatherListener = fn =>
  listeners.push(fn);

setInterval(() =>
  fetchWeather().then(data =>
    listeners.forEach(listener => listener(data))
  )
, 10000);

If something that isn't a function is accidentally passed to addWeatherListener, we'll get an error like TypeError: listener is not a function, and the stacktrace will report the line with the listener(data) call.

Unfortunately it won't containt the call to addWeatherListener, namely the line that mistakenly passed the wrong value, so the stacktrace is basically useless in finding the bug.

A dynamic type check can be added in addWeatherListener to detect the wrong type immediately:

import { expectFunction } from '@fpc/types';

const addWeatherListener = fn =>
  listeners.push(expectFunction(fn));

Now addWeatherListener(null) throws TypeError: Expected function, got null.

API

isArray

Alias for Array.isArray

isBoolean

Shortcut for typeof val === 'boolean'

isFunction

Shortcut for typeof val === 'function'

isInteger

Alias for Number.isSafeInteger

isIterable

Checks if an object implements the iterable protocol

isNumber

Checks if a value is a number, excludes Infinity, -Infinity and NaN.

isObject

Checks if a value is a non-null object. Functions are considered objects since in javascript they are implemented as Function object.

Functions have the same interface as every other plain object, so there's no point in return false on functions.

E.g.:

const obj = () => null;
obj.x1 = 10;
console.log({ ...obj, x2: 20 }); // { x1: 10, x2: 20 }

isPromise

Checks if an object is thenable.

N.b.: thenable objects may not be standard promises.

import { isPromise } from '@fpc/types';

if (isPromise(obj)) {
  obj.then(console.log, console.error); // ← this cannot fail
  obj.then(console.log).catch(console.error); // `catch` method may not be defined
}

isString

Shortcut for typeof val === 'string'

isSymbol

Shortcut for typeof val === 'symbol'

typeOf

Works like built-in typeof with the following differences:

• typeOf(null) === 'null'
• typeOf(NaN) === 'NaN'
• typeOf(±Infinity) === 'infinity'

expect*

Every is* function has an expect* counterpart. For example expectInteger(5) returns 5, expectInteger(null) throws TypeError: Expected integer, got null.