immutable-validation/lib/util.js

Data validation using immutable data structures

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.isIterable = undefined;

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };

exports.noop = noop;
exports.isFunction = isFunction;
exports.isString = isString;
exports.isObject = isObject;
exports.isNumber = isNumber;
exports.isBoolean = isBoolean;
exports.maybeHas = maybeHas;
exports.iterableLength = iterableLength;
exports.unwrapImmutable = unwrapImmutable;
exports.get = get;
exports.assert = assert;
exports.assertFor = assertFor;
exports.liftToArray = liftToArray;
exports.asCallable = asCallable;

var _type = require('ramda/src/type');

var _type2 = _interopRequireDefault(_type);

var _partial = require('ramda/src/partial');

var _partial2 = _interopRequireDefault(_partial);

var _has = require('ramda/src/has');

var _has2 = _interopRequireDefault(_has);

var _hasIn = require('ramda/src/hasIn');

var _hasIn2 = _interopRequireDefault(_hasIn);

var _both = require('ramda/src/both');

var _both2 = _interopRequireDefault(_both);

var _is = require('ramda/src/is');

var _is2 = _interopRequireDefault(_is);

var _either = require('ramda/src/either');

var _either2 = _interopRequireDefault(_either);

var _isArrayLike = require('ramda/src/isArrayLike');

var _isArrayLike2 = _interopRequireDefault(_isArrayLike);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function noop() {
    return undefined;
}

function isFunction(obj) {
    return (0, _type2.default)(obj) === 'Function';
}

function isString(obj) {
    return (0, _type2.default)(obj) === 'String';
}

function isObject(obj) {
    return (0, _type2.default)(obj) === 'Object';
}

function isNumber(obj) {
    return (0, _type2.default)(obj) === 'Number';
}

function isBoolean(obj) {
    return (0, _type2.default)(obj) === 'Boolean';
}

function maybeHas(prop) {
    return (0, _both2.default)((0, _is2.default)(Object), (0, _has2.default)(prop));
}

var isIterable = exports.isIterable = (0, _both2.default)((0, _is2.default)(Object), (0, _either2.default)((0, _hasIn2.default)('length'), (0, _hasIn2.default)('size')));

function iterableLength(iter) {
    if (!isIterable(iter)) return 0;
    if (iter.size) return iter.size;
    return iter.length;
}

function unwrapImmutable(maybeImmutable) {
    if (!maybeImmutable) return maybeImmutable;
    if (isFunction(maybeImmutable.toJS)) return maybeImmutable.toJS();
    return maybeImmutable;
}

function get(maybeImmutable, propOrIndex) {
    if (!maybeImmutable || (typeof maybeImmutable === 'undefined' ? 'undefined' : _typeof(maybeImmutable)) !== 'object') return maybeImmutable;
    if (isFunction(maybeImmutable.get)) return maybeImmutable.get(propOrIndex);
    return maybeImmutable[propOrIndex];
}

function assert(expr, err) {
    if (!expr) throw err;
}

function assertFor(predicate, err, val) {
    assert(predicate(val), err);
    return val;
}

function liftToArray(val) {
    return (0, _isArrayLike2.default)(val) ? val : [val];
}

/**
 * Ensures that the given argument can be called as a function:
 *
 *    var definitelyFn = asCallable(maybeFn);
 *    definitelyFn(); // calling maybeFn would throw if maybeFn is not a function
 *
 * @param {*} maybeFn - value to ensure is callable
 * @param {string|function} instead - function to call if maybeFn is not callable, OR the string 'identity' to return the value of maybeFn
 * @returns {function}
 */
function asCallable(maybeFn, instead) {
    if (isFunction(maybeFn)) return maybeFn;
    if (isFunction(instead)) return (0, _partial2.default)(instead, [maybeFn]);
    return noop;
}