rambda 6.9.0 → 7.0.0

package/src/ifElse.js

@@ -1,13 +1,11 @@
-import { curry } from './curry'
+import {curry} from './curry'
 
-function ifElseFn(
-  condition, onTrue, onFalse
-){
+function ifElseFn(condition, onTrue, onFalse) {
   return (...input) => {
     const conditionResult =
       typeof condition === 'boolean' ? condition : condition(...input)
 
-    if (conditionResult === true){
+    if (conditionResult === true) {
       return onTrue(...input)
     }
 

package/src/includes.js

@@ -1,15 +1,16 @@
-import { _isArray } from './_internals/_isArray'
-import { _indexOf } from './indexOf'
+import {_isArray} from './_internals/_isArray'
+import {_indexOf} from './equals'
 
-export function includes(valueToFind, input){
-  if (arguments.length === 1) return _input => includes(valueToFind, _input)
-  if (typeof input === 'string'){
-    return input.includes(valueToFind)
+export function includes(valueToFind, iterable) {
+  if (arguments.length === 1)
+    return _iterable => includes(valueToFind, _iterable)
+  if (typeof iterable === 'string') {
+    return iterable.includes(valueToFind)
   }
-  if (!input){
-    throw new TypeError(`Cannot read property \'indexOf\' of ${ input }`)
+  if (!iterable) {
+    throw new TypeError(`Cannot read property \'indexOf\' of ${iterable}`)
   }
-  if (!_isArray(input)) return false
+  if (!_isArray(iterable)) return false
 
-  return _indexOf(valueToFind, input) > -1
+  return _indexOf(valueToFind, iterable) > -1
 }

package/src/indexBy.js

@@ -1,28 +1,28 @@
-import { path } from './path'
+import {path} from './path'
 
-function indexByPath(pathInput, list){
+function indexByPath(pathInput, list) {
   const toReturn = {}
-  for (let i = 0; i < list.length; i++){
-    const item = list[ i ]
-    toReturn[ path(pathInput, item) ] = item
+  for (let i = 0; i < list.length; i++) {
+    const item = list[i]
+    toReturn[path(pathInput, item)] = item
   }
 
   return toReturn
 }
 
-export function indexBy(condition, list){
-  if (arguments.length === 1){
+export function indexBy(condition, list) {
+  if (arguments.length === 1) {
     return _list => indexBy(condition, _list)
   }
 
-  if (typeof condition === 'string'){
+  if (typeof condition === 'string') {
     return indexByPath(condition, list)
   }
 
   const toReturn = {}
-  for (let i = 0; i < list.length; i++){
-    const item = list[ i ]
-    toReturn[ condition(item) ] = item
+  for (let i = 0; i < list.length; i++) {
+    const item = list[i]
+    toReturn[condition(item)] = item
   }
 
   return toReturn

package/src/indexOf.js

@@ -1,29 +1,7 @@
-import { equals } from './equals'
-import { type } from './type'
-import { _isArray } from './_internals/_isArray'
+import {_indexOf} from './equals'
 
-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
-}
-
-export function indexOf(valueToFind, list){
-  if (arguments.length === 1){
+export function indexOf(valueToFind, list) {
+  if (arguments.length === 1) {
     return _list => _indexOf(valueToFind, _list)
   }
 

package/src/init.js

@@ -1,9 +1,7 @@
 import baseSlice from './_internals/baseSlice'
 
-export function init(listOrString){
+export function init(listOrString) {
   if (typeof listOrString === 'string') return listOrString.slice(0, -1)
 
-  return listOrString.length ? baseSlice(
-    listOrString, 0, -1
-  ) : []
+  return listOrString.length ? baseSlice(listOrString, 0, -1) : []
 }

package/src/intersection.js

@@ -1,7 +1,7 @@
-import { filter } from './filter'
-import { includes } from './includes'
+import {filter} from './filter'
+import {includes} from './includes'
 
-export function intersection(listA, listB){
+export function intersection(listA, listB) {
   if (arguments.length === 1) return _list => intersection(listA, _list)
 
   return filter(x => includes(x, listA), listB)

package/src/intersperse.js

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

package/src/is.js

@@ -1,8 +1,8 @@
-export function is(targetPrototype, x){
+export function is(targetPrototype, x) {
   if (arguments.length === 1) return _x => is(targetPrototype, _x)
 
   return (
-    x != null && x.constructor === targetPrototype ||
+    (x != null && x.constructor === targetPrototype) ||
     x instanceof targetPrototype
   )
 }

package/src/isEmpty.js

@@ -1,16 +1,16 @@
-import { type } from './type'
+import {type} from './type'
 
-export function isEmpty(input){
+export function isEmpty(input) {
   const inputType = type(input)
-  if ([ 'Undefined', 'NaN', 'Number', 'Null' ].includes(inputType))
+  if (['Undefined', 'NaN', 'Number', 'Null'].includes(inputType))
     return false
   if (!input) return true
 
-  if (inputType === 'Object'){
+  if (inputType === 'Object') {
     return Object.keys(input).length === 0
   }
 
-  if (inputType === 'Array'){
+  if (inputType === 'Array') {
     return input.length === 0
   }
 

package/src/isFunction.js

@@ -1,5 +1,5 @@
-import { type } from './type'
+import {type} from './type'
 
-export function isFunction(fn){
-  return [ 'Async', 'Function' ].includes(type(fn))
+export function isFunction(fn) {
+  return ['Async', 'Function'].includes(type(fn))
 }

package/src/isNil.js

@@ -1,3 +1,3 @@
-export function isNil(x){
+export function isNil(x) {
   return x === undefined || x === null
 }

package/src/isPromise.js

@@ -1,5 +1,5 @@
-import { type } from './type'
+import {type} from './type'
 
-export function isPromise(x){
-  return [ 'Async', 'Promise' ].includes(type(x))
+export function isPromise(x) {
+  return ['Async', 'Promise'].includes(type(x))
 }

package/src/join.js

@@ -1,4 +1,4 @@
-export function join(glue, list){
+export function join(glue, list) {
   if (arguments.length === 1) return _list => join(glue, _list)
 
   return list.join(glue)

package/src/keys.js

@@ -1,3 +1,3 @@
-export function keys(x){
+export function keys(x) {
   return Object.keys(x)
 }

package/src/last.js

@@ -1,7 +1,7 @@
-export function last(listOrString){
-  if (typeof listOrString === 'string'){
-    return listOrString[ listOrString.length - 1 ] || ''
+export function last(listOrString) {
+  if (typeof listOrString === 'string') {
+    return listOrString[listOrString.length - 1] || ''
   }
 
-  return listOrString[ listOrString.length - 1 ]
+  return listOrString[listOrString.length - 1]
 }

package/src/lastIndexOf.js

@@ -1,15 +1,9 @@
-import { equals } from './equals'
+import {_lastIndexOf} from './equals'
 
-export function lastIndexOf(target, list){
-  if (arguments.length === 1) return _list => lastIndexOf(target, _list)
-
-  let index = list.length
-
-  while (--index > 0){
-    if (equals(list[ index ], target)){
-      return index
-    }
+export function lastIndexOf(valueToFind, list) {
+  if (arguments.length === 1) {
+    return _list => _lastIndexOf(valueToFind, _list)
   }
 
-  return -1
+  return _lastIndexOf(valueToFind, list)
 }

package/src/length.js

@@ -1,7 +1,8 @@
-export function length(x){
-  if (!x && x !== '' || x.length === undefined){
-    return NaN
-  }
+import {_isArray} from './_internals/_isArray'
 
-  return x.length
+export function length(x) {
+  if (_isArray(x)) return x.length
+  if (typeof x === 'string') return x.length
+
+  return NaN
 }

package/src/lens.js

@@ -1,6 +1,6 @@
-export function lens(getter, setter){
-  return function (functor){
-    return function (target){
+export function lens(getter, setter) {
+  return function (functor) {
+    return function (target) {
       return functor(getter(target)).map(focus => setter(focus, target))
     }
   }

package/src/lensIndex.js

@@ -1,7 +1,7 @@
-import { lens } from './lens'
-import { nth } from './nth'
-import { update } from './update'
+import {lens} from './lens'
+import {nth} from './nth'
+import {update} from './update'
 
-export function lensIndex(index){
+export function lensIndex(index) {
   return lens(nth(index), update(index))
 }

package/src/lensProp.js

@@ -1,7 +1,7 @@
-import { assoc } from './assoc'
-import { lens } from './lens'
-import { prop } from './prop'
+import {assoc} from './assoc'
+import {lens} from './lens'
+import {prop} from './prop'
 
-export function lensProp(key){
+export function lensProp(key) {
   return lens(prop(key), assoc(key))
 }

package/src/map.js

@@ -1,14 +1,12 @@
-import { _isArray } from './_internals/_isArray'
-import { _keys } from './_internals/_keys'
+import {_isArray} from './_internals/_isArray'
+import {_keys} from './_internals/_keys'
 
-export function mapArray(
-  fn, list, isIndexed = false
-){
+export function mapArray(fn, list, isIndexed = false) {
   let index = 0
   const willReturn = Array(list.length)
 
-  while (index < list.length){
-    willReturn[ index ] = isIndexed ? fn(list[ index ], index) : fn(list[ index ])
+  while (index < list.length) {
+    willReturn[index] = isIndexed ? fn(list[index], index) : fn(list[index])
 
     index++
   }
@@ -16,17 +14,15 @@ export function mapArray(
   return willReturn
 }
 
-export function mapObject(fn, obj){
+export function mapObject(fn, obj) {
   let index = 0
   const keys = _keys(obj)
   const len = keys.length
   const willReturn = {}
 
-  while (index < len){
-    const key = keys[ index ]
-    willReturn[ key ] = fn(
-      obj[ key ], key, obj
-    )
+  while (index < len) {
+    const key = keys[index]
+    willReturn[key] = fn(obj[key], key, obj)
     index++
   }
 
@@ -35,10 +31,13 @@ export function mapObject(fn, obj){
 
 export const mapObjIndexed = mapObject
 
-export function map(fn, list){
-  if (arguments.length === 1) return _list => map(fn, _list)
-  if (list === undefined) return []
-  if (_isArray(list)) return mapArray(fn, list)
+export function map(fn, iterable) {
+  if (arguments.length === 1) return _iterable => map(fn, _iterable)
+  if (!iterable) {
+    throw new Error('Incorrect iterable input')
+  }
+
+  if (_isArray(iterable)) return mapArray(fn, iterable)
 
-  return mapObject(fn, list)
+  return mapObject(fn, iterable)
 }

package/src/match.js

@@ -1,4 +1,4 @@
-export function match(pattern, input){
+export function match(pattern, input) {
   if (arguments.length === 1) return _input => match(pattern, _input)
 
   const willReturn = input.match(pattern)

package/src/mathMod.js

@@ -1,8 +1,8 @@
 import _isInteger from './_internals/_isInteger'
 
-export function mathMod(x, y){
+export function mathMod(x, y) {
   if (arguments.length === 1) return _y => mathMod(x, _y)
   if (!_isInteger(x) || !_isInteger(y) || y < 1) return NaN
 
-  return (x % y + y) % y
+  return ((x % y) + y) % y
 }

package/src/max.js

@@ -1,4 +1,4 @@
-export function max(x, y){
+export function max(x, y) {
   if (arguments.length === 1) return _y => max(x, _y)
 
   return y > x ? y : x

package/src/maxBy.js

@@ -1,8 +1,6 @@
-import { curry } from './curry'
+import {curry} from './curry'
 
-export function maxByFn(
-  compareFn, x, y
-){
+export function maxByFn(compareFn, x, y) {
   return compareFn(y) > compareFn(x) ? y : x
 }
 

package/src/maybe.js

@@ -1,8 +1,6 @@
-import { type } from './type'
+import {type} from './type'
 
-export function maybe(
-  ifRule, whenIf, whenElse
-){
+export function maybe(ifRule, whenIf, whenElse) {
   const whenIfInput =
     ifRule && type(whenIf) === 'Function' ? whenIf() : whenIf
 

package/src/mean.js

@@ -1,5 +1,5 @@
-import { sum } from './sum'
+import {sum} from './sum'
 
-export function mean(list){
+export function mean(list) {
   return sum(list) / list.length
 }

package/src/median.js

@@ -1,17 +1,19 @@
-import { mean } from './mean'
+import {mean} from './mean'
 
-export function median(list){
+export function median(list) {
   const len = list.length
   if (len === 0) return NaN
-  const width = 2 - len % 2
+  const width = 2 - (len % 2)
   const idx = (len - width) / 2
 
-  return mean(Array.prototype.slice
-    .call(list, 0)
-    .sort((a, b) => {
-      if (a === b) return 0
+  return mean(
+    Array.prototype.slice
+      .call(list, 0)
+      .sort((a, b) => {
+        if (a === b) return 0
 
-      return a < b ? -1 : 1
-    })
-    .slice(idx, idx + width))
+        return a < b ? -1 : 1
+      })
+      .slice(idx, idx + width)
+  )
 }

package/src/merge.js

@@ -1,7 +1,5 @@
-export function merge(target, newProps){
+export function merge(target, newProps) {
   if (arguments.length === 1) return _newProps => merge(target, _newProps)
 
-  return Object.assign(
-    {}, target || {}, newProps || {}
-  )
+  return Object.assign({}, target || {}, newProps || {})
 }

package/src/mergeAll.js

@@ -1,7 +1,7 @@
-import { map } from './map'
-import { merge } from './merge'
+import {map} from './map'
+import {merge} from './merge'
 
-export function mergeAll(arr){
+export function mergeAll(arr) {
   let willReturn = {}
   map(val => {
     willReturn = merge(willReturn, val)

package/src/mergeDeepRight.js

@@ -1,21 +1,21 @@
-import { type } from './type'
+import {type} from './type'
 
-export function mergeDeepRight(target, source){
-  if (arguments.length === 1){
+export function mergeDeepRight(target, source) {
+  if (arguments.length === 1) {
     return sourceHolder => mergeDeepRight(target, sourceHolder)
   }
 
   const willReturn = JSON.parse(JSON.stringify(target))
 
   Object.keys(source).forEach(key => {
-    if (type(source[ key ]) === 'Object'){
-      if (type(target[ key ]) === 'Object'){
-        willReturn[ key ] = mergeDeepRight(target[ key ], source[ key ])
+    if (type(source[key]) === 'Object') {
+      if (type(target[key]) === 'Object') {
+        willReturn[key] = mergeDeepRight(target[key], source[key])
       } else {
-        willReturn[ key ] = source[ key ]
+        willReturn[key] = source[key]
       }
     } else {
-      willReturn[ key ] = source[ key ]
+      willReturn[key] = source[key]
     }
   })
 

package/src/mergeLeft.js

@@ -1,6 +1,6 @@
-import { merge } from './merge'
+import {merge} from './merge'
 
-export function mergeLeft(x, y){
+export function mergeLeft(x, y) {
   if (arguments.length === 1) return _y => mergeLeft(x, _y)
 
   return merge(y, x)

package/src/min.js

@@ -1,4 +1,4 @@
-export function min(x, y){
+export function min(x, y) {
   if (arguments.length === 1) return _y => min(x, _y)
 
   return y < x ? y : x

package/src/minBy.js

@@ -1,8 +1,6 @@
-import { curry } from './curry'
+import {curry} from './curry'
 
-export function minByFn(
-  compareFn, x, y
-){
+export function minByFn(compareFn, x, y) {
   return compareFn(y) < compareFn(x) ? y : x
 }
 

package/src/modulo.js

@@ -1,4 +1,4 @@
-export function modulo(x, y){
+export function modulo(x, y) {
   if (arguments.length === 1) return _y => modulo(x, _y)
 
   return x % y

package/src/move.js

@@ -1,16 +1,15 @@
-import { curry } from './curry'
+import {curry} from './curry'
+import {cloneList} from './_internals/cloneList'
 
-function moveFn(
-  fromIndex, toIndex, list
-){
-  if (fromIndex < 0 || toIndex < 0){
+function moveFn(fromIndex, toIndex, list) {
+  if (fromIndex < 0 || toIndex < 0) {
     throw new Error('Rambda.move does not support negative indexes')
   }
   if (fromIndex > list.length - 1 || toIndex > list.length - 1) return list
 
-  const clone = list.slice()
-  clone[ fromIndex ] = list[ toIndex ]
-  clone[ toIndex ] = list[ fromIndex ]
+  const clone = cloneList(list)
+  clone[fromIndex] = list[toIndex]
+  clone[toIndex] = list[fromIndex]
 
   return clone
 }

package/src/multiply.js

@@ -1,4 +1,4 @@
-export function multiply(x, y){
+export function multiply(x, y) {
   if (arguments.length === 1) return _y => multiply(x, _y)
 
   return x * y

package/src/negate.js

@@ -1,3 +1,3 @@
-export function negate(x){
+export function negate(x) {
   return -x
 }

package/src/none.js

@@ -1,8 +1,8 @@
-export function none(predicate, list){
+export function none(predicate, list) {
   if (arguments.length === 1) return _list => none(predicate, _list)
 
-  for (let i = 0; i < list.length; i++){
-    if (!predicate(list[ i ])) return true
+  for (let i = 0; i < list.length; i++) {
+    if (!predicate(list[i])) return true
   }
 
   return false

package/src/not.js

@@ -1,3 +1,3 @@
-export function not(input){
+export function not(input) {
   return !input
 }

package/src/nth.js

@@ -1,9 +1,9 @@
-export function nth(index, list){
+export function nth(index, list) {
   if (arguments.length === 1) return _list => nth(index, _list)
 
   const idx = index < 0 ? list.length + index : index
 
-  return Object.prototype.toString.call(list) === '[object String]' ?
-    list.charAt(idx) :
-    list[ idx ]
+  return Object.prototype.toString.call(list) === '[object String]'
+    ? list.charAt(idx)
+    : list[idx]
 }