New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

functionallibrary

Package Overview
Dependencies
Maintainers
1
Versions
22
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

functionallibrary - npm Package Compare versions

Comparing version

1.0.5
to
1.0.6

.babelrc

6

build/rollup.config.js
import commonjs from '@rollup/plugin-commonjs';
import babel from 'rollup-plugin-babel';

@@ -10,4 +11,7 @@ export default {

plugins: [
commonjs(),
commonjs(),
babel({
exclude: 'node_modules/**'
}),
],
};

798

dist/functionallibrary.umd.js
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
typeof define === 'function' && define.amd ? define(['exports'], factory) :
(global = global || self, factory(global.functionallibrary = {}));
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
typeof define === 'function' && define.amd ? define(['exports'], factory) :
(global = global || self, factory(global.functionallibrary = {}));
}(this, (function (exports) { 'use strict';
const allAreTrue = (...arg) => arg.every(a => a);
var allAreTrue_2 = allAreTrue;
var allAreTrue = function allAreTrue() {
for (var _len = arguments.length, arg = new Array(_len), _key = 0; _key < _len; _key++) {
arg[_key] = arguments[_key];
}
var allAreTrue_1 = {
allAreTrue: allAreTrue_2
};
return arg.every(function (a) {
return a;
});
};
const find = (fn, col) => col.find(fn);
const findIndex = (fn, col) => col.findIndex(fn);
const forEach = (fn, col) => col.forEach(fn);
const map = (fn, col) => col.map(fn);
const reduce = (fn, col, acc = []) => col.reduce(fn, acc);
var arrayPrototypes = { find, findIndex, forEach, map, reduce };
var allAreTrue_2 = allAreTrue;
var allAreTrue_1 = {
allAreTrue: allAreTrue_2
};
const atLeastOneTrue = (...args) => args.some(a => a);
var atLeastOneTrue_2 = atLeastOneTrue;
var find = function find(fn, col) {
return col.find(fn);
};
var atLeastOneTrue_1 = {
atLeastOneTrue: atLeastOneTrue_2
};
var findIndex = function findIndex(fn, col) {
return col.findIndex(fn);
};
const equality = (...args) => {
let [prop1, prop2] = args;
if (!prop2) {
prop2 = prop1;
}
return function inner(item) {
return typeof item === 'object' ? item[prop1] === prop2 : item === prop1;
};
};
// const people = [{ id: 1, name: 'Noah' }, { id: 2, name; 'Pepe' }, { id: 3, name: 'Luciana' }, { id: 4, name: 'Jose Juan' }];
// const noah = people.find(equality('name', 'Noah')); --> noah = { id: 1, name: 'Noah' }
var equality_2 = equality;
var forEach = function forEach(fn, col) {
return col.forEach(fn);
};
var equality_1 = {
equality: equality_2
};
var map = function map(fn, col) {
return col.map(fn);
};
const { find: find$1 } = arrayPrototypes;
const { equality: equality$1 } = equality_1;
var reduce = function reduce(fn, col) {
var acc = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
return col.reduce(fn, acc);
};
const commonsItemsBetweenArrays = (collection1, collection2) => {
const [arr1, prop1] = collection1;
const [arr2, prop2] = collection2;
const lower = arr1.length <= arr2.length ? arr1 : arr2;
const bigger = lower.length === arr1.length ? arr2 : arr1;
let list = [];
if (prop2) {
lower.forEach((a) => {
const val = prop1 ? a[prop1] : a;
const match = find$1(equality$1(prop2, val), bigger);
if (match) {
list = list.concat(match);
}
});
}
if(
lower.every(a => typeof a === 'string' || typeof a === 'number') &&
bigger.every(a => typeof a === 'string' || typeof a === 'number')
) {
lower.forEach((a) => {
const match = bigger.find(b => a === b);
list = match ? list.concat(match) : list;
});
}
return list;
};
var commonsItemsBetweenArrays_2 = commonsItemsBetweenArrays;
var arrayPrototypes = {
find: find,
findIndex: findIndex,
forEach: forEach,
map: map,
reduce: reduce
};
var commonsItemsBetweenArrays_1 = {
commonsItemsBetweenArrays: commonsItemsBetweenArrays_2
};
var atLeastOneTrue = function atLeastOneTrue() {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
const compose = (...fns) => (...args) => fns.reduceRight((res, fn) => [fn.call(null, ...res)], args)[0];
var compose_2 = compose;
return args.some(function (a) {
return a;
});
};
var compose_1 = {
compose: compose_2
};
var atLeastOneTrue_2 = atLeastOneTrue;
var atLeastOneTrue_1 = {
atLeastOneTrue: atLeastOneTrue_2
};
const getPropertyValue = (args) => {
const propFlow = args.split('.');
return function inner(item) {
let newItem = { ...item };
propFlow.forEach((el) => {
newItem = (newItem || {})[el];
});
return newItem;
};
};
var getPropertyValue_2 = getPropertyValue;
function _typeof(obj) {
"@babel/helpers - typeof";
var getPropertyValue_1 = {
getPropertyValue: getPropertyValue_2
};
if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
_typeof = function (obj) {
return typeof obj;
};
} else {
_typeof = function (obj) {
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
};
}
const { getPropertyValue: getPropertyValue$1 } = getPropertyValue_1;
return _typeof(obj);
}
const createPropertyByOtherOne = (...args) => {
const [prop1, prop2] = args;
return function inner(item) {
let newItem = null;
if (item.length) {
[newItem] = item;
} else {
newItem = { ...item };
}
newItem[prop1] = getPropertyValue$1(prop2)(newItem);
return newItem;
};
};
var createPropertyByOtherOne_2 = createPropertyByOtherOne;
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;
}
var createPropertyByOtherOne_1 = {
createPropertyByOtherOne: createPropertyByOtherOne_2
};
return obj;
}
const debounce = (fn, wait = 200) => { // retarda la ejecucion de una funcion
let timeOut = null;
return function inner(...args) {
clearTimeout(timeOut);
timeOut = setTimeout(fn.bind(this, args), wait);
};
};
var debounce_2 = debounce;
function ownKeys(object, enumerableOnly) {
var keys = Object.keys(object);
var debounce_1 = {
debounce: debounce_2
};
if (Object.getOwnPropertySymbols) {
var symbols = Object.getOwnPropertySymbols(object);
if (enumerableOnly) symbols = symbols.filter(function (sym) {
return Object.getOwnPropertyDescriptor(object, sym).enumerable;
});
keys.push.apply(keys, symbols);
}
const isEmpty = (arg) => {
if (Array.isArray(arg)) {
return arg.length === 0;
}
if (typeof arg === 'object' && arg !== null) {
return Object.keys(arg).length === 0;
}
if (typeof arg === 'string' || typeof arg === 'number') {
return !arg;
}
return !arg;
};
var isEmpty_2 = isEmpty;
return keys;
}
var isEmpty_1 = {
isEmpty: isEmpty_2
};
function _objectSpread2(target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i] != null ? arguments[i] : {};
const { isEmpty: isEmpty$1 } = isEmpty_1;
if (i % 2) {
ownKeys(Object(source), true).forEach(function (key) {
_defineProperty(target, key, source[key]);
});
} else if (Object.getOwnPropertyDescriptors) {
Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
} else {
ownKeys(Object(source)).forEach(function (key) {
Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
});
}
}
const isNotEmpty = arg => !isEmpty$1(arg);
var isNotEmpty_2 = isNotEmpty;
return target;
}
var isNotEmpty_1 = {
isNotEmpty: isNotEmpty_2
};
function _slicedToArray(arr, i) {
return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
}
const mergeObjects = (...objs) => Object.assign({}, ...objs);
var mergeObjects_2 = mergeObjects;
function _toConsumableArray(arr) {
return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
}
var mergeObjects_1 = {
mergeObjects: mergeObjects_2
};
function _arrayWithoutHoles(arr) {
if (Array.isArray(arr)) return _arrayLikeToArray(arr);
}
const removeItemFromArrayByIndex = (index, arr) => {
arr.splice(index, 1);
return arr;
};
var removeItemFromArrayByIndex_2 = removeItemFromArrayByIndex;
function _arrayWithHoles(arr) {
if (Array.isArray(arr)) return arr;
}
var removeItemFromArrayByIndex_1 = {
removeItemFromArrayByIndex: removeItemFromArrayByIndex_2
};
function _iterableToArray(iter) {
if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
}
const { findIndex: findIndex$1 } = arrayPrototypes;
const { removeItemFromArrayByIndex: removeItemFromArrayByIndex$1 } = removeItemFromArrayByIndex_1;
function _iterableToArrayLimit(arr, i) {
if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
var _arr = [];
var _n = true;
var _d = false;
var _e = undefined;
const removeItemFromArrayByProp = (prop, val) => (arr) => {
const index = findIndex$1(a => a[prop] === val, arr);
return removeItemFromArrayByIndex$1(index, arr);
};
var removeItemFromArrayByProp_2 = removeItemFromArrayByProp;
try {
for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
_arr.push(_s.value);
var removeItemFromArrayByProp_1 = {
removeItemFromArrayByProp: removeItemFromArrayByProp_2
};
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;
}
}
const returnUniqueArraysItems = (...arrs) => {
const res = [].concat(...arrs);
const unique = new Set();
res.forEach(item => {
unique.add(JSON.stringify(item));
});
const uniqueParsed = [];
unique.forEach(item => uniqueParsed.push(JSON.parse(item)));
return [].concat(uniqueParsed);
};
var returnUniqueArraysItems_2 = returnUniqueArraysItems;
return _arr;
}
var returnUniqueArraysItems_1 = {
returnUniqueArraysItems: returnUniqueArraysItems_2
};
function _unsupportedIterableToArray(o, minLen) {
if (!o) return;
if (typeof o === "string") return _arrayLikeToArray(o, minLen);
var n = Object.prototype.toString.call(o).slice(8, -1);
if (n === "Object" && o.constructor) n = o.constructor.name;
if (n === "Map" || n === "Set") return Array.from(n);
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
}
const round = decimal => value => Number(value.toFixed(decimal));
var round_2 = round;
function _arrayLikeToArray(arr, len) {
if (len == null || len > arr.length) len = arr.length;
var round_1 = {
round: round_2
};
for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
const setNewProperty = (property, v) => (item, index) => {
const a = { ...item };
a[property] = typeof v === 'function' ? v(item, index) : v;
return a;
};
var setNewProperty_2 = setNewProperty;
return arr2;
}
var setNewProperty_1 = {
setNewProperty: setNewProperty_2
};
function _nonIterableSpread() {
throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
const { allAreTrue: allAreTrue$1 } = allAreTrue_1;
const { find: find$2, findIndex: findIndex$2, forEach: forEach$1, map: map$1, reduce: reduce$1 } = arrayPrototypes;
const { atLeastOneTrue: atLeastOneTrue$1 } = atLeastOneTrue_1;
const { commonsItemsBetweenArrays: commonsItemsBetweenArrays$1 } = commonsItemsBetweenArrays_1;
const { compose: compose$1 } = compose_1;
const { createPropertyByOtherOne: createPropertyByOtherOne$1 } = createPropertyByOtherOne_1;
const { debounce: debounce$1 } = debounce_1;
const { equality: equality$2 } = equality_1;
const { getPropertysValue } = getPropertyValue_1;
const { isEmpty: isEmpty$2 } = isEmpty_1;
const { isNotEmpty: isNotEmpty$1 } = isNotEmpty_1;
const { mergeObjects: mergeObjects$1 } = mergeObjects_1;
const { removeItemFromArrayByIndex: removeItemFromArrayByIndex$2 } = removeItemFromArrayByIndex_1;
const { removeItemFromArrayByProp: removeItemFromArrayByProp$1 } = removeItemFromArrayByProp_1;
const { returnUniqueArraysItems: returnUniqueArraysItems$1 } = returnUniqueArraysItems_1;
const { round: round$1 } = round_1;
const { setNewProperty: setNewProperty$1 } = setNewProperty_1;
function _nonIterableRest() {
throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
var wrapper = {
allAreTrue: allAreTrue$1,
atLeastOneTrue: atLeastOneTrue$1,
commonsItemsBetweenArrays: commonsItemsBetweenArrays$1,
compose: compose$1,
createPropertyByOtherOne: createPropertyByOtherOne$1,
debounce: debounce$1,
equality: equality$2,
find: find$2,
findIndex: findIndex$2,
forEach: forEach$1,
getPropertysValue,
isEmpty: isEmpty$2,
isNotEmpty: isNotEmpty$1,
map: map$1,
mergeObjects: mergeObjects$1,
reduce: reduce$1,
removeItemFromArrayByIndex: removeItemFromArrayByIndex$2,
removeItemFromArrayByProp: removeItemFromArrayByProp$1,
returnUniqueArraysItems: returnUniqueArraysItems$1,
round: round$1,
setNewProperty: setNewProperty$1,
};
var wrapper_1 = wrapper.allAreTrue;
var wrapper_2 = wrapper.atLeastOneTrue;
var wrapper_3 = wrapper.commonsItemsBetweenArrays;
var wrapper_4 = wrapper.compose;
var wrapper_5 = wrapper.createPropertyByOtherOne;
var wrapper_6 = wrapper.debounce;
var wrapper_7 = wrapper.equality;
var wrapper_8 = wrapper.find;
var wrapper_9 = wrapper.findIndex;
var wrapper_10 = wrapper.forEach;
var wrapper_11 = wrapper.getPropertysValue;
var wrapper_12 = wrapper.isEmpty;
var wrapper_13 = wrapper.isNotEmpty;
var wrapper_14 = wrapper.map;
var wrapper_15 = wrapper.mergeObjects;
var wrapper_16 = wrapper.reduce;
var wrapper_17 = wrapper.removeItemFromArrayByIndex;
var wrapper_18 = wrapper.removeItemFromArrayByProp;
var wrapper_19 = wrapper.returnUniqueArraysItems;
var wrapper_20 = wrapper.round;
var wrapper_21 = wrapper.setNewProperty;
var equality = function equality() {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
exports.allAreTrue = wrapper_1;
exports.atLeastOneTrue = wrapper_2;
exports.commonsItemsBetweenArrays = wrapper_3;
exports.compose = wrapper_4;
exports.createPropertyByOtherOne = wrapper_5;
exports.debounce = wrapper_6;
exports.default = wrapper;
exports.equality = wrapper_7;
exports.find = wrapper_8;
exports.findIndex = wrapper_9;
exports.forEach = wrapper_10;
exports.getPropertysValue = wrapper_11;
exports.isEmpty = wrapper_12;
exports.isNotEmpty = wrapper_13;
exports.map = wrapper_14;
exports.mergeObjects = wrapper_15;
exports.reduce = wrapper_16;
exports.removeItemFromArrayByIndex = wrapper_17;
exports.removeItemFromArrayByProp = wrapper_18;
exports.returnUniqueArraysItems = wrapper_19;
exports.round = wrapper_20;
exports.setNewProperty = wrapper_21;
var prop1 = args[0],
prop2 = args[1];
Object.defineProperty(exports, '__esModule', { value: true });
if (!prop2) {
prop2 = prop1;
}
return function inner(item) {
return _typeof(item) === 'object' ? item[prop1] === prop2 : item === prop1;
};
}; // const people = [{ id: 1, name: 'Noah' }, { id: 2, name; 'Pepe' }, { id: 3, name: 'Luciana' }, { id: 4, name: 'Jose Juan' }];
// const noah = people.find(equality('name', 'Noah')); --> noah = { id: 1, name: 'Noah' }
var equality_2 = equality;
var equality_1 = {
equality: equality_2
};
var find$1 = arrayPrototypes.find;
var equality$1 = equality_1.equality;
var commonsItemsBetweenArrays = function commonsItemsBetweenArrays(collection1, collection2) {
var _collection = _slicedToArray(collection1, 2),
arr1 = _collection[0],
prop1 = _collection[1];
var _collection2 = _slicedToArray(collection2, 2),
arr2 = _collection2[0],
prop2 = _collection2[1];
var lower = arr1.length <= arr2.length ? arr1 : arr2;
var bigger = lower.length === arr1.length ? arr2 : arr1;
var list = [];
if (prop2) {
lower.forEach(function (a) {
var val = prop1 ? a[prop1] : a;
var match = find$1(equality$1(prop2, val), bigger);
if (match) {
list = list.concat(match);
}
});
}
if (lower.every(function (a) {
return typeof a === 'string' || typeof a === 'number';
}) && bigger.every(function (a) {
return typeof a === 'string' || typeof a === 'number';
})) {
lower.forEach(function (a) {
var match = bigger.find(function (b) {
return a === b;
});
list = match ? list.concat(match) : list;
});
}
return list;
};
var commonsItemsBetweenArrays_2 = commonsItemsBetweenArrays;
var commonsItemsBetweenArrays_1 = {
commonsItemsBetweenArrays: commonsItemsBetweenArrays_2
};
var compose = function compose() {
for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) {
fns[_key] = arguments[_key];
}
return function () {
for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
args[_key2] = arguments[_key2];
}
return fns.reduceRight(function (res, fn) {
return [fn.call.apply(fn, [null].concat(_toConsumableArray(res)))];
}, args)[0];
};
};
var compose_2 = compose;
var compose_1 = {
compose: compose_2
};
var getPropertyValue = function getPropertyValue(args) {
var propFlow = args.split('.');
return function inner(item) {
var newItem = _objectSpread2({}, item);
propFlow.forEach(function (el) {
newItem = (newItem || {})[el];
});
return newItem;
};
};
var getPropertyValue_2 = getPropertyValue;
var getPropertyValue_1 = {
getPropertyValue: getPropertyValue_2
};
var getPropertyValue$1 = getPropertyValue_1.getPropertyValue;
var createPropertyByOtherOne = function createPropertyByOtherOne() {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
var prop1 = args[0],
prop2 = args[1];
return function inner(item) {
var newItem = null;
if (item.length) {
var _item = _slicedToArray(item, 1);
newItem = _item[0];
} else {
newItem = _objectSpread2({}, item);
}
newItem[prop1] = getPropertyValue$1(prop2)(newItem);
return newItem;
};
};
var createPropertyByOtherOne_2 = createPropertyByOtherOne;
var createPropertyByOtherOne_1 = {
createPropertyByOtherOne: createPropertyByOtherOne_2
};
var debounce = function debounce(fn) {
var wait = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 200;
// retarda la ejecucion de una funcion
var timeOut = null;
return function inner() {
clearTimeout(timeOut);
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
timeOut = setTimeout(fn.bind(this, args), wait);
};
};
var debounce_2 = debounce;
var debounce_1 = {
debounce: debounce_2
};
var isEmpty = function isEmpty(arg) {
if (Array.isArray(arg)) {
return arg.length === 0;
}
if (_typeof(arg) === 'object' && arg !== null) {
return Object.keys(arg).length === 0;
}
if (typeof arg === 'string' || typeof arg === 'number') {
return !arg;
}
return !arg;
};
var isEmpty_2 = isEmpty;
var isEmpty_1 = {
isEmpty: isEmpty_2
};
var isEmpty$1 = isEmpty_1.isEmpty;
var isNotEmpty = function isNotEmpty(arg) {
return !isEmpty$1(arg);
};
var isNotEmpty_2 = isNotEmpty;
var isNotEmpty_1 = {
isNotEmpty: isNotEmpty_2
};
var mergeObjects = function mergeObjects() {
for (var _len = arguments.length, objs = new Array(_len), _key = 0; _key < _len; _key++) {
objs[_key] = arguments[_key];
}
return Object.assign.apply(Object, [{}].concat(objs));
};
var mergeObjects_2 = mergeObjects;
var mergeObjects_1 = {
mergeObjects: mergeObjects_2
};
var removeItemFromArrayByIndex = function removeItemFromArrayByIndex(index, arr) {
arr.splice(index, 1);
return arr;
};
var removeItemFromArrayByIndex_2 = removeItemFromArrayByIndex;
var removeItemFromArrayByIndex_1 = {
removeItemFromArrayByIndex: removeItemFromArrayByIndex_2
};
var findIndex$1 = arrayPrototypes.findIndex;
var removeItemFromArrayByIndex$1 = removeItemFromArrayByIndex_1.removeItemFromArrayByIndex;
var removeItemFromArrayByProp = function removeItemFromArrayByProp(prop, val) {
return function (arr) {
var index = findIndex$1(function (a) {
return a[prop] === val;
}, arr);
return removeItemFromArrayByIndex$1(index, arr);
};
};
var removeItemFromArrayByProp_2 = removeItemFromArrayByProp;
var removeItemFromArrayByProp_1 = {
removeItemFromArrayByProp: removeItemFromArrayByProp_2
};
var returnUniqueArraysItems = function returnUniqueArraysItems() {
var _ref;
var res = (_ref = []).concat.apply(_ref, arguments);
var unique = new Set();
res.forEach(function (item) {
unique.add(JSON.stringify(item));
});
var uniqueParsed = [];
unique.forEach(function (item) {
return uniqueParsed.push(JSON.parse(item));
});
return [].concat(uniqueParsed);
};
var returnUniqueArraysItems_2 = returnUniqueArraysItems;
var returnUniqueArraysItems_1 = {
returnUniqueArraysItems: returnUniqueArraysItems_2
};
var round = function round(decimal) {
return function (value) {
return Number(value.toFixed(decimal));
};
};
var round_2 = round;
var round_1 = {
round: round_2
};
var setNewProperty = function setNewProperty(property, v) {
return function (item, index) {
var a = _objectSpread2({}, item);
a[property] = typeof v === 'function' ? v(item, index) : v;
return a;
};
};
var setNewProperty_2 = setNewProperty;
var setNewProperty_1 = {
setNewProperty: setNewProperty_2
};
var allAreTrue$1 = allAreTrue_1.allAreTrue;
var find$2 = arrayPrototypes.find,
findIndex$2 = arrayPrototypes.findIndex,
forEach$1 = arrayPrototypes.forEach,
map$1 = arrayPrototypes.map,
reduce$1 = arrayPrototypes.reduce;
var atLeastOneTrue$1 = atLeastOneTrue_1.atLeastOneTrue;
var commonsItemsBetweenArrays$1 = commonsItemsBetweenArrays_1.commonsItemsBetweenArrays;
var compose$1 = compose_1.compose;
var createPropertyByOtherOne$1 = createPropertyByOtherOne_1.createPropertyByOtherOne;
var debounce$1 = debounce_1.debounce;
var equality$2 = equality_1.equality;
var getPropertysValue = getPropertyValue_1.getPropertysValue;
var isEmpty$2 = isEmpty_1.isEmpty;
var isNotEmpty$1 = isNotEmpty_1.isNotEmpty;
var mergeObjects$1 = mergeObjects_1.mergeObjects;
var removeItemFromArrayByIndex$2 = removeItemFromArrayByIndex_1.removeItemFromArrayByIndex;
var removeItemFromArrayByProp$1 = removeItemFromArrayByProp_1.removeItemFromArrayByProp;
var returnUniqueArraysItems$1 = returnUniqueArraysItems_1.returnUniqueArraysItems;
var round$1 = round_1.round;
var setNewProperty$1 = setNewProperty_1.setNewProperty;
var wrapper = {
allAreTrue: allAreTrue$1,
atLeastOneTrue: atLeastOneTrue$1,
commonsItemsBetweenArrays: commonsItemsBetweenArrays$1,
compose: compose$1,
createPropertyByOtherOne: createPropertyByOtherOne$1,
debounce: debounce$1,
equality: equality$2,
find: find$2,
findIndex: findIndex$2,
forEach: forEach$1,
getPropertysValue: getPropertysValue,
isEmpty: isEmpty$2,
isNotEmpty: isNotEmpty$1,
map: map$1,
mergeObjects: mergeObjects$1,
reduce: reduce$1,
removeItemFromArrayByIndex: removeItemFromArrayByIndex$2,
removeItemFromArrayByProp: removeItemFromArrayByProp$1,
returnUniqueArraysItems: returnUniqueArraysItems$1,
round: round$1,
setNewProperty: setNewProperty$1
};
var wrapper_1 = wrapper.allAreTrue;
var wrapper_2 = wrapper.atLeastOneTrue;
var wrapper_3 = wrapper.commonsItemsBetweenArrays;
var wrapper_4 = wrapper.compose;
var wrapper_5 = wrapper.createPropertyByOtherOne;
var wrapper_6 = wrapper.debounce;
var wrapper_7 = wrapper.equality;
var wrapper_8 = wrapper.find;
var wrapper_9 = wrapper.findIndex;
var wrapper_10 = wrapper.forEach;
var wrapper_11 = wrapper.getPropertysValue;
var wrapper_12 = wrapper.isEmpty;
var wrapper_13 = wrapper.isNotEmpty;
var wrapper_14 = wrapper.map;
var wrapper_15 = wrapper.mergeObjects;
var wrapper_16 = wrapper.reduce;
var wrapper_17 = wrapper.removeItemFromArrayByIndex;
var wrapper_18 = wrapper.removeItemFromArrayByProp;
var wrapper_19 = wrapper.returnUniqueArraysItems;
var wrapper_20 = wrapper.round;
var wrapper_21 = wrapper.setNewProperty;
exports.allAreTrue = wrapper_1;
exports.atLeastOneTrue = wrapper_2;
exports.commonsItemsBetweenArrays = wrapper_3;
exports.compose = wrapper_4;
exports.createPropertyByOtherOne = wrapper_5;
exports.debounce = wrapper_6;
exports.default = wrapper;
exports.equality = wrapper_7;
exports.find = wrapper_8;
exports.findIndex = wrapper_9;
exports.forEach = wrapper_10;
exports.getPropertysValue = wrapper_11;
exports.isEmpty = wrapper_12;
exports.isNotEmpty = wrapper_13;
exports.map = wrapper_14;
exports.mergeObjects = wrapper_15;
exports.reduce = wrapper_16;
exports.removeItemFromArrayByIndex = wrapper_17;
exports.removeItemFromArrayByProp = wrapper_18;
exports.returnUniqueArraysItems = wrapper_19;
exports.round = wrapper_20;
exports.setNewProperty = wrapper_21;
Object.defineProperty(exports, '__esModule', { value: true });
})));

13

package.json
{
"name": "functionallibrary",
"version": "1.0.5",
"version": "1.0.6",
"description": "funciones a usar en programacion funcional",
"main": "dist/functionallibrary.umd.js",
"scripts": {
"build": "npm run build:umd & npm run build:es & npm run build:unpkg",
"build:unpkg": "rollup --config build/rollup.config.js --format iife --file dist/functionallibrary.min.js",
"build:es": "rollup --config build/rollup.config.js --format es --file dist/functionallibrary.esm.js",
"build": "npm run build:umd",
"build:umd": "rollup --config build/rollup.config.js --format umd --file dist/functionallibrary.umd.js",

@@ -32,4 +30,11 @@ "test": "node ./test"

"dependencies": {
"@babel/polyfill": "^7.8.7",
"@rollup/plugin-commonjs": "^11.1.0"
},
"devDependencies": {
"@babel/cli": "^7.8.4",
"@babel/core": "^7.9.0",
"@babel/preset-env": "^7.9.5",
"rollup-plugin-babel": "^4.4.0"
}
}
dist/functionallibrary.esm.js
dist/functionallibrary.min.js