sophia-components/build/utils/helpers.js

Sophia React Components based on bulma.io

'use strict';

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

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 _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; };

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 _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 _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-param-reassign,import/prefer-default-export,no-confusing-arrow */
var decamelize = function decamelize(str) {
  return str.replace(/[^a-zA-Z0-9]+/g, '-').replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2').replace(/([a-z])([A-Z])/g, '$1-$2').replace(/([0-9])([^0-9])/g, '$1-$2').replace(/([^0-9])([0-9])/g, '$1-$2').replace(/-+/g, '-').toLowerCase();
};

var getClassString = function getClassString(_ref) {
  var item = _ref.item,
      prefix = _ref.prefix,
      value = _ref.value;

  if (Array.isArray(value)) {
    return value.reduce(function (acum, val) {
      return [].concat(_toConsumableArray(acum), _toConsumableArray(getClassString({ item: item, prefix: prefix, value: val })));
    }, []);
  }
  var additionalStr = typeof value === 'string' ? '-' + value : '';
  return [prefix + '-' + decamelize(item, '-') + additionalStr];
};

var getUniqueValuesArray = function getUniqueValuesArray(array) {
  return [].concat(_toConsumableArray(new Set(array)));
};

var keyProcessor = exports.keyProcessor = function keyProcessor(prefix, prefixKey, keys, props) {
  if (prefix && prefix.length) {
    return getUniqueValuesArray(prefix.map(function (item) {
      return prefixKey + '-' + item;
    }));
  }
  var filtered = keys.filter(function (item) {
    return props[item];
  });
  if (filtered.length) {
    var classArray = filtered.reduce(function (acum, item) {
      var value = props[item];
      return [].concat(_toConsumableArray(acum), _toConsumableArray(getClassString({ item: item, prefix: prefixKey, value: value })));
    }, []);
    return getUniqueValuesArray(classArray);
  }
  return [];
};
// Convert props to the is-key className
var processor = function processor(isKeys, hasKeys, _ref2) {
  var is = _ref2.is,
      has = _ref2.has,
      original = _ref2.className,
      restProps = _objectWithoutProperties(_ref2, ['is', 'has', 'className']);

  var className = typeof original === 'string' ? original.split(' ') : [].concat(_toConsumableArray(original));
  var freeProps = Object.keys(restProps).reduce(function (acum, key) {
    if (!isKeys.includes(key) && !hasKeys.includes(key)) {
      return _extends({}, acum, _defineProperty({}, key, restProps[key]));
    }
    return acum;
  }, {});
  var isClasses = keyProcessor(is, 'is', isKeys, restProps);
  var hasClasses = keyProcessor(has, 'has', hasKeys, restProps);
  var classNameUniques = new Set([].concat(_toConsumableArray(className), _toConsumableArray(isClasses), _toConsumableArray(hasClasses)));
  return { className: [].concat(_toConsumableArray(classNameUniques)), props: freeProps };
};

exports.processor = processor;
var combineSets = exports.combineSets = function combineSets() {
  for (var _len = arguments.length, sets = Array(_len), _key = 0; _key < _len; _key++) {
    sets[_key] = arguments[_key];
  }

  var combined = sets.reduce(function (acum, set) {
    return [].concat(_toConsumableArray(acum), _toConsumableArray(set));
  }, []);
  return [].concat(_toConsumableArray(new Set(combined)));
};

var classNameJoiner = exports.classNameJoiner = function classNameJoiner() {
  for (var _len2 = arguments.length, pieces = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
    pieces[_key2] = arguments[_key2];
  }

  return pieces.filter(function (piece) {
    return piece;
  }).join(' ');
};

var propTypeArrayChecker = exports.propTypeArrayChecker = function propTypeArrayChecker(possibleTypes) {
  return function (propValue, key, componentName, location, propFullName) {
    if (!possibleTypes.includes(propValue[key].type.displayName)) {
      return new Error('Invalid prop `' + propFullName + '` supplied to' + (' `' + componentName + '`. Validation failed.'));
    }
    return true;
  };
};
var propTypeChecker = exports.propTypeChecker = function propTypeChecker(possibleTypes) {
  return function (propValue, componentName, location, propFullName) {
    if (!possibleTypes.includes(propValue.type.displayName)) {
      return new Error('Invalid prop `' + propFullName + '` supplied to' + (' `' + componentName + '`. Validation failed.'));
    }
    return true;
  };
};
var capitalizeFirstLetter = exports.capitalizeFirstLetter = function capitalizeFirstLetter(str) {
  return str.charAt(0).toUpperCase() + str.slice(1);
};

var propsSegregator = exports.propsSegregator = function propsSegregator(props, segregators) {
  var segKeys = Object.keys(segregators);
  var initialAcum = segKeys.reduce(function (acum, key) {
    return _extends({}, acum, _defineProperty({}, key, {}));
  }, {});
  return Object.entries(props).reduce(function (acum, _ref3) {
    var _ref4 = _slicedToArray(_ref3, 2),
        key = _ref4[0],
        value = _ref4[1];

    // eslint-disable-next-line no-cond-assign
    for (var i = 0, segKey; segKey = segKeys[i]; i += 1) {
      if (segregators[segKey].includes(key)) {
        return _extends({}, acum, _defineProperty({}, segKey, _extends({}, acum[segKey], _defineProperty({}, key, value))));
      }
    }
    return acum;
  }, initialAcum);
};