mezzanine/lib/verify.js

Fantasy land union types with pattern matching

'use strict';Object.defineProperty(exports, "__esModule", { value: true });exports.validateMono = exports.isSingleAlike = exports.isSingleProof = undefined;

var _ramda = require('ramda');


























// interface ModelCheck {
//   ()
// }

var proofCase = {
  native: rule =>
  rule === Number ||
  rule === String ||
  rule === Boolean ||
  rule === Object ||
  rule === Array ||
  rule === Function ||
  rule === RegExp ||
  rule === Symbol,
  func: rule => typeof rule === 'function',
  model: rule =>
  typeof rule === 'function' &&
  rule.ಠ_ಠ !== undefined &&
  typeof rule.is === 'function',
  obj: rule => typeof rule === 'object'


  /**
                                         *
                                         * @deprecated
                                         */ };
var isSingleProof = exports.isSingleProof = (proof
//  proofCase.model(proof)
) => proofCase.native(proof) ||
proofCase.func(proof);

var isSingleAlike = exports.isSingleAlike = proof =>
typeof proof === 'object' &&
Object.keys(proof).length === 1 &&
Object.keys(proof)[0] === 'value';

var validateMono = exports.validateMono =
proof =>
(data, dataKey) => {
  if (proof === Number ||
  proof === String ||
  proof === Boolean ||
  proof === Object ||
  proof === Array ||
  proof === Function ||
  proof === RegExp ||
  proof === Symbol) return (0, _ramda.is)(proof, data);else
  if (typeof proof === 'function' &&
  proof.ಠ_ಠ !== undefined &&
  typeof proof.is === 'function')
  return proof.is(data);else
  if (typeof proof === 'function') return proof(data, dataKey);
  return false;
};

var canAccessKeys = data =>
typeof data === 'object' ||
proofCase.model(data);

function validate(proof, data, dataKey) {
  if (proofCase.native(proof)) return (0, _ramda.is)(proof, data);
  //$FlowIssue
  if (proofCase.model(proof)) return proof.is(data);
  if (typeof proof === 'function') return proof(data, dataKey);
  if (proof == null) return false;
  if (data == null) return false;
  if (proofCase.obj(proof) && canAccessKeys(data)) {
    proof;
    var tProof = proof;
    var typeKeys = Object.keys(tProof);
    if (typeKeys.length === 0) return true;
    for (var _iterator = typeKeys, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {var _ref;if (_isArray) {if (_i >= _iterator.length) break;_ref = _iterator[_i++];} else {_i = _iterator.next();if (_i.done) break;_ref = _i.value;}var typeKey = _ref;
      var rule = tProof[typeKey];
      //$FlowIssue
      var property = data[typeKey];
      var result = validate(rule, property, typeKey);
      if (!result) return false;
    }
    return true;
  }
  return false;
}exports.default =

validate;
//# sourceMappingURL=verify.js.map