rambda 10.1.0 → 10.3.0

package/dist/rambda.umd.js

@@ -539,6 +539,53 @@
     return b => equalsFn(a, b)
   }
 
+  class _Set {
+    constructor() {
+      this.set = new Set();
+      this.items = {};
+    }
+
+    checkUniqueness(item) {
+      const type$1 = type(item);
+      if (['Null', 'Undefined', 'NaN'].includes(type$1)) {
+        if (type$1 in this.items) {
+          return false
+        }
+        this.items[type$1] = true;
+
+        return true
+      }
+      if (!['Object', 'Array'].includes(type$1)) {
+        const prevSize = this.set.size;
+        this.set.add(item);
+
+        return this.set.size !== prevSize
+      }
+
+      if (!(type$1 in this.items)) {
+        this.items[type$1] = [item];
+
+        return true
+      }
+
+      if (_indexOf(item, this.items[type$1]) === -1) {
+        this.items[type$1].push(item);
+
+        return true
+      }
+
+      return false
+    }
+  }
+
+  function duplicateBy(fn) {
+    return list => {
+      const set = new _Set();
+
+      return list.filter(item => !set.checkUniqueness(fn(item)))
+    }
+  }
+
   function eqBy(fn, a) {
     return b => equalsFn(fn(a), fn(b))
   }
@@ -590,6 +637,21 @@
     return iterable => !includes(valueToFind)(iterable)
   }
 
+  function filterAsync(predicate) {
+    return async list => {
+      const willReturn = [];
+      let index = 0;
+      for (const x of list) {
+        if (await predicate(x, index)) {
+          willReturn.push(list[index]);
+        }
+        index++;
+      }
+
+      return willReturn
+    }
+  }
+
   function filterObject(predicate) {
     return obj => {
       const willReturn = {};
@@ -802,6 +864,21 @@
     return listOrString[0]
   }
 
+  function indexBy(property){
+  	return list => {
+  		const toReturn = {};
+  		for (let i = 0; i < list.length; i++){
+  			const item = list[ i ];
+  			const key = item[property];
+  			if(key !== undefined){
+  				toReturn[ key ] = item;
+  			}
+  		}
+  	
+  		return toReturn
+  	}
+  }
+
   function indexOf(valueToFind) {
     return list => _indexOf(valueToFind, list)
   }
@@ -940,8 +1017,8 @@
     return async list => {
       const willReturn = [];
       let i = 0;
-      for (const a of list) {
-        willReturn.push(await fn(a, i++));
+      for (const x of list) {
+        willReturn.push(await fn(x, i++));
       }
 
       return willReturn
@@ -975,6 +1052,17 @@
     return async list =>  Promise.all(list.map((x, i) => fn(x, i)))
   }
 
+  function mapPropObject(fn, prop) {
+    return obj => {
+  		if (!Array.isArray(obj[prop])) return obj
+  			
+  			return {
+  				...obj,
+  				[prop]: obj[prop].map(fn)
+  			}
+  		}
+   	 }
+
   function match(pattern) {
     return input => {
       const willReturn = input.match(pattern);
@@ -1014,6 +1102,66 @@
     }
   }
 
+  function createPath(path, delimiter = '.') {
+    return typeof path === 'string'
+      ? path.split(delimiter).map(x => (Number.isInteger(Number(x)) ? Number(x) : x))
+      : path
+  }
+
+  function path(pathInput) {
+  	return (obj)  => {
+  		if (!obj) {
+  			return undefined
+  		}
+  		let willReturn = obj;
+  		let counter = 0;
+  	
+  		const pathArrValue = createPath(pathInput);
+  	
+  		while (counter < pathArrValue.length) {
+  			if (willReturn === null || willReturn === undefined) {
+  				return undefined
+  			}
+  			if (willReturn[pathArrValue[counter]] === null) {
+  				return undefined
+  			}
+  	
+  			willReturn = willReturn[pathArrValue[counter]];
+  			counter++;
+  		}
+  	
+  		return willReturn
+  	}
+  }
+
+  function assoc(prop, newValue) {
+    return obj => Object.assign({}, obj, { [prop]: newValue })
+  }
+
+  function modifyPathFn(pathInput, fn, obj) {
+    const path$1 = createPath(pathInput);
+    if (path$1.length === 1) {
+      return {
+        ...obj,
+        [path$1[0]]: fn(obj[path$1[0]]),
+      }
+    }
+    if (path(path$1)(obj) === undefined) {
+      return obj
+    }
+
+    const val = modifyPathFn(Array.prototype.slice.call(path$1, 1), fn, obj[path$1[0]]);
+    if (val === obj[path$1[0]]) {
+      return obj
+    }
+
+    return assoc(path$1[0], val)(obj)
+  }
+
+  function modifyPath(pathInput, fn) {
+    return obj => modifyPathFn(pathInput, fn, obj)
+  }
+
   function update(index, newValue) {
     return list => {
       const clone = cloneList(list);
@@ -1069,12 +1217,6 @@
     }
   }
 
-  function createPath(path, delimiter = '.') {
-    return typeof path === 'string'
-      ? path.split(delimiter).map(x => (Number.isInteger(Number(x)) ? Number(x) : x))
-      : path
-  }
-
   function _includes(x, list) {
     let index = -1;
     const { length } = list;
@@ -1141,32 +1283,6 @@
   }
   }
 
-  function path(pathInput) {
-  	return (obj)  => {
-  		if (!obj) {
-  			return undefined
-  		}
-  		let willReturn = obj;
-  		let counter = 0;
-  	
-  		const pathArrValue = createPath(pathInput);
-  	
-  		while (counter < pathArrValue.length) {
-  			if (willReturn === null || willReturn === undefined) {
-  				return undefined
-  			}
-  			if (willReturn[pathArrValue[counter]] === null) {
-  				return undefined
-  			}
-  	
-  			willReturn = willReturn[pathArrValue[counter]];
-  			counter++;
-  		}
-  	
-  		return willReturn
-  	}
-  }
-
   function pathSatisfies(fn, pathInput) {
     return obj => Boolean(fn(path(pathInput)(obj)))
   }
@@ -1422,6 +1538,17 @@
     return str => str.replace(pattern, replacer)
   }
 
