rambda 6.9.0 → 7.0.3

package/src/endsWith.js

@@ -1,5 +1,22 @@
-export function endsWith(target, str){
-  if (arguments.length === 1) return _str => endsWith(target, _str)
+import {equals} from './equals.js'
+import {_isArray} from './_internals/_isArray.js'
 
-  return str.endsWith(target)
+export function endsWith(target, iterable) {
+  if (arguments.length === 1) return _iterable => endsWith(target, _iterable)
+
+  if (typeof iterable === 'string') {
+    return iterable.endsWith(target)
+  }
+  if (!_isArray(target)) return false
+
+  const diff = iterable.length - target.length
+  let correct = true
+  const filtered = target.filter((x, index) => {
+    if (!correct) return false
+    const result = equals(x, iterable[index + diff])
+    if (!result) correct = false
+    return result
+  })
+
+  return filtered.length === target.length
 }

package/src/eqProps.js

@@ -1,14 +1,9 @@
-import { curry } from './curry'
-import { equals } from './equals'
+import {curry} from './curry'
+import {equals} from './equals'
+import {prop} from './prop'
 
-function eqPropsFn(
-  prop, obj1, obj2
-){
-  if (!obj1 || !obj2){
-    throw new Error('wrong object inputs are passed to R.eqProps')
-  }
-
-  return equals(obj1[ prop ], obj2[ prop ])
+function eqPropsFn(property, objA, objB) {
+  return equals(prop(property, objA), prop(property, objB))
 }
 
 export const eqProps = curry(eqPropsFn)

package/src/equals.js

@@ -1,60 +1,139 @@
-import { type } from './type'
+import {type} from './type'
+import {_isArray} from './_internals/_isArray'
 
-function parseError(maybeError){
+export function _lastIndexOf(valueToFind, list) {
+  if (!_isArray(list)) {
+    throw new Error(`Cannot read property 'indexOf' of ${list}`)
+  }
+  const typeOfValue = type(valueToFind)
+  if (!['Object', 'Array', 'NaN', 'RegExp'].includes(typeOfValue))
+    return list.lastIndexOf(valueToFind)
+
+  const {length} = list
+  let index = length
+  let foundIndex = -1
+
+  while (--index > -1 && foundIndex === -1) {
+    if (equals(list[index], valueToFind)) {
+      foundIndex = index
+    }
+  }
+
+  return foundIndex
+}
+
+export function _indexOf(valueToFind, list) {
+  if (!_isArray(list)) {
+    throw new Error(`Cannot read property 'indexOf' of ${list}`)
+  }
+  const typeOfValue = type(valueToFind)
+  if (!['Object', 'Array', 'NaN', 'RegExp'].includes(typeOfValue))
+    return list.indexOf(valueToFind)
+
+  let index = -1
+  let foundIndex = -1
+  const {length} = list
+
+  while (++index < length && foundIndex === -1) {
+    if (equals(list[index], valueToFind)) {
+      foundIndex = index
+    }
+  }
+
+  return foundIndex
+}
+
+function _arrayFromIterator(iter) {
+  const list = []
+  let next
+  while (!(next = iter.next()).done) {
+    list.push(next.value)
+  }
+  return list
+}
+
+function _equalsSets(a, b) {
+  if (a.size !== b.size) {
+    return false
+  }
+  const aList = _arrayFromIterator(a.values())
+  const bList = _arrayFromIterator(b.values())
+
+  const filtered = aList.filter(
+    aInstance => _indexOf(aInstance, bList) === -1
+  )
+  return filtered.length === 0
+}
+
+function parseError(maybeError) {
   const typeofError = maybeError.__proto__.toString()
-  if (![ 'Error', 'TypeError' ].includes(typeofError)) return []
+  if (!['Error', 'TypeError'].includes(typeofError)) return []
 
-  return [ typeofError, maybeError.message ]
+  return [typeofError, maybeError.message]
 }
 
-function parseDate(maybeDate){
-  if (!maybeDate.toDateString) return [ false ]
+function parseDate(maybeDate) {
+  if (!maybeDate.toDateString) return [false]
 
-  return [ true, maybeDate.getTime() ]
+  return [true, maybeDate.getTime()]
 }
 
-function parseRegex(maybeRegex){
-  if (maybeRegex.constructor !== RegExp) return [ false ]
+function parseRegex(maybeRegex) {
+  if (maybeRegex.constructor !== RegExp) return [false]
 
-  return [ true, maybeRegex.toString() ]
+  return [true, maybeRegex.toString()]
 }
 
-export function equals(a, b){
+function equalsSets(a, b) {
+  if (a.size !== b.size) {
+    return false
+  }
+  const aList = _arrayFromIterator(a.values())
+  const bList = _arrayFromIterator(b.values())
+
+  const filtered = aList.filter(
+    aInstance => _indexOf(aInstance, bList) === -1
+  )
+  return filtered.length === 0
+}
+
+export function equals(a, b) {
   if (arguments.length === 1) return _b => equals(a, _b)
 
   const aType = type(a)
+
   if (aType !== type(b)) return false
-  if (aType === 'Function'){
+  if (aType === 'Function') {
     return a.name === undefined ? false : a.name === b.name
   }
 
-  if ([ 'NaN', 'Undefined', 'Null' ].includes(aType)) return true
+  if (['NaN', 'Undefined', 'Null'].includes(aType)) return true
 
-  if (aType === 'Number'){
+  if (aType === 'Number') {
     if (Object.is(-0, a) !== Object.is(-0, b)) return false
 
     return a.toString() === b.toString()
   }
 
-  if ([ 'String', 'Boolean' ].includes(aType)){
+  if (['String', 'Boolean'].includes(aType)) {
     return a.toString() === b.toString()
   }
 
-  if (aType === 'Array'){
+  if (aType === 'Array') {
     const aClone = Array.from(a)
     const bClone = Array.from(b)
 
-    if (aClone.toString() !== bClone.toString()){
+    if (aClone.toString() !== bClone.toString()) {
       return false
     }
 
     let loopArrayFlag = true
     aClone.forEach((aCloneInstance, aCloneIndex) => {
-      if (loopArrayFlag){
+      if (loopArrayFlag) {
         if (
-          aCloneInstance !== bClone[ aCloneIndex ] &&
-          !equals(aCloneInstance, bClone[ aCloneIndex ])
-        ){
+          aCloneInstance !== bClone[aCloneIndex] &&
+          !equals(aCloneInstance, bClone[aCloneIndex])
+        ) {
           loopArrayFlag = false
         }
       }
@@ -66,40 +145,42 @@ export function equals(a, b){
   const aRegex = parseRegex(a)
   const bRegex = parseRegex(b)
 
-  if (aRegex[ 0 ]){
-    return bRegex[ 0 ] ? aRegex[ 1 ] === bRegex[ 1 ] : false
-  } else if (bRegex[ 0 ]) return false
+  if (aRegex[0]) {
+    return bRegex[0] ? aRegex[1] === bRegex[1] : false
+  } else if (bRegex[0]) return false
 
   const aDate = parseDate(a)
   const bDate = parseDate(b)
 
-  if (aDate[ 0 ]){
-    return bDate[ 0 ] ? aDate[ 1 ] === bDate[ 1 ] : false
-  } else if (bDate[ 0 ]) return false
+  if (aDate[0]) {
+    return bDate[0] ? aDate[1] === bDate[1] : false
+  } else if (bDate[0]) return false
 
   const aError = parseError(a)
   const bError = parseError(b)
 
-  if (aError[ 0 ]){
-    return bError[ 0 ] ?
-      aError[ 0 ] === bError[ 0 ] && aError[ 1 ] === bError[ 1 ] :
-      false
+  if (aError[0]) {
+    return bError[0]
+      ? aError[0] === bError[0] && aError[1] === bError[1]
+      : false
   }
-
-  if (aType === 'Object'){
+  if (aType === 'Set') {
+    return _equalsSets(a, b)
+  }
+  if (aType === 'Object') {
     const aKeys = Object.keys(a)
 
-    if (aKeys.length !== Object.keys(b).length){
+    if (aKeys.length !== Object.keys(b).length) {
       return false
     }
 
     let loopObjectFlag = true
     aKeys.forEach(aKeyInstance => {
-      if (loopObjectFlag){
-        const aValue = a[ aKeyInstance ]
-        const bValue = b[ aKeyInstance ]
+      if (loopObjectFlag) {
+        const aValue = a[aKeyInstance]
+        const bValue = b[aKeyInstance]
 
-        if (aValue !== bValue && !equals(aValue, bValue)){
+        if (aValue !== bValue && !equals(aValue, bValue)) {
           loopObjectFlag = false
         }
       }

package/src/evolve.js

@@ -1,12 +1,12 @@
-import { _isArray } from './_internals/_isArray'
-import { mapArray, mapObject } from './map'
-import { type } from './type'
+import {_isArray} from './_internals/_isArray'
+import {mapArray, mapObject} from './map'
+import {type} from './type'
 
-export function evolveArray(rules, list){
+export function evolveArray(rules, list) {
   return mapArray(
     (x, i) => {
-      if (type(rules[ i ]) === 'Function'){
-        return rules[ i ](x)
+      if (type(rules[i]) === 'Function') {
+        return rules[i](x)
       }
 
       return x
@@ -16,43 +16,45 @@ export function evolveArray(rules, list){
   )
 }
 
-export function evolveObject(rules, iterable){
+export function evolveObject(rules, iterable) {
   return mapObject((x, prop) => {
-    if (type(x) === 'Object'){
-      const typeRule = type(rules[ prop ])
-      if (typeRule === 'Function'){
-        return rules[ prop ](x)
+    if (type(x) === 'Object') {
+      const typeRule = type(rules[prop])
+      if (typeRule === 'Function') {
+        return rules[prop](x)
       }
-      if (typeRule === 'Object'){
-        return evolve(rules[ prop ], x)
+      if (typeRule === 'Object') {
+        return evolve(rules[prop], x)
       }
 
       return x
     }
-    if (type(rules[ prop ]) === 'Function'){
-      return rules[ prop ](x)
+    if (type(rules[prop]) === 'Function') {
+      return rules[prop](x)
     }
 
     return x
   }, iterable)
 }
 
-export function evolve(rules, iterable){
-  if (arguments.length === 1){
+export function evolve(rules, iterable) {
+  if (arguments.length === 1) {
     return _iterable => evolve(rules, _iterable)
   }
   const rulesType = type(rules)
   const iterableType = type(iterable)
 
-  if (iterableType !== rulesType){
+  if (iterableType !== rulesType) {
     throw new Error('iterableType !== rulesType')
   }
 
-  if (![ 'Object', 'Array' ].includes(rulesType)){
-    throw new Error(`'iterable' and 'rules' are from wrong type ${ rulesType }`)
+  if (!['Object', 'Array'].includes(rulesType)) {
+    throw new Error(
+      `'iterable' and 'rules' are from wrong type ${rulesType}`
+    )
   }
 
-  if (iterableType === 'Object'){
+  if (iterableType === 'Object') {
     return evolveObject(rules, iterable)
   }
 

package/src/filter.js

@@ -1,30 +1,28 @@
-import { _isArray } from './_internals/_isArray'
+import {_isArray} from './_internals/_isArray'
 
-export function filterObject(predicate, obj){
+export function filterObject(predicate, obj) {
   const willReturn = {}
 
-  for (const prop in obj){
-    if (predicate(obj[ prop ], prop, obj)){
-      willReturn[ prop ] = obj[ prop ]
+  for (const prop in obj) {
+    if (predicate(obj[prop], prop, obj)) {
+      willReturn[prop] = obj[prop]
     }
   }
 
   return willReturn
 }
 
-export function filterArray(
-  predicate, list, indexed = false
-){
+export function filterArray(predicate, list, indexed = false) {
   let index = 0
   const len = list.length
   const willReturn = []
 
-  while (index < len){
-    const predicateResult = indexed ?
-      predicate(list[ index ], index) :
-      predicate(list[ index ])
-    if (predicateResult){
-      willReturn.push(list[ index ])
+  while (index < len) {
+    const predicateResult = indexed
+      ? predicate(list[index], index)
+      : predicate(list[index])
+    if (predicateResult) {
+      willReturn.push(list[index])
     }
 
     index++
@@ -33,12 +31,14 @@ export function filterArray(
   return willReturn
 }
 
-export function filter(predicate, iterable){
-  if (arguments.length === 1){
+export function filter(predicate, iterable) {
+  if (arguments.length === 1)
     return _iterable => filter(predicate, _iterable)
+  if (!iterable) {
+    throw new Error('Incorrect iterable input')
   }
-  if (!iterable) return []
-  if (_isArray(iterable)) return filterArray(predicate, iterable)
+
+  if (_isArray(iterable)) return filterArray(predicate, iterable, false)
 
   return filterObject(predicate, iterable)
 }

package/src/find.js

@@ -1,12 +1,12 @@
-export function find(predicate, list){
+export function find(predicate, list) {
   if (arguments.length === 1) return _list => find(predicate, _list)
 
   let index = 0
   const len = list.length
 
-  while (index < len){
-    const x = list[ index ]
-    if (predicate(x)){
+  while (index < len) {
+    const x = list[index]
+    if (predicate(x)) {
       return x
     }
 

package/src/findIndex.js

@@ -1,11 +1,11 @@
-export function findIndex(predicate, list){
+export function findIndex(predicate, list) {
   if (arguments.length === 1) return _list => findIndex(predicate, _list)
 
   const len = list.length
   let index = -1
 
-  while (++index < len){
-    if (predicate(list[ index ])){
+  while (++index < len) {
+    if (predicate(list[index])) {
       return index
     }
   }

package/src/findLast.js

@@ -1,11 +1,11 @@
-export function findLast(predicate, list){
+export function findLast(predicate, list) {
   if (arguments.length === 1) return _list => findLast(predicate, _list)
 
   let index = list.length
 
-  while (--index >= 0){
-    if (predicate(list[ index ])){
-      return list[ index ]
+  while (--index >= 0) {
+    if (predicate(list[index])) {
+      return list[index]
     }
   }
 

package/src/findLastIndex.js

@@ -1,10 +1,10 @@
-export function findLastIndex(fn, list){
+export function findLastIndex(fn, list) {
   if (arguments.length === 1) return _list => findLastIndex(fn, _list)
 
   let index = list.length
 
-  while (--index >= 0){
-    if (fn(list[ index ])){
+  while (--index >= 0) {
+    if (fn(list[index])) {
       return index
     }
   }

package/src/flatten.js

@@ -1,13 +1,13 @@
-import { _isArray } from './_internals/_isArray'
+import {_isArray} from './_internals/_isArray'
 
-export function flatten(list, input){
+export function flatten(list, input) {
   const willReturn = input === undefined ? [] : input
 
-  for (let i = 0; i < list.length; i++){
-    if (_isArray(list[ i ])){
-      flatten(list[ i ], willReturn)
+  for (let i = 0; i < list.length; i++) {
+    if (_isArray(list[i])) {
+      flatten(list[i], willReturn)
     } else {
-      willReturn.push(list[ i ])
+      willReturn.push(list[i])
     }
   }
 

package/src/flip.js

@@ -1,23 +1,19 @@
-function flipFn(fn){
+function flipFn(fn) {
   return (...input) => {
-    if (input.length === 1){
-      return holder => fn(holder, input[ 0 ])
-    } else if (input.length === 2){
-      return fn(input[ 1 ], input[ 0 ])
-    } else if (input.length === 3){
-      return fn(
-        input[ 1 ], input[ 0 ], input[ 2 ]
-      )
-    } else if (input.length === 4){
-      return fn(
-        input[ 1 ], input[ 0 ], input[ 2 ], input[ 3 ]
-      )
+    if (input.length === 1) {
+      return holder => fn(holder, input[0])
+    } else if (input.length === 2) {
+      return fn(input[1], input[0])
+    } else if (input.length === 3) {
+      return fn(input[1], input[0], input[2])
+    } else if (input.length === 4) {
+      return fn(input[1], input[0], input[2], input[3])
     }
 
-    throw new Error('R.flip doesn\'t work with arity > 4')
+    throw new Error("R.flip doesn't work with arity > 4")
   }
 }
 
-export function flip(fn){
+export function flip(fn) {
   return flipFn(fn)
 }

package/src/forEach.js

@@ -1,19 +1,19 @@
-import { _isArray } from './_internals/_isArray'
-import { _keys } from './_internals/_keys'
+import {_isArray} from './_internals/_isArray'
+import {_keys} from './_internals/_keys'
 
-export function forEach(fn, list){
+export function forEach(fn, list) {
   if (arguments.length === 1) return _list => forEach(fn, _list)
 
-  if (list === undefined){
+  if (list === undefined) {
     return
   }
 
-  if (_isArray(list)){
+  if (_isArray(list)) {
     let index = 0
     const len = list.length
 
-    while (index < len){
-      fn(list[ index ])
+    while (index < len) {
+      fn(list[index])
       index++
     }
   } else {
@@ -21,11 +21,9 @@ export function forEach(fn, list){
     const keys = _keys(list)
     const len = keys.length
 
-    while (index < len){
-      const key = keys[ index ]
-      fn(
-        list[ key ], key, list
-      )
+    while (index < len) {
+      const key = keys[index]
+      fn(list[key], key, list)
       index++
     }
   }

package/src/fromPairs.js

@@ -1,6 +1,6 @@
-export function fromPairs(listOfPairs){
+export function fromPairs(listOfPairs) {
   const toReturn = {}
-  listOfPairs.forEach(([ prop, value ]) => toReturn[ prop ] = value)
+  listOfPairs.forEach(([prop, value]) => (toReturn[prop] = value))
 
   return toReturn
 }

package/src/groupBy.js

@@ -1,16 +1,16 @@
-export function groupBy(groupFn, list){
+export function groupBy(groupFn, list) {
   if (arguments.length === 1) return _list => groupBy(groupFn, _list)
 
   const result = {}
-  for (let i = 0; i < list.length; i++){
-    const item = list[ i ]
+  for (let i = 0; i < list.length; i++) {
+    const item = list[i]
     const key = groupFn(item)
 
-    if (!result[ key ]){
-      result[ key ] = []
+    if (!result[key]) {
+      result[key] = []
     }
 
-    result[ key ].push(item)
+    result[key].push(item)
   }
 
   return result

package/src/groupWith.js

@@ -1,25 +1,24 @@
-import { _isArray } from './_internals/_isArray'
+import {_isArray} from './_internals/_isArray'
+import {cloneList} from './_internals/cloneList'
 
-export function groupWith(compareFn, list){
+export function groupWith(compareFn, list) {
   if (!_isArray(list)) throw new TypeError('list.reduce is not a function')
 
-  const clone = list.slice()
+  const clone = cloneList(list)
 
-  if (list.length === 1) return [ clone ]
+  if (list.length === 1) return [clone]
 
   const toReturn = []
   let holder = []
 
-  clone.reduce((
-    prev, current, i
-  ) => {
+  clone.reduce((prev, current, i) => {
     if (i === 0) return current
 
     const okCompare = compareFn(prev, current)
     const holderIsEmpty = holder.length === 0
     const lastCall = i === list.length - 1
 
-    if (okCompare){
+    if (okCompare) {
       if (holderIsEmpty) holder.push(prev)
       holder.push(current)
       if (lastCall) toReturn.push(holder)
@@ -27,15 +26,15 @@ export function groupWith(compareFn, list){
       return current
     }
 
-    if (holderIsEmpty){
-      toReturn.push([ prev ])
-      if (lastCall) toReturn.push([ current ])
+    if (holderIsEmpty) {
+      toReturn.push([prev])
+      if (lastCall) toReturn.push([current])
 
       return current
     }
 
     toReturn.push(holder)
-    if (lastCall) toReturn.push([ current ])
+    if (lastCall) toReturn.push([current])
     holder = []
 
     return current

package/src/hasPath.js

@@ -1,9 +1,9 @@
-import { path } from './path'
+import {path} from './path'
 
-export function hasPath(maybePath, obj){
-  if (arguments.length === 1){
-    return objHolder => hasPath(maybePath, objHolder)
+export function hasPath(pathInput, obj) {
+  if (arguments.length === 1) {
+    return objHolder => hasPath(pathInput, objHolder)
   }
 
-  return path(maybePath, obj) !== undefined
+  return path(pathInput, obj) !== undefined
 }