rambda 10.0.0-alpha.0 → 10.0.0-beta.3

package/src/includes.js

@@ -2,18 +2,17 @@ import { isArray } from './_internals/isArray.js'
 import { _indexOf } from './equals.js'
 
 export function includes(valueToFind) {
-	return iterable => 
-	{
-  if (typeof iterable === 'string') {
-    return iterable.includes(valueToFind)
-  }
-  if (!iterable) {
-    throw new TypeError(`Cannot read property \'indexOf\' of ${iterable}`)
-  }
-  if (!isArray(iterable)) {
-    return false
-  }
+  return iterable => {
+    if (typeof iterable === 'string') {
+      return iterable.includes(valueToFind)
+    }
+    if (!iterable) {
+      throw new TypeError(`Cannot read property \'indexOf\' of ${iterable}`)
+    }
+    if (!isArray(iterable)) {
+      return false
+    }
 
-  return _indexOf(valueToFind, iterable) > -1
-}
+    return _indexOf(valueToFind, iterable) > -1
+  }
 }

package/src/interpolate.js

@@ -0,0 +1,29 @@
+const getOccurrences = input => input.match(/{{\s*.+?\s*}}/g)
+const getOccurrenceProp = occurrence => occurrence.replace(/{{\s*|\s*}}/g, '')
+
+const replace = ({ inputHolder, prop, replacer }) => {
+  const regexBase = `{{${prop}}}`
+  const regex = new RegExp(regexBase, 'g')
+  return inputHolder.replace(regex, replacer)
+}
+
+export function interpolate(input) {
+  return templateInput => {
+    const occurrences = getOccurrences(input)
+    if (occurrences === null) {
+      return input
+    }
+    let inputHolder = input
+
+    for (const occurrence of occurrences) {
+      const prop = getOccurrenceProp(occurrence)
+      inputHolder = replace({
+        inputHolder,
+        prop,
+        replacer: templateInput[prop],
+      })
+    }
+
+    return inputHolder
+  }
+}

package/src/intersection.js

@@ -2,5 +2,5 @@ import { filter } from './filter.js'
 import { includes } from './includes.js'
 
 export function intersection(listA) {
-  return listB =>filter(x => includes(x)(listA))(listB)
+  return listB => filter(x => includes(x)(listA))(listB)
 }

package/src/intersperse.js

@@ -1,17 +1,17 @@
 export function intersperse(separator) {
-	return list => {
-  let index = -1
-  const len = list.length
-  const willReturn = []
+  return list => {
+    let index = -1
+    const len = list.length
+    const willReturn = []
 
-  while (++index < len) {
-    if (index === len - 1) {
-      willReturn.push(list[index])
-    } else {
-      willReturn.push(list[index], separator)
+    while (++index < len) {
+      if (index === len - 1) {
+        willReturn.push(list[index])
+      } else {
+        willReturn.push(list[index], separator)
+      }
     }
-  }
 
-  return willReturn
-}
+    return willReturn
+  }
 }

package/src/join.js

@@ -1,3 +1,3 @@
 export function join(glue) {
-  return list=> list.join(glue)
+  return list => list.join(glue)
 }

package/src/map.js

@@ -1,11 +1,15 @@
+export 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
+}
+
 export 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
-  }
+  return list => mapFn(fn, list)
 }

package/src/mapAsync.js

@@ -1,11 +1,11 @@
 export function mapAsync(fn) {
-	return async list => {
-		const willReturn = []
+  return async list => {
+    const willReturn = []
     let i = 0
     for (const a of list) {
       willReturn.push(await fn(a, i++))
     }
 
     return willReturn
-	}
+  }
 }

package/src/mapKeys.js

@@ -0,0 +1,11 @@
+export function mapKeys(fn) {
+  return obj => {
+		const willReturn = {}
+
+		Object.keys(obj).forEach(key => {
+			willReturn[fn(key, obj[key])] = obj[key]
+		})
+
+		return willReturn
+	}
+}

package/src/mapObjectAsync.js

