rambda 10.0.0-beta.1 → 10.0.0-beta.3

package/dist/rambda.js

@@ -2,6 +2,35 @@ function addProp(key, value) {
   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++) {
@@ -201,12 +230,8 @@ function isFalsy(input) {
   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) {
@@ -218,12 +243,8 @@ function descend(getFunction) {
   }
 }
 
-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) {
@@ -658,6 +679,81 @@ function flatten(list, input) {
   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++) {
@@ -821,18 +917,6 @@ function lastIndexOf(valueToFind) {
   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 = [];
@@ -897,6 +981,20 @@ function minBy(compareFn, x) {
   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$1(list);
+    clone[actualIndex] = replaceFn(clone[actualIndex]);
+
+    return clone
+  }
+}
+
 function update(index, newValue) {
   return list => {
     const clone = cloneList$1(list);
@@ -1024,32 +1122,34 @@ function partitionObject(predicate) {
 }
 }
 
-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)))
 }
 
 /**
@@ -1258,7 +1358,7 @@ function propOr(defaultValue, property) {
       return defaultValue
     }
 
-    return defaultTo(defaultValue, obj[property])
+    return defaultTo(defaultValue)(obj[property])
   }
 }
 
@@ -1266,42 +1366,33 @@ function propSatisfies(predicate, property) {
   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 []
-    }
+function rangeDescending(start, end) {
+	const len = start - end;
+	const willReturn = Array(len);
 
-    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
-  }
+	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
@@ -1312,20 +1403,6 @@ function replace(pattern, replacer) {
   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;
@@ -1344,21 +1421,42 @@ function sort(sortFn) {
   return list => cloneList$1(list).sort(sortFn)
 }
 
+function sortByFn (
+	sortFn,
+	list,
+	descending
+){
+	const clone = cloneList$1(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) {
@@ -1675,4 +1773,4 @@ function zipWith(fn, x) {
     )
 }
 
-export { _arity, _includes, _indexOf, _lastIndexOf, addProp, all, allPass, any, anyPass, append, ascend, checkObjectWithSpec, compact, complement, concat, count, countBy, createCompareFunction, createObjectFromKeys, defaultTo, descend, drop, dropLast, dropLastWhile, dropWhile, eqBy, eqProps, equals, equalsFn, evolve, excludes, filter, filterObject, find, findIndex, findLast, findLastIndex, findNth, flatMap, flatten, groupBy, groupByFallback, head, includes, indexOf, init, innerJoin, interpolate, intersection, intersperse, join, last, lastIndexOf, map, mapAsync, mapKeys, mapObject, mapObjectAsync, mapParallelAsync, match, maxBy, merge, mergeTypes, minBy, modifyProp, none, objOf, objectIncludes, omit, partition, partitionObject, path, permutations, pick, pipe, pipeAsync, pluck, prepend, prop, propEq, propOr, propSatisfies, range, rangeDescending, reduce, reject, rejectObject, replace, replaceItemAtIndex, shuffle, sort, sortBy, sortObject, sortWith, split, splitEvery, symmetricDifference, tail, take, takeLast, takeLastWhile, takeWhile, tap, test, tryCatch, type, union, uniq, uniqBy, uniqWith, unless, unwind, update, when, zip, zipWith };
+export { _arity, _includes, _indexOf, _lastIndexOf, addProp, addPropToObjects, all, allPass, any, anyPass, append, ascend, checkObjectWithSpec, compact, complement, concat, count, countBy, createCompareFunction, createObjectFromKeys, defaultTo, descend, drop, dropLast, dropLastWhile, dropWhile, eqBy, eqProps, equals, equalsFn, evolve, excludes, filter, filterObject, find, findIndex, findLast, findLastIndex, findNth, flatMap, flatten, flattenObject, flattenObjectHelper, groupBy, groupByFallback, head, includes, indexOf, init, innerJoin, interpolate, intersection, intersperse, join, last, lastIndexOf, map, mapAsync, mapFn, mapKeys, mapObject, mapObjectAsync, mapParallelAsync, match, maxBy, merge, mergeTypes, minBy, modifyItemAtIndex, modifyProp, none, objOf, objectIncludes, omit, partition, partitionObject, path, pathSatisfies, permutations, pick, pipe, pipeAsync, pluck, prepend, prop, propEq, propOr, propSatisfies, range, reduce, reject, rejectObject, replace, shuffle, sort, sortBy, sortByDescending, sortByFn, sortByPath, sortByPathDescending, sortObject, sortWith, split, splitEvery, symmetricDifference, tail, take, takeLast, takeLastWhile, takeWhile, tap, test, transformFlatObject, tryCatch, type, union, uniq, uniqBy, uniqWith, unless, unwind, update, when, zip, zipWith };