@mintlab/kitchen-sink/dist/object.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getObject = getObject;
exports.purge = purge;
exports.extract = extract;
exports.get = get;
exports.performGetOnProperties = performGetOnProperties;
exports.filterProperties = filterProperties;
exports.filterPropertiesOnValues = filterPropertiesOnValues;
exports.isObject = exports.cloneWithout = void 0;

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }

function _iterableToArrayLimit(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"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

var keys = Object.keys,
    entries = Object.entries;
/**
 * Get a shallow clone of an object without the specified properties.
 *
 * @param {Object} object
 * @param {*} exclusions
 * @return {Object}
 */

var cloneWithout = function cloneWithout(object) {
  for (var _len = arguments.length, exclusions = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
    exclusions[_key - 1] = arguments[_key];
  }

  return keys(object).reduce(function (accumulator, key) {
    if (!exclusions.includes(key)) {
      accumulator[key] = object[key];
    }

    return accumulator;
  }, {});
};
/**
 * @param {Object|string} value
 * @return {boolean}
 */


exports.cloneWithout = cloneWithout;

var isObject = function isObject(value) {
  return typeof value !== 'string';
};
/**
 * @param {Array} array
 * @return {Object}
 */


exports.isObject = isObject;

function getObject(array) {
  var _array$filter = array.filter(function (value) {
    return isObject(value);
  }),
      _array$filter2 = _slicedToArray(_array$filter, 2),
      object = _array$filter2[0],
      invalid = _array$filter2[1];

  if (object === undefined) {
    throw new TypeError('no object');
  }

  if (invalid !== undefined) {
    throw new TypeError('multiple objects');
  }

  return object;
}
/**
 * @param {Array} rest
 * @return {Object}
 */


function purge() {
  for (var _len2 = arguments.length, rest = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
    rest[_key2] = arguments[_key2];
  }

  var object = getObject(rest);
  return entries(object).reduce(function (accumulator, _ref) {
    var _ref2 = _slicedToArray(_ref, 2),
        key = _ref2[0],
        value = _ref2[1];

    if (!rest.includes(key)) {
      accumulator[key] = value;
    }

    return accumulator;
  }, {});
}
/**
 * @param rest
 * @return {Array}
 */


function extract() {
  for (var _len3 = arguments.length, rest = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
    rest[_key3] = arguments[_key3];
  }

  var object = getObject(rest);

  var map = function map(value) {
    if (value === object) {
      return purge.apply(void 0, rest);
    }

    return object[value];
  };

  return rest.map(map);
} // ZS-FIXME: complicated and unreadable.
// 1) add ESDoc documentation for function purpose, paramaters and return value
// 2) write unit tests
// 3) enable ESLint
// 4) refactor

/*eslint-disable*/


function get(obj, path, def) {
  var fullPath = path.replace(/\[/g, '.').replace(/]/g, '').split('.').filter(Boolean);
  if (!obj) return def || undefined;
  return fullPath.every(everyFunc) ? obj : def;

  function everyFunc(step) {
    return !(step && obj && (obj = obj[step]) === undefined);
  }
}
/**
 * @param {Object} object
 * @param {Object} paramGetters
 * @return {Object}
 */


function performGetOnProperties(object, paramGetters) {
  return keys(object).reduce(function (acc, param) {
    acc[param] = get(object, paramGetters[param]);
    return acc;
  }, {});
}
/**
 * @param {Object} object
 * @param rest
 * @return {Object}
 */


function filterProperties(object) {
  for (var _len4 = arguments.length, rest = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
    rest[_key4 - 1] = arguments[_key4];
  }

  return rest.reduce(function addProperty(accumulator, x) {
    if (object.hasOwnProperty(x)) {
      accumulator[x] = object[x];
    }

    return accumulator;
  }, {});
}

function filterPropertiesOnValues(object, filter) {
  return keys(object).reduce(function filterProps(accumulator, x) {
    if (filter(object[x])) {
      accumulator[x] = object[x];
    }

    return accumulator;
  }, {});
}