maycur-business/lib/utils/slimLodash.js

maycur business react components of web

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }

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

function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }

function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

var hasOwnProperty = Object.prototype.hasOwnProperty;

function isObject(value) {
  var type = _typeof(value);

  return value != null && (type === 'object' || type === 'function');
}

function isArray(value) {
  if (!checkEmpty(value)) return false;
  return Array.isArray(value);
}
/* 只对Array和Object有效 */


function isEmpty(value) {
  if (!checkEmpty(value)) return true;

  if (isArray(value)) {
    return value.length === 0;
  } else if (isObject(value)) {
    return Object.keys(value).length === 0;
  }
}

function checkEmpty(par) {
  if (par === undefined) return false;
  if (par === null) return false;
  if (!par) return false;
  return true;
}

function has(object, key) {
  return object != null && hasOwnProperty.call(object, key);
}

function forEach(collection, iteratee) {
  if (collection === undefined || collection === null) return;

  if (Array.isArray(collection)) {
    return collection.forEach(iteratee);
  } else if (isObject(collection)) {
    Object.keys(collection).forEach(function (key) {
      if (typeof iteratee === 'function') {
        iteratee(collection[key], key);
      }
    });
  }
}

function union() {
  var array1 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
  var array2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
  if (!array1) return array2;
  if (!array2) return array1;
  return _toConsumableArray(new Set([].concat(_toConsumableArray(array1), _toConsumableArray(array2))));
}

function find(par, iteratee) {
  if (checkEmpty(par) && Array.isArray(par)) {
    return par.find(iteratee);
  }
}

function findIndex(par, iteratee) {
  if (checkEmpty(par) && Array.isArray(par)) {
    return par.findIndex(iteratee);
  }
}

function last(value) {
  if (!isArray(value)) return;
  if (isEmpty(value)) return;
  return value[value.length - 1];
}

function includes(collection, name) {
  if (!isArray(collection) || !checkEmpty(name)) return false;

  if (isArray(collection)) {
    return collection.includes(name);
  } else {
    return false;
  }
}

function map(array, iteratee) {
  var index = -1;
  var length = array == null ? 0 : array.length;
  var result = new Array(length);

  while (++index < length) {
    result[index] = iteratee(array[index], index, array);
  }

  return result;
}

function pick(object, keys) {
  return keys.reduce(function (obj, key) {
    if (object && object.hasOwnProperty(key)) {
      obj[key] = object[key];
    }

    return obj;
  }, {});
}

var slimLodash = {
  has: has,
  forEach: forEach,
  union: union,
  find: find,
  isObject: isObject,
  isArray: isArray,
  isEmpty: isEmpty,
  last: last,
  includes: includes,
  checkEmpty: checkEmpty,
  map: map,
  findIndex: findIndex,
  pick: pick
};
var _default = slimLodash;
exports["default"] = _default;