@@ -1,10 +1,10 @@
 export function mapObjectAsync(fn) {
-	return async obj => {
-		const willReturn = {}
-		for (const prop in obj){
-			willReturn[ prop ] = await fn(obj[ prop ], prop)
-		}
-	
-		return willReturn
-	}
-}
+  return async obj => {
+    const willReturn = {}
+    for (const prop in obj) {
+      willReturn[prop] = await fn(obj[prop], prop)
+    }
+
+    return willReturn
+  }
+}

package/src/mapParallelAsync.js

@@ -0,0 +1,3 @@
+export function mapParallelAsync(fn) {
+  return async list =>  Promise.all(list.map((x, i) => fn(x, i)))
+}

package/src/match.js

@@ -1,7 +1,7 @@
 export function match(pattern) {
-	return input => {
-		const willReturn = input.match(pattern)
-	
-		return willReturn === null ? [] : willReturn
-	}
+  return input => {
+    const willReturn = input.match(pattern)
+
+    return willReturn === null ? [] : willReturn
+  }
 }

package/src/{replaceItemAtIndex.js → modifyItemAtIndex.js}

@@ -1,6 +1,6 @@
 import { cloneList } from './_internals/cloneList.js'
 
-export function replaceItemAtIndex(index, replaceFn) {
+export function modifyItemAtIndex(index, replaceFn) {
   return list => {
     const actualIndex = index < 0 ? list.length + index : index
     if (index >= list.length || actualIndex < 0) {

package/src/modifyProp.js

@@ -0,0 +1,20 @@
+import { isArray } from './_internals/isArray.js'
+import { update } from './update.js'
+
+function modifyFn(property, fn, list) {
+  if (list[property] === undefined) {
+    return list
+  }
+  if (isArray(list)) {
+    return update(property, fn(list[property]))(list)
+  }
+
+  return {
+    ...list,
+    [property]: fn(list[property]),
+  }
+}
+
+export function modifyProp(property, fn) {
+  return obj => modifyFn(property, fn, obj)
+}

package/src/objectIncludes.js

@@ -0,0 +1,12 @@
+import { equals } from './equals.js'
+import { filterObject } from './filterObject.js'
+
+export function objectIncludes(condition) {
+  return obj => {
+    const result = filterObject((conditionValue, conditionProp) =>
+      equals(conditionValue)(obj[conditionProp]),
+    )(condition)
+
+    return Object.keys(result).length === Object.keys(condition).length
+  }
+}

package/src/partition.js

@@ -1,41 +1,17 @@
-import { isArray } from './_internals/isArray.js'
-
-export function partitionObject(predicate, iterable) {
-  const yes = {}
-  const no = {}
-  Object.entries(iterable).forEach(([prop, value]) => {
-    if (predicate(value, prop)) {
-      yes[prop] = value
-    } else {
-      no[prop] = value
-    }
-  })
-
-  return [yes, no]
-}
-
-export function partitionArray(predicate, list, indexed = false) {
-  const yes = []
-  const no = []
-  let counter = -1
-
-  while (counter++ < list.length - 1) {
-    if (indexed ? predicate(list[counter], counter) : predicate(list[counter])) {
-      yes.push(list[counter])
-    } else {
-      no.push(list[counter])
-    }
-  }
-
-  return [yes, no]
-}
-
 export function partition(predicate) {
-	return iterable => {
-		if (!isArray(iterable)) {
-			return partitionObject(predicate, iterable)
+  return list => {
+		const yes = []
+		const no = []
+		let counter = -1
+	
+		while (counter++ < list.length - 1) {
+			if (predicate(list[counter], counter)) {
+				yes.push(list[counter])
+			} else {
+				no.push(list[counter])
+			}
 		}
 	
-		return partitionArray(predicate, iterable)
-	}
+		return [yes, no]
+  }
 }

package/src/partitionObject.js

@@ -0,0 +1,15 @@
+export function partitionObject(predicate) {
+	return obj => {
+  const yes = {}
+  const no = {}
+  Object.entries(obj).forEach(([prop, value]) => {
+    if (predicate(value, prop)) {
+      yes[prop] = value
+    } else {
+      no[prop] = value
+    }
+  })
+
+  return [yes, no]
+}
+}

package/src/path.js

@@ -1,29 +1,27 @@
 import { createPath } from './_internals/createPath.js'
 
-export 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++
-  }
-
-  return willReturn
+export 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
+	}
 }

package/src/pathSatisfies.js

@@ -0,0 +1,5 @@
+import { path } from './path.js'
+
+export function pathSatisfies(fn, pathInput) {
+  return obj => Boolean(fn(path(pathInput)(obj)))
+}

package/src/permutations.js

@@ -0,0 +1,40 @@
+import { cloneList } from './_internals/cloneList.js'
+
+/**
+ * Source:
+ * https://github.com/denoland/std/blob/main/collections/permutations.ts
+ */
+export function permutations(inputArray) {
+  const result = [];
+  const array = cloneList(inputArray);
+  const k = array.length;
+  if (k === 0) {
+    return result;
+  }
+
+  const c = new Array(k).fill(0);
+
+  result.push([...array]);
+
+  let i = 1;
+
+  while (i < k) {
+    if (c[i] < i) {
+      if (i % 2 === 0) {
+        [array[0], array[i]] = [array[i], array[0]]
+      } else {
+        [array[c[i]], array[i]] = [array[i], array[c[i]]]
+      }
+
+      result.push([...array]);
+
+      c[i] += 1;
+      i = 1;
+    } else {
+      c[i] = 0;
+      i += 1;
+    }
+  }
+
+  return result;
+}

package/src/pipeAsync.js

@@ -1,10 +1,11 @@
 import { type } from './type.js'
 
 export async function pipeAsync(input, ...fnList) {
-		let willReturn = input
-		for (const fn of fnList) {
-			const initialResult = fn(willReturn)
-			willReturn = type(initialResult) === 'Promise' ? await initialResult : initialResult
-    }
-		return willReturn
+  let willReturn = input
+  for (const fn of fnList) {
+    const initialResult = fn(willReturn)
+    willReturn =
+      type(initialResult) === 'Promise' ? await initialResult : initialResult
+  }
+  return willReturn
 }

package/src/pluck.js

@@ -1,13 +1,13 @@
 export function pluck(property) {
-	return list => {
-  const willReturn = []
+  return list => {
+    const willReturn = []
 
-  list.forEach(x => {
-    if (x[property] !== undefined) {
-      willReturn.push(x[property])
-    }
-  })
+    list.forEach(x => {
+      if (x[property] !== undefined) {
+        willReturn.push(x[property])
+      }
+    })
 
-  return willReturn
-}
+    return willReturn
+  }
 }

package/src/prepend.js

@@ -1,3 +1,3 @@
 export function prepend(x) {
-  return list=> [x].concat(list)
+  return list => [x].concat(list)
 }

package/src/propOr.js

@@ -6,6 +6,6 @@ export function propOr(defaultValue, property) {
       return defaultValue
     }
 
-    return defaultTo(defaultValue, obj[property])
+    return defaultTo(defaultValue)(obj[property])
   }
 }

