bdn-pocket/es/types.js

pocket tools for managing redux and redux-saga

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.mixed = exports.array = exports.object = exports.string = exports.bool = exports.func = exports.number = exports.Type = 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 && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var _it = require('@stamp/it');

var _it2 = _interopRequireDefault(_it);

var _argOverProp = require('@stamp/arg-over-prop');

var _isNil = require('ramda/src/isNil');

var _isNil2 = _interopRequireDefault(_isNil);

var _prop = require('ramda/src/prop');

var _prop2 = _interopRequireDefault(_prop);

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

var _has2 = _interopRequireDefault(_has);

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

var Type = exports.Type = (0, _it2.default)((0, _argOverProp.argOverProp)('required', 'name', 'allowNull')).props({
  required: true, // key required
  type: null,
  name: null,
  allowNull: false // null value allowed
}).methods({
  isValid: function isValid() {
    var o = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    var name = arguments[1];

    var propName = name || this.name;
    var hasProp = (0, _has2.default)(propName, o);
    var v = (0, _prop2.default)(propName, o);
    var isEmpty = (0, _isNil2.default)(v);
    if (this.required) {
      if (hasProp === false) {
        throw new Error('prop \'' + propName + '\' is required but missing');
      }
    }
    if (isEmpty === true && this.allowNull === false && hasProp === true) {
      throw new Error('prop \'' + propName + '\' does not allow null value');
    }

    if (isEmpty === false && this.isTypeOk(v) === false) {
      var typeOfV = this.getType(v);
      throw new Error('prop \'' + propName + '\' expect type ' + this.type + ' but received ' + typeOfV);
    }

    return true;
  },


  /**
   * override using Stamp functionality
   *
   *    const newType = Type
   *      .props({ type: 'newType' })
   *      .methods({
   *        isTypeOk(v) {
   *          return // make your test here
   *        }
   *      })
   * @param {*} v
   */
  isTypeOk: function isTypeOk(v) {
    if ((0, _isNil2.default)(this.type) === true) return true;
    return (typeof v === 'undefined' ? 'undefined' : _typeof(v)) === this.type;
  },
  getType: function getType(v) {
    var type = typeof v === 'undefined' ? 'undefined' : _typeof(v);
    if (type === 'object') {
      return Array.isArray(v) ? 'array' : 'object';
    } else {
      return type;
    }
  }
});

var number = exports.number = Type.props({ type: 'number' });
var func = exports.func = Type.props({ type: 'function' });
var bool = exports.bool = Type.props({ type: 'boolean' });
var string = exports.string = Type.props({ type: 'string' });

var object = exports.object = Type.props({ type: 'object' }).methods({
  isTypeOk: function isTypeOk(v) {
    return this.getType(v) === 'object';
    // return (typeof v === 'object') && !Array.isArray(v)
  }
});

var array = exports.array = Type.props({ type: 'array' }).methods({
  isTypeOk: function isTypeOk(v) {
    return this.getType(v) === 'array';
    //  return Array.isArray(v)
  }
});

var mixed = exports.mixed = Type.props({ type: 'mixed' }).methods({
  isTypeOk: function isTypeOk() {
    return true;
  }
});

var Types = {
  number: number,
  func: func,
  object: object,
  // shape: () => null,
  bool: bool,
  string: string,
  array: array,
  mixed: mixed
};

exports.default = Types;