rambda 7.0.1 → 7.1.0

package/src/drop.js

@@ -1,4 +1,4 @@
-export function drop(howManyToDrop, listOrString) {
+export function drop(howManyToDrop, listOrString){
   if (arguments.length === 1) return _list => drop(howManyToDrop, _list)
 
   return listOrString.slice(howManyToDrop > 0 ? howManyToDrop : 0)

package/src/dropLast.js

@@ -1,9 +1,9 @@
-export function dropLast(howManyToDrop, listOrString) {
-  if (arguments.length === 1) {
+export function dropLast(howManyToDrop, listOrString){
+  if (arguments.length === 1){
     return _listOrString => dropLast(howManyToDrop, _listOrString)
   }
 
-  return howManyToDrop > 0
-    ? listOrString.slice(0, -howManyToDrop)
-    : listOrString.slice()
+  return howManyToDrop > 0 ?
+    listOrString.slice(0, -howManyToDrop) :
+    listOrString.slice()
 }

package/src/dropLastWhile.js

@@ -1,30 +1,30 @@
-import {_isArray} from './_internals/_isArray'
+import { _isArray } from './_internals/_isArray.js'
 
-export function dropLastWhile(predicate, iterable) {
-  if (arguments.length === 1) {
+export function dropLastWhile(predicate, iterable){
+  if (arguments.length === 1){
     return _iterable => dropLastWhile(predicate, _iterable)
   }
   if (iterable.length === 0) return iterable
   const isArray = _isArray(iterable)
 
-  if (typeof predicate !== 'function') {
-    throw new Error(`'predicate' is from wrong type ${typeof predicate}`)
+  if (typeof predicate !== 'function'){
+    throw new Error(`'predicate' is from wrong type ${ typeof predicate }`)
   }
-  if (!isArray && typeof iterable !== 'string') {
-    throw new Error(`'iterable' is from wrong type ${typeof iterable}`)
+  if (!isArray && typeof iterable !== 'string'){
+    throw new Error(`'iterable' is from wrong type ${ typeof iterable }`)
   }
 
   let found = false
   const toReturn = []
   let counter = iterable.length
 
-  while (counter > 0) {
+  while (counter > 0){
     counter--
-    if (!found && predicate(iterable[counter]) === false) {
+    if (!found && predicate(iterable[ counter ]) === false){
       found = true
-      toReturn.push(iterable[counter])
-    } else if (found) {
-      toReturn.push(iterable[counter])
+      toReturn.push(iterable[ counter ])
+    } else if (found){
+      toReturn.push(iterable[ counter ])
     }
   }
 

package/src/dropRepeats.js

@@ -1,15 +1,15 @@
-import {_isArray} from './_internals/_isArray'
-import {equals} from './equals'
+import { _isArray } from './_internals/_isArray.js'
+import { equals } from './equals.js'
 
-export function dropRepeats(list) {
-  if (!_isArray(list)) {
-    throw new Error(`${list} is not a list`)
+export function dropRepeats(list){
+  if (!_isArray(list)){
+    throw new Error(`${ list } is not a list`)
   }
 
   const toReturn = []
 
   list.reduce((prev, current) => {
-    if (!equals(prev, current)) {
+    if (!equals(prev, current)){
       toReturn.push(current)
     }
 

package/src/dropRepeatsWith.js

@@ -1,23 +1,23 @@
-import {_isArray} from './_internals/_isArray'
+import { _isArray } from './_internals/_isArray.js'
 
-export function dropRepeatsWith(predicate, list) {
-  if (arguments.length === 1) {
+export function dropRepeatsWith(predicate, list){
+  if (arguments.length === 1){
     return _iterable => dropRepeatsWith(predicate, _iterable)
   }
 
-  if (!_isArray(list)) {
-    throw new Error(`${list} is not a list`)
+  if (!_isArray(list)){
+    throw new Error(`${ list } is not a list`)
   }
 
   const toReturn = []
 
   list.reduce((prev, current) => {
-    if (prev === undefined) {
+    if (prev === undefined){
       toReturn.push(current)
 
       return current
     }
-    if (!predicate(prev, current)) {
+    if (!predicate(prev, current)){
       toReturn.push(current)
     }
 

package/src/dropWhile.js

@@ -1,24 +1,24 @@
-import {_isArray} from '../src/_internals/_isArray'
+import { _isArray } from '../src/_internals/_isArray.js'
 
-export function dropWhile(predicate, iterable) {
-  if (arguments.length === 1) {
+export function dropWhile(predicate, iterable){
+  if (arguments.length === 1){
     return _iterable => dropWhile(predicate, _iterable)
   }
   const isArray = _isArray(iterable)
-  if (!isArray && typeof iterable !== 'string') {
+  if (!isArray && typeof iterable !== 'string'){
     throw new Error('`iterable` is neither list nor a string')
   }
   let flag = false
   const holder = []
   let counter = -1
 
-  while (counter++ < iterable.length - 1) {
-    if (flag) {
-      holder.push(iterable[counter])
-    } else if (!predicate(iterable[counter])) {
+  while (counter++ < iterable.length - 1){
+    if (flag){
+      holder.push(iterable[ counter ])
+    } else if (!predicate(iterable[ counter ])){
       if (!flag) flag = true
 
-      holder.push(iterable[counter])
+      holder.push(iterable[ counter ])
     }
   }
 

package/src/either.js

@@ -1,5 +1,5 @@
-export function either(firstPredicate, secondPredicate) {
-  if (arguments.length === 1) {
+export function either(firstPredicate, secondPredicate){
+  if (arguments.length === 1){
     return _secondPredicate => either(firstPredicate, _secondPredicate)
   }
 

package/src/endsWith.js

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

package/src/eqProps.js

@@ -1,8 +1,10 @@
-import {curry} from './curry'
-import {equals} from './equals'
-import {prop} from './prop'
+import { curry } from './curry.js'
+import { equals } from './equals.js'
+import { prop } from './prop.js'
 
-function eqPropsFn(property, objA, objB) {
+function eqPropsFn(
+  property, objA, objB
+){
   return equals(prop(property, objA), prop(property, objB))
 }
 

package/src/equals.js

@@ -1,20 +1,20 @@
-import {type} from './type'
-import {_isArray} from './_internals/_isArray'
+import { _isArray } from './_internals/_isArray.js'
+import { type } from './type.js'
 
-export function _lastIndexOf(valueToFind, list) {
-  if (!_isArray(list)) {
-    throw new Error(`Cannot read property 'indexOf' of ${list}`)
+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))
+  if (![ 'Object', 'Array', 'NaN', 'RegExp' ].includes(typeOfValue))
     return list.lastIndexOf(valueToFind)
 
-  const {length} = list
+  const { length } = list
   let index = length
   let foundIndex = -1
 
-  while (--index > -1 && foundIndex === -1) {
-    if (equals(list[index], valueToFind)) {
+  while (--index > -1 && foundIndex === -1){
+    if (equals(list[ index ], valueToFind)){
       foundIndex = index
     }
   }
@@ -22,20 +22,20 @@ export function _lastIndexOf(valueToFind, list) {
   return foundIndex
 }
 
-export function _indexOf(valueToFind, list) {
-  if (!_isArray(list)) {
-    throw new Error(`Cannot read property 'indexOf' of ${list}`)
+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))
+  if (![ 'Object', 'Array', 'NaN', 'RegExp' ].includes(typeOfValue))
     return list.indexOf(valueToFind)
 
   let index = -1
   let foundIndex = -1
-  const {length} = list
+  const { length } = list
 
-  while (++index < length && foundIndex === -1) {
-    if (equals(list[index], valueToFind)) {
+  while (++index < length && foundIndex === -1){
+    if (equals(list[ index ], valueToFind)){
       foundIndex = index
     }
   }
@@ -43,97 +43,96 @@ export function _indexOf(valueToFind, list) {
   return foundIndex
 }
 
-function _arrayFromIterator(iter) {
+function _arrayFromIterator(iter){
   const list = []
   let next
-  while (!(next = iter.next()).done) {
+  while (!(next = iter.next()).done){
     list.push(next.value)
   }
+
   return list
 }
 
-function _equalsSets(a, b) {
-  if (a.size !== b.size) {
+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
-  )
+  const filtered = aList.filter(aInstance => _indexOf(aInstance, bList) === -1)
+
   return filtered.length === 0
 }
 
-function parseError(maybeError) {
+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() ]
 }
 
-function equalsSets(a, b) {
-  if (a.size !== b.size) {
+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
-  )
+  const filtered = aList.filter(aInstance => _indexOf(aInstance, bList) === -1)
+
   return filtered.length === 0
 }
 
-export function equals(a, b) {
+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
         }
       }
@@ -145,42 +144,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 === 'Set') {
+  if (aType === 'Set'){
     return _equalsSets(a, b)
   }
-  if (aType === 'Object') {
+  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.js'
+import { mapArray, mapObject } from './map.js'
+import { type } from './type.js'
 
-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,45 +16,43 @@ 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,28 +1,32 @@
-import {_isArray} from './_internals/_isArray'
+import { _isArray } from './_internals/_isArray.js'
 
-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++
@@ -31,14 +35,16 @@ export function filterArray(predicate, list, indexed = false) {
   return willReturn
 }
 
-export function filter(predicate, iterable) {
+export function filter(predicate, iterable){
   if (arguments.length === 1)
     return _iterable => filter(predicate, _iterable)
-  if (!iterable) {
+  if (!iterable){
     throw new Error('Incorrect iterable input')
   }
 
-  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
     }
   }