package/src/propSatisfies.js

@@ -1,5 +1,3 @@
-import { prop } from './prop.js'
-
 export function propSatisfies(predicate, property) {
-  return obj => predicate(prop(property, obj))
+  return obj => predicate(obj[property])
 }

package/src/range.js

@@ -1,18 +1,34 @@
-export function range(start){
-	return end => {
-  if (Number.isNaN(Number(start)) || Number.isNaN(Number(end))){
-    throw new TypeError('Both arguments to range must be numbers')
-  }
+function rangeDescending(start, end) {
+	const len = start - end
+	const willReturn = Array(len)
 
-  if (end < start) return []
+	for (let i = 0; i < len; i++) {
+		willReturn[i] = start - i
+	}
 
-  const len = end - start
-  const willReturn = Array(len)
+	return willReturn
+}
 
-  for (let i = 0; i < len; i++){
-    willReturn[ i ] = start + i
-  }
+export function range(start) {
+  return end => {
+    if (Number.isNaN(Number(start)) || Number.isNaN(Number(end))) {
+      throw new TypeError('Both arguments to range must be numbers')
+    }
 
-  return willReturn
-}
+    if (end === start) {
+      return []
+    }
+		if (end < start) return rangeDescending(start,end)
+
+    const len = end - start
+    const willReturn = Array(len)
+
+    for (let i = 0; i < len; i++) {
+      willReturn[i] = start + i
+    }
+
+    return willReturn
+  }
 }
+
+

package/src/reject.js

@@ -1,5 +1,5 @@
 import { filter } from './filter.js'
 
 export function reject(predicate) {
-  return list => filter(x => !predicate(x), list)
+  return list => filter(x => !predicate(x))(list)
 }

package/src/rejectObject.js

@@ -0,0 +1,13 @@
+export function rejectObject(predicate) {
+  return obj => {
+    const willReturn = {}
+
+    for (const prop in obj) {
+      if (!predicate(obj[prop], prop, obj)) {
+        willReturn[prop] = obj[prop]
+      }
+    }
+
+    return willReturn
+  }
+}

package/src/shuffle.js

@@ -0,0 +1,13 @@
+export function shuffle(listInput) {
+  const list = cloneList(listInput)
+  let counter = list.length
+  while (counter > 0) {
+    const index = Math.floor(Math.random() * counter)
+    counter--
+    const temp = list[counter]
+    list[counter] = list[index]
+    list[index] = temp
+  }
+
+  return list
+}

package/src/sort.js

@@ -1,5 +1,5 @@
 import { cloneList } from './_internals/cloneList.js'
 
-export function sort(sortFn){
+export function sort(sortFn) {
   return list => cloneList(list).sort(sortFn)
 }

package/src/sortBy.js

@@ -1,16 +1,27 @@
 import { cloneList } from './_internals/cloneList.js'
 
-export function sortBy(sortFn){
-	return list => {
-  const clone = cloneList(list)
+export function sortByFn (
+	sortFn,
+	list,
+	descending
+){
+	const clone = cloneList(list)
 
-  return clone.sort((a, b) => {
-    const aSortResult = sortFn(a)
-    const bSortResult = sortFn(b)
+	return clone.sort((a, b) => {
+		const aSortResult = sortFn(a)
+		const bSortResult = sortFn(b)
 
-    if (aSortResult === bSortResult) return 0
+		if (aSortResult === bSortResult) {
+			return 0
+		}
+		if(
+			descending
+		) return aSortResult > bSortResult ? -1 : 1
 
-    return aSortResult < bSortResult ? -1 : 1
-  })
+		return aSortResult < bSortResult ? -1 : 1
+	})
 }
+
+export function sortBy(sortFn) {
+  return list => sortByFn(sortFn, list, false)
 }

package/src/sortByDescending.js

@@ -0,0 +1,5 @@
+import { sortByFn } from "./sortBy.js";
+
+export function sortByDescending(sortFn) {
+  return list => sortByFn(sortFn, list, true)
+}

package/src/sortByPath.js

@@ -0,0 +1,6 @@
+import { path } from './path.js'
+import { sortBy } from './sortBy.js'
+
+export function sortByPath(sortPath) {
+  return list => sortBy(path(sortPath))(list)
+}

package/src/sortByPathDescending.js

@@ -0,0 +1,6 @@
+import { path } from './path.js'
+import { sortByDescending } from './sortByDescending.js'
+
+export function sortByPathDescending(sortPath) {
+  return list => sortByDescending(path(sortPath))(list)
+}

package/src/sortObject.js

@@ -0,0 +1,15 @@
+import { sort } from './sort.js'
+
+export function sortObject(predicate) {
+  return obj => {
+    const keys = Object.keys(obj)
+    const sortedKeys = sort((a, b) => predicate(a, b, obj[a], obj[b]))(keys)
+
+    const toReturn = {}
+    sortedKeys.forEach(singleKey => {
+      toReturn[singleKey] = obj[singleKey]
+    })
+
+    return toReturn
+  }
+}