+  function replaceAll(patterns, replacer) {
+    return input => {
+      let text = input;
+      patterns.forEach(singlePattern => {
+        text = text.replace(singlePattern, replacer);
+      });
+
+      return text
+    }
+  }
+
   function shuffle(listInput) {
     const list = cloneList(listInput);
     let counter = list.length;
@@ -1652,45 +1779,6 @@
     }
   }
 
-  class _Set {
-    constructor() {
-      this.set = new Set();
-      this.items = {};
-    }
-
-    checkUniqueness(item) {
-      const type$1 = type(item);
-      if (['Null', 'Undefined', 'NaN'].includes(type$1)) {
-        if (type$1 in this.items) {
-          return false
-        }
-        this.items[type$1] = true;
-
-        return true
-      }
-      if (!['Object', 'Array'].includes(type$1)) {
-        const prevSize = this.set.size;
-        this.set.add(item);
-
-        return this.set.size !== prevSize
-      }
-
-      if (!(type$1 in this.items)) {
-        this.items[type$1] = [item];
-
-        return true
-      }
-
-      if (_indexOf(item, this.items[type$1]) === -1) {
-        this.items[type$1].push(item);
-
-        return true
-      }
-
-      return false
-    }
-  }
-
   function uniq(list) {
     const set = new _Set();
     const willReturn = [];
@@ -1820,6 +1908,7 @@
   exports.dropLast = dropLast;
   exports.dropLastWhile = dropLastWhile;
   exports.dropWhile = dropWhile;
+  exports.duplicateBy = duplicateBy;
   exports.eqBy = eqBy;
   exports.eqProps = eqProps;
   exports.equals = equals;
@@ -1827,6 +1916,7 @@
   exports.evolve = evolve;
   exports.excludes = excludes;
   exports.filter = filter;
+  exports.filterAsync = filterAsync;
   exports.filterObject = filterObject;
   exports.find = find;
   exports.findIndex = findIndex;
@@ -1841,6 +1931,7 @@
   exports.groupByFallback = groupByFallback;
   exports.head = head;
   exports.includes = includes;
+  exports.indexBy = indexBy;
   exports.indexOf = indexOf;
   exports.init = init;
   exports.innerJoin = innerJoin;
@@ -1857,12 +1948,14 @@
   exports.mapObject = mapObject;
   exports.mapObjectAsync = mapObjectAsync;
   exports.mapParallelAsync = mapParallelAsync;
+  exports.mapPropObject = mapPropObject;
   exports.match = match;
   exports.maxBy = maxBy;
   exports.merge = merge;
   exports.mergeTypes = mergeTypes;
   exports.minBy = minBy;
   exports.modifyItemAtIndex = modifyItemAtIndex;
+  exports.modifyPath = modifyPath;
   exports.modifyProp = modifyProp;
   exports.none = none;
   exports.objOf = objOf;
@@ -1887,6 +1980,7 @@
   exports.reject = reject;
   exports.rejectObject = rejectObject;
   exports.replace = replace;
+  exports.replaceAll = replaceAll;
   exports.shuffle = shuffle;
   exports.sort = sort;
   exports.sortBy = sortBy;