sophia-components/build/base/withAttrs.js

Sophia React Components based on bulma.io

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.attrSets = exports.tdAttrs = exports.selectAttrs = exports.textAreaAttrs = exports.fileAttrs = exports.radioAttrs = exports.checkboxAttrs = exports.inputAttrs = exports.aAttrs = exports.allAttrs = exports.labelAttrs = exports.defaultAttrs = undefined;

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _react = require('react');

var _react2 = _interopRequireDefault(_react);

var _propTypes = require('prop-types');

var _propTypes2 = _interopRequireDefault(_propTypes);

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

function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } /* eslint-disable no-confusing-arrow */


var mappedAttrs = {
  id: _propTypes2.default.string,
  className: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.arrayOf(_propTypes2.default.string)]),
  style: _propTypes2.default.shape(),
  disabled: _propTypes2.default.bool,
  readOnly: _propTypes2.default.bool,
  checked: _propTypes2.default.bool,
  name: _propTypes2.default.string,
  title: _propTypes2.default.string,
  href: _propTypes2.default.string,
  role: _propTypes2.default.string,
  target: _propTypes2.default.oneOf(['_blank', '_self', 'blank', 'self']),
  value: _propTypes2.default.any,
  type: _propTypes2.default.oneOf(['button', 'checkbox', 'color', 'date', 'datetime-local', 'email', 'file', 'hidden', 'image', 'month', 'number', 'password', 'radio', 'range', 'reset', 'search', 'submit', 'tel', 'text', 'time', 'url', 'week']),
  placeholder: _propTypes2.default.string,
  rows: _propTypes2.default.string,
  for: _propTypes2.default.string,
  size: _propTypes2.default.string,
  colspan: _propTypes2.default.string,
  headers: _propTypes2.default.string,
  rowspan: _propTypes2.default.string,
  scope: _propTypes2.default.string
};

var dummyConverter = function dummyConverter(val) {
  return val;
};
var classNameConverter = function classNameConverter(val) {
  if (typeof val === 'string') {
    return val;
  }
  if (Array.isArray(val) && val.length) {
    return val.join(' ');
  }
  return null;
};

var converterAttrs = {
  id: dummyConverter,
  className: classNameConverter,
  style: dummyConverter,
  for: dummyConverter,
  disabled: dummyConverter,
  checked: dummyConverter,
  readOnly: dummyConverter,
  name: dummyConverter,
  title: dummyConverter,
  href: dummyConverter,
  role: dummyConverter,
  target: dummyConverter,
  type: dummyConverter,
  placeholder: dummyConverter,
  rows: dummyConverter,
  size: dummyConverter,
  value: dummyConverter,
  colspan: dummyConverter,
  headers: dummyConverter,
  rowspan: dummyConverter,
  scope: dummyConverter
};

var acceptedAttrs = Object.keys(converterAttrs);
var defaultAttrs = exports.defaultAttrs = ['id', 'className', 'style', 'role'];
var labelAttrs = exports.labelAttrs = [].concat(defaultAttrs, ['for']);
var allAttrs = exports.allAttrs = [].concat(_toConsumableArray(acceptedAttrs));
var aAttrs = exports.aAttrs = ['href', 'target', 'title', 'name'];
var inputAttrs = exports.inputAttrs = ['name', 'type', 'value', 'disabled', 'placeholder', 'readOnly'];
var checkboxAttrs = exports.checkboxAttrs = ['name', 'checked', 'disabled', 'placeholder', 'readOnly'];
var radioAttrs = exports.radioAttrs = ['name', 'value', 'checked', 'disabled', 'placeholder', 'readOnly'];
var fileAttrs = exports.fileAttrs = ['name', 'value', 'disabled', 'readOnly'];
var textAreaAttrs = exports.textAreaAttrs = ['name', 'value', 'disabled', 'placeholder', 'readOnly', 'rows'];
var selectAttrs = exports.selectAttrs = ['name', 'value', 'disabled', 'placeholder', 'readOnly', 'size'];
var tdAttrs = exports.tdAttrs = ['colspan', 'headers', 'rowspan', 'scope'];
var attrSets = exports.attrSets = {
  defaultAttrs: defaultAttrs,
  aAttrs: aAttrs,
  inputAttrs: inputAttrs,
  tdAttrs: tdAttrs,
  allAttrs: allAttrs
};

var withAttrs = function withAttrs() {
  var attrs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultAttrs;
  var skipNulls = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;

  // Validations and warnings
  if (!attrs.length) {
    console.warn('At least one attribute must be passed');
  }
  attrs.forEach(function (attr, index) {
    if (typeof attr !== 'string') {
      console.warn('Invalid attribute at array index', index);
    }
  });
  var invalidAttrs = attrs.reduce(function (acum, attr) {
    return acceptedAttrs.includes(attr) ? acum : [].concat(_toConsumableArray(acum), [attr]);
  }, []);
  if (invalidAttrs.length) {
    console.warn('Invalid attributes: ', invalidAttrs.join(', '));
  }
  return function (InnerComponent) {
    var WithAttr = function (_Component) {
      _inherits(WithAttr, _Component);

      function WithAttr() {
        _classCallCheck(this, WithAttr);

        return _possibleConstructorReturn(this, (WithAttr.__proto__ || Object.getPrototypeOf(WithAttr)).apply(this, arguments));
      }

      _createClass(WithAttr, [{
        key: 'render',
        value: function render() {
          var propsToBePassed = Object.entries(this.props).reduce(function (acum, _ref) {
            var _ref2 = _slicedToArray(_ref, 2),
                key = _ref2[0],
                value = _ref2[1];

            if (attrs.includes(key)) {
              var converted = converterAttrs[key](value);
              if (skipNulls && (converted === null || converted === undefined)) {
                return acum;
              }
              return _extends({}, acum, { attrs: _extends({}, acum.attrs, _defineProperty({}, key, converted)) });
            }
            return _extends({}, acum, _defineProperty({}, key, value));
          }, { attrs: {} });
          return _react2.default.createElement(InnerComponent, propsToBePassed);
        }
      }]);

      return WithAttr;
    }(_react.Component);

    var attrPropTypes = attrs.reduce(function (acum, key) {
      return _extends({}, acum, _defineProperty({}, key, mappedAttrs[key]));
    }, {});
    if (!InnerComponent.propTypes) {
      // eslint-disable-next-line no-param-reassign
      InnerComponent.propTypes = {};
    }

    var _InnerComponent$propT = InnerComponent.propTypes,
        removedPropType = _InnerComponent$propT.attrs,
        restPropTypes = _objectWithoutProperties(_InnerComponent$propT, ['attrs']);

    WithAttr.propTypes = _extends({}, restPropTypes, attrPropTypes);
    var attrDefaults = attrs.reduce(function (acum, key) {
      return _extends({}, acum, _defineProperty({}, key, null));
    }, {});
    WithAttr.defaultProps = _extends({}, InnerComponent.defaultProps, attrDefaults);
    WithAttr.displayName = InnerComponent.displayName || InnerComponent.name;
    return WithAttr;
  };
};

exports.default = withAttrs;