rambda 10.0.0-beta.1 → 10.0.0

package/dist/rambda.umd.js

@@ -8,6 +8,35 @@
     return obj => ({ ...obj, [key]: value })
   }
 
+  function mapFn(
+  	fn, list
+  ){
+  	let index = 0;
+  	const willReturn = Array(list.length);
+  	while (index < list.length) {
+  		willReturn[index] = fn(list[index], index);
+  		index++;
+  	}
+  	return willReturn
+  }
+
+  function map(fn) {
+    return list => mapFn(fn, list)
+  }
+
+  function addPropToObjects (
+  	property, 
+  	fn
+  ){
+  	return listOfObjects => mapFn(
+  		(obj) => ({
+  			...(obj),
+  			[property]: fn(obj)
+  		}), 
+  		listOfObjects
+  	)
+  }
+
   function all(predicate) {
     return list => {
       for (let i = 0; i < list.length; i++) {
@@ -62,11 +91,11 @@
     }
   }
 
-  const cloneList$1 = list => Array.prototype.slice.call(list);
+  const cloneList = list => Array.prototype.slice.call(list);
 
   function append(x) {
     return list => {
-      const clone = cloneList$1(list);
+      const clone = cloneList(list);
       clone.push(x);
 
       return clone
@@ -207,12 +236,8 @@
     return input === undefined || input === null || Number.isNaN(input) === true
   }
 
-  function defaultTo(defaultArgument, input) {
-    if (arguments.length === 1) {
-      return _input => defaultTo(defaultArgument, _input)
-    }
-
-    return isFalsy(input) ? defaultArgument : input
+  function defaultTo(defaultArgument) {
+    return input => isFalsy(input) ? defaultArgument : input
   }
 
   function descend(getFunction) {
@@ -224,12 +249,8 @@
     }
   }
 
-  function drop(howManyToDrop, listOrString) {
-    if (arguments.length === 1) {
-      return _list => drop(howManyToDrop, _list)
-    }
-
-    return listOrString.slice(howManyToDrop > 0 ? howManyToDrop : 0)
+  function drop(howManyToDrop, ) {
+    return list => list.slice(howManyToDrop > 0 ? howManyToDrop : 0)
   }
 
   function dropLast(numberItems) {
@@ -664,6 +685,81 @@
     return willReturn
   }
 
+  function flattenObjectHelper(obj, accumulator = []){
+    const willReturn = {};
+    Object.keys(obj).forEach(key => {
+      const typeIs = type(obj[ key ]);
+      if (typeIs === 'Object'){
+        const [ flatResultValue, flatResultPath ] = flattenObjectHelper(obj[ key ],
+          [ ...accumulator, key ]);
+        willReturn[ flatResultPath.join('.') ] = flatResultValue;
+
+        return
+      } else if (accumulator.length > 0){
+        const finalKey = [ ...accumulator, key ].join('.');
+        willReturn[ finalKey ] = obj[ key ];
+
+        return
+      }
+      willReturn[ key ] = obj[ key ];
+    });
+    if (accumulator.length > 0) return [ willReturn, accumulator ]
+
+    return willReturn
+  }
+
+  function transformFlatObject(obj){
+    const willReturn = {};
+
+    const transformFlatObjectFn = objLocal => {
+      const willReturnLocal = {};
+      Object.keys(objLocal).forEach(key => {
+        const typeIs = type(objLocal[ key ]);
+        if (typeIs === 'Object'){
+          transformFlatObjectFn(objLocal[ key ]);
+
+          return
+        }
+        willReturnLocal[ key ] = objLocal[ key ];
+        willReturn[ key ] = objLocal[ key ];
+      });
+
+      return willReturnLocal
+    };
+
+    Object.keys(obj).forEach(key => {
+      const typeIs = type(obj[ key ]);
+      if (typeIs === 'Object'){
+        transformFlatObjectFn(obj[ key ]);
+
+        return
+      }
+      willReturn[ key ] = obj[ key ];
+    });
+
+    return willReturn
+  }
+
+  function flattenObject(obj){
+    const willReturn = {};
+
+    Object.keys(obj).forEach(key => {
+      const typeIs = type(obj[ key ]);
+      if (typeIs === 'Object'){
+        const flatObject = flattenObjectHelper(obj[ key ]);
+        const transformed = transformFlatObject(flatObject);
+
+        Object.keys(transformed).forEach(keyTransformed => {
+          willReturn[ `${ key }.${ keyTransformed }` ] = transformed[ keyTransformed ];
+        });
+      } else {
+        willReturn[ key ] = obj[ key ];
+      }
+    });
+
+    return willReturn
+  }
+
   function groupByFallback(groupFn, list) {
       const result = {};
       for (let i = 0; i < list.length; i++) {
@@ -827,18 +923,6 @@
     return list => _lastIndexOf(valueToFind, list)
   }
 
-  function map(fn) {
-    return list => {
-      let index = 0;
-      const willReturn = Array(list.length);
-      while (index < list.length) {
-        willReturn[index] = fn(list[index], index);
-        index++;
-      }
-      return willReturn
-    }
-  }
-
   function mapAsync(fn) {
     return async list => {
       const willReturn = [];
@@ -903,9 +987,23 @@
     return y => (compareFn(y) < compareFn(x) ? y : x)
   }
 
+  function modifyItemAtIndex(index, replaceFn) {
+    return list => {
+      const actualIndex = index < 0 ? list.length + index : index;
+      if (index >= list.length || actualIndex < 0) {
+        return list
+      }
+
+      const clone = cloneList(list);
+      clone[actualIndex] = replaceFn(clone[actualIndex]);
+
+      return clone
+    }
+  }
+
   function update(index, newValue) {
     return list => {
-      const clone = cloneList$1(list);
+      const clone = cloneList(list);
       if (index === -1) {
         return clone.fill(newValue, index)
       }
@@ -1030,32 +1128,34 @@
   }
   }
 
-  function path(pathInput, obj) {
-    if (arguments.length === 1) {
-      return _obj => path(pathInput, _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++;
-    }
+  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
+  	}
+  }
 
-    return willReturn
+  function pathSatisfies(fn, pathInput) {
+    return obj => Boolean(fn(path(pathInput)(obj)))
   }
 
   /**
@@ -1064,7 +1164,7 @@
    */
   function permutations(inputArray) {
     const result = [];
-    const array = cloneList$1(inputArray);
+    const array = cloneList(inputArray);
     const k = array.length;
     if (k === 0) {
       return result;
@@ -1264,7 +1364,7 @@
         return defaultValue
       }
 
-      return defaultTo(defaultValue, obj[property])
+      return defaultTo(defaultValue)(obj[property])
     }
   }
 
@@ -1272,42 +1372,33 @@
     return obj => predicate(obj[property])
   }
 
-  function range(start) {
-    return end => {
-      if (Number.isNaN(Number(start)) || Number.isNaN(Number(end))) {
-        throw new TypeError('Both arguments to range must be numbers')
-      }
-
-      if (end <= start) {
-        return []
-      }
-
-      const len = end - start;
-      const willReturn = Array(len);
+  function rangeDescending(start, end) {
+  	const len = start - end;
+  	const willReturn = Array(len);
 
-      for (let i = 0; i < len + 1; i++) {
-        willReturn[i] = start + i;
-      }
+  	for (let i = 0; i < len; i++) {
+  		willReturn[i] = start - i;
+  	}
 
-      return willReturn
-    }
+  	return willReturn
   }
 
-  function rangeDescending(start) {
+  function range(start) {
     return end => {
       if (Number.isNaN(Number(start)) || Number.isNaN(Number(end))) {
         throw new TypeError('Both arguments to range must be numbers')
       }
 
-      if (end >= start) {
+      if (end === start) {
         return []
       }
+  		if (end < start) return rangeDescending(start,end)
 
-      const len = start - end;
+      const len = end - start;
       const willReturn = Array(len);
 
-      for (let i = 0; i < len + 1; i++) {
-        willReturn[i] = start - i;
+      for (let i = 0; i < len; i++) {
+        willReturn[i] = start + i;
       }
 
       return willReturn
@@ -1318,20 +1409,6 @@
     return str => str.replace(pattern, replacer)
   }
 
-  function replaceItemAtIndex(index, replaceFn) {
-    return list => {
-      const actualIndex = index < 0 ? list.length + index : index;
-      if (index >= list.length || actualIndex < 0) {
-        return list
-      }
-
-      const clone = cloneList$1(list);
-      clone[actualIndex] = replaceFn(clone[actualIndex]);
-
-      return clone
-    }
-  }
-
   function shuffle(listInput) {
     const list = cloneList(listInput);
     let counter = list.length;
@@ -1347,24 +1424,45 @@
   }
 
   function sort(sortFn) {
-    return list => cloneList$1(list).sort(sortFn)
+    return list => cloneList(list).sort(sortFn)
+  }
+
+  function sortByFn (
+  	sortFn,
+  	list,
+  	descending
+  ){
+  	const clone = cloneList(list);
+
+  	return clone.sort((a, b) => {
+  		const aSortResult = sortFn(a);
+  		const bSortResult = sortFn(b);
+
+  		if (aSortResult === bSortResult) {
+  			return 0
+  		}
+  		if(
+  			descending
+  		) return aSortResult > bSortResult ? -1 : 1
+
+  		return aSortResult < bSortResult ? -1 : 1
+  	})
   }
 
   function sortBy(sortFn) {
-    return list => {
-      const clone = cloneList$1(list);
+    return list => sortByFn(sortFn, list, false)
+  }
 
-      return clone.sort((a, b) => {
-        const aSortResult = sortFn(a);
-        const bSortResult = sortFn(b);
+  function sortByDescending(sortFn) {
+    return list => sortByFn(sortFn, list, true)
+  }
 
-        if (aSortResult === bSortResult) {
-          return 0
-        }
+  function sortByPath(sortPath) {
+    return list => sortBy(path(sortPath))(list)
+  }
 
-        return aSortResult < bSortResult ? -1 : 1
-      })
-    }
+  function sortByPathDescending(sortPath) {
+    return list => sortByDescending(path(sortPath))(list)
   }
 
   function sortObject(predicate) {
@@ -1529,7 +1627,7 @@
 
   function union(x) {
     return y => {
-      const toReturn = cloneList$1(x);
+      const toReturn = cloneList(x);
 
       y.forEach(yInstance => {
         if (!includes(yInstance)(x)) {
@@ -1686,6 +1784,7 @@
   exports._indexOf = _indexOf;
   exports._lastIndexOf = _lastIndexOf;
   exports.addProp = addProp;
+  exports.addPropToObjects = addPropToObjects;
   exports.all = all;
   exports.allPass = allPass;
   exports.any = any;
@@ -1721,6 +1820,8 @@
   exports.findNth = findNth;
   exports.flatMap = flatMap;
   exports.flatten = flatten;
+  exports.flattenObject = flattenObject;
+  exports.flattenObjectHelper = flattenObjectHelper;
   exports.groupBy = groupBy;
   exports.groupByFallback = groupByFallback;
   exports.head = head;
@@ -1736,6 +1837,7 @@
   exports.lastIndexOf = lastIndexOf;
   exports.map = map;
   exports.mapAsync = mapAsync;
+  exports.mapFn = mapFn;
   exports.mapKeys = mapKeys;
   exports.mapObject = mapObject;
   exports.mapObjectAsync = mapObjectAsync;
@@ -1745,6 +1847,7 @@
   exports.merge = merge;
   exports.mergeTypes = mergeTypes;
   exports.minBy = minBy;
+  exports.modifyItemAtIndex = modifyItemAtIndex;
   exports.modifyProp = modifyProp;
   exports.none = none;
   exports.objOf = objOf;
@@ -1753,6 +1856,7 @@
   exports.partition = partition;
   exports.partitionObject = partitionObject;
   exports.path = path;
+  exports.pathSatisfies = pathSatisfies;
   exports.permutations = permutations;
   exports.pick = pick;
   exports.pipe = pipe;
@@ -1764,15 +1868,17 @@
   exports.propOr = propOr;
   exports.propSatisfies = propSatisfies;
   exports.range = range;
-  exports.rangeDescending = rangeDescending;
   exports.reduce = reduce;
   exports.reject = reject;
   exports.rejectObject = rejectObject;
   exports.replace = replace;
-  exports.replaceItemAtIndex = replaceItemAtIndex;
   exports.shuffle = shuffle;
   exports.sort = sort;
   exports.sortBy = sortBy;
+  exports.sortByDescending = sortByDescending;
+  exports.sortByFn = sortByFn;
+  exports.sortByPath = sortByPath;
+  exports.sortByPathDescending = sortByPathDescending;
   exports.sortObject = sortObject;
   exports.sortWith = sortWith;
   exports.split = split;
@@ -1785,6 +1891,7 @@
   exports.takeWhile = takeWhile;
   exports.tap = tap;
   exports.test = test;
+  exports.transformFlatObject = transformFlatObject;
   exports.tryCatch = tryCatch;
   exports.type = type;
   exports.union = union;