rubico 2.7.3 → 2.7.5

package/x/differenceWith.js

@@ -32,13 +32,13 @@ const differenceWithArrayAsync = async function (
 ) {
   const allValuesLength = allValues.length
   while (++index < allValuesLength) {
-    const item = allValues[index]
-    let doesItemExistByComparator = arraySome(array, curry2(comparator, item, __))
-    if (isPromise(doesItemExistByComparator)) {
-      doesItemExistByComparator = await doesItemExistByComparator
+    const element = allValues[index]
+    let doesElementExistByComparator = arraySome(array, curry2(comparator, element, __))
+    if (isPromise(doesElementExistByComparator)) {
+      doesElementExistByComparator = await doesElementExistByComparator
     }
-    if (!doesItemExistByComparator) {
-      result.push(item)
+    if (!doesElementExistByComparator) {
+      result.push(element)
     }
   }
   return result
@@ -61,14 +61,14 @@ const differenceWithArray = function (comparator, allValues, array) {
     result = []
   let index = -1
   while (++index < allValuesLength) {
-    const item = allValues[index],
-      doesItemExistByComparator = arraySome(array, curry2(comparator, item, __))
-    if (isPromise(doesItemExistByComparator)) {
-      return doesItemExistByComparator.then(funcConcatSync(
-        curry3(thunkConditional, __, noop, thunkify2(arrayPush, result, item)),
+    const element = allValues[index],
+      doesElementExistByComparator = arraySome(array, curry2(comparator, element, __))
+    if (isPromise(doesElementExistByComparator)) {
+      return doesElementExistByComparator.then(funcConcatSync(
+        curry3(thunkConditional, __, noop, thunkify2(arrayPush, result, element)),
         thunkify5(differenceWithArrayAsync, comparator, allValues, array, result, index)))
-    } else if (!doesItemExistByComparator) {
-      result.push(item)
+    } else if (!doesElementExistByComparator) {
+      result.push(element)
     }
   }
   return result

package/x/find.d.ts

@@ -15,7 +15,7 @@ export = find;
  * ```
  *
  * @description
- * Get the first item in a foldable collection that matches a predicate.
+ * Get the first element in a foldable collection that matches a predicate.
  *
  * ```javascript [playground]
  * import find from 'https://unpkg.com/rubico/dist/x/find.es.js'

package/x/find.js

@@ -22,7 +22,7 @@ const asyncIteratorFind = require('../_internal/asyncIteratorFind')
  * ```
  *
  * @description
- * Get the first item in a foldable collection that matches a predicate.
+ * Get the first element in a foldable collection that matches a predicate.
  *
  * ```javascript [playground]
  * import find from 'https://unpkg.com/rubico/dist/x/find.es.js'

package/x/find.test.js

@@ -2,7 +2,7 @@ const assert = require('assert')
 const find = require('./find')
 
 describe('find', () => {
-  it('gets the first item that passes test', async () => {
+  it('gets the first element that passes test', async () => {
     assert.strictEqual(
       find(x => x > 2)([1, 2, 3]),
       3,
@@ -33,7 +33,7 @@ describe('find', () => {
     )
   })
 
-  it('returns undefined for no items passing', async () => {
+  it('returns undefined for no elements passing', async () => {
     assert.strictEqual(
       find(x => x > 3)([1, 2, 3]),
       undefined,

package/x/findIndex.test.js

@@ -2,7 +2,7 @@ const assert = require('assert')
 const findIndex = require('./findIndex')
 
 describe('findIndex', function () {
-  it('finds the index in an array of the first item matching a predicate function', async function () {
+  it('finds the index in an array of the first element matching a predicate function', async function () {
     const startsWithAAA = string => string.startsWith('AAA')
     {
       const foundIndex = findIndex(startsWithAAA)([

package/x/first.d.ts

@@ -10,7 +10,7 @@ export = first;
  * ```
  *
  * @description
- * Get the first item of a collection
+ * Get the first element of a collection
  *
  * ```javascript [playground]
  * import first from 'https://unpkg.com/rubico/dist/x/first.es.js'

package/x/first.js

@@ -9,7 +9,7 @@
  * ```
  *
  * @description
- * Get the first item of a collection
+ * Get the first element of a collection
  *
  * ```javascript [playground]
  * import first from 'https://unpkg.com/rubico/dist/x/first.es.js'

package/x/first.test.js

@@ -2,7 +2,7 @@ const assert = require('assert')
 const first = require('./first')
 
 describe('first', () => {
-  it('gets the first item of an array', async () => {
+  it('gets the first element of an array', async () => {
     assert.strictEqual(first([1, 2, 3]), 1)
     assert.strictEqual(first([]), undefined)
   })

package/x/groupBy.d.ts

@@ -35,7 +35,7 @@ export = groupBy;
  * // }
  * ```
  *
- * Additionally, pass a resolver in property position to resolve a value for group membership for each item.
+ * Additionally, pass a resolver in property position to resolve a value for group membership for each element.
  *
  * ```javascript [playground]
  * import groupBy from 'https://unpkg.com/rubico/dist/x/groupBy.es.js'

package/x/groupBy.js

@@ -4,33 +4,33 @@ const reduce = require('../reduce')
 const __ = require('../_internal/placeholder')
 const curry3 = require('../_internal/curry3')
 
-// (mapOfArrays Map<any=>Array>, key any, item any) => mapOfArrays
+// (mapOfArrays Map<any=>Array>, key any, element any) => mapOfArrays
 // TODO: benchmark vs mapOfArrays.has(key)
-const group = function (mapOfArrays, key, item) {
+const group = function (mapOfArrays, key, element) {
   const array = mapOfArrays.get(key)
   if (array == null) {
-    mapOfArrays.set(key, [item])
+    mapOfArrays.set(key, [element])
   } else {
-    array.push(item)
+    array.push(element)
   }
   return mapOfArrays
 }
 
-// property string => (mapOfArrays Map<any=>Array>, item any) => mapOfArrays
+// property string => (mapOfArrays Map<any=>Array>, element any) => mapOfArrays
 const groupByProperty = property => function groupByPropertyReducer(
-  mapOfArrays, item,
+  mapOfArrays, element,
 ) {
-  return group(mapOfArrays, item[property], item)
+  return group(mapOfArrays, element[property], element)
 }
 
-// resolver any=>any => (mapOfArrays Map<any=>Array>, item any) => mapOfArrays
+// resolver any=>any => (mapOfArrays Map<any=>Array>, element any) => mapOfArrays
 const groupByResolver = resolver => function groupByResolverReducer(
-  mapOfArrays, item,
+  mapOfArrays, element,
 ) {
-  const key = resolver(item)
+  const key = resolver(element)
   return isPromise(key)
-    ? key.then(curry3(group, mapOfArrays, __, item))
-    : group(mapOfArrays, key, item)
+    ? key.then(curry3(group, mapOfArrays, __, element))
+    : group(mapOfArrays, key, element)
 }
 
 
@@ -70,7 +70,7 @@ const groupByResolver = resolver => function groupByResolverReducer(
  * // }
  * ```
  *
- * Additionally, pass a resolver in property position to resolve a value for group membership for each item.
+ * Additionally, pass a resolver in property position to resolve a value for group membership for each element.
  *
  * ```javascript [playground]
  * import groupBy from 'https://unpkg.com/rubico/dist/x/groupBy.es.js'

package/x/last.d.ts

@@ -10,7 +10,7 @@ export = last;
  * ```
  *
  * @description
- * Get the last item of a collection
+ * Get the last element of a collection
  *
  * ```javascript [playground]
  * import last from 'https://unpkg.com/rubico/dist/x/last.es.js'

package/x/last.js

@@ -9,7 +9,7 @@
  * ```
  *
  * @description
- * Get the last item of a collection
+ * Get the last element of a collection
  *
  * ```javascript [playground]
  * import last from 'https://unpkg.com/rubico/dist/x/last.es.js'

package/x/last.test.js

@@ -2,7 +2,7 @@ const assert = require('assert')
 const last = require('./last')
 
 describe('last', () => {
-  it('gets the last item of an array', async () => {
+  it('gets the last element of an array', async () => {
     assert.strictEqual(last([1, 2, 3]), 3)
     assert.strictEqual(last([]), undefined)
   })

package/x/maxBy.d.ts

@@ -4,22 +4,22 @@ export = maxBy;
  *
  * @synopsis
  * ```coffeescript [specscript]
- * maxBy(array Array, path string) -> maxItemByPath any
+ * maxBy(array Array, path string) -> maxElementByPath any
  *
- * maxBy(path string)(array Array) -> maxItemByPath any
+ * maxBy(path string)(array Array) -> maxElementByPath any
  * ```
  *
  * @description
- * Finds the item that is the max by a property denoted by path.
+ * Finds the element that is the max by a property denoted by path.
  *
  * ```javascript [playground]
  * import maxBy from 'https://unpkg.com/rubico/dist/x/maxBy.es.js'
  *
  * const array = [{ a: 1 }, { a: 2 }, { a: 3 }]
  *
- * const maxItem = maxBy(array, 'a')
+ * const maxElement = maxBy(array, 'a')
  *
- * console.log(maxItem) // { a: 3 }
+ * console.log(maxElement) // { a: 3 }
  * ```
  *
  * `maxBy` composes in a lazy way.
@@ -29,13 +29,13 @@ export = maxBy;
  *
  * const numbers = [1, 2, 3]
  *
- * const maxItem = pipe(numbers, [
+ * const maxElement = pipe(numbers, [
  *   map(number => number ** 2),
  *   map(number => ({ a: { b: { c: number } } })),
  *   maxBy('a.b.c')
  * ])
  *
- * console.log(maxItem) // { a: { b: { c: 9 } } }
+ * console.log(maxElement) // { a: { b: { c: 9 } } }
  * ```
  */
 declare function maxBy(...args: any[]): any;

package/x/maxBy.js

@@ -7,21 +7,21 @@ const curry2 = require('../_internal/curry2')
  *
  * @synopsis
  * ```coffeescript [specscript]
- * _maxBy(array Array, path string) -> maxItemByPath any
+ * _maxBy(array Array, path string) -> maxElementByPath any
  * ```
  */
 const _maxBy = function (array, path) {
   const length = array.length
   const getter = get(path)
   let index = 0
-  let maxItem = array[index]
+  let maxElement = array[index]
   while (++index < length) {
-    const item = array[index]
-    if (getter(item) > getter(maxItem)) {
-      maxItem = item
+    const element = array[index]
+    if (getter(element) > getter(maxElement)) {
+      maxElement = element
     }
   }
-  return maxItem
+  return maxElement
 }
 
 /**
@@ -29,22 +29,22 @@ const _maxBy = function (array, path) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * maxBy(array Array, path string) -> maxItemByPath any
+ * maxBy(array Array, path string) -> maxElementByPath any
  *
- * maxBy(path string)(array Array) -> maxItemByPath any
+ * maxBy(path string)(array Array) -> maxElementByPath any
  * ```
  *
  * @description
- * Finds the item that is the max by a property denoted by path.
+ * Finds the element that is the max by a property denoted by path.
  *
  * ```javascript [playground]
  * import maxBy from 'https://unpkg.com/rubico/dist/x/maxBy.es.js'
  *
  * const array = [{ a: 1 }, { a: 2 }, { a: 3 }]
  *
- * const maxItem = maxBy(array, 'a')
+ * const maxElement = maxBy(array, 'a')
  *
- * console.log(maxItem) // { a: 3 }
+ * console.log(maxElement) // { a: 3 }
  * ```
  *
  * `maxBy` composes in a lazy way.
@@ -54,13 +54,13 @@ const _maxBy = function (array, path) {
  *
  * const numbers = [1, 2, 3]
  *
- * const maxItem = pipe(numbers, [
+ * const maxElement = pipe(numbers, [
  *   map(number => number ** 2),
  *   map(number => ({ a: { b: { c: number } } })),
  *   maxBy('a.b.c')
  * ])
  *
- * console.log(maxItem) // { a: { b: { c: 9 } } }
+ * console.log(maxElement) // { a: { b: { c: 9 } } }
  * ```
  */
 const maxBy = function (...args) {

package/x/maxBy.test.js

@@ -4,20 +4,20 @@ const pipe = require('../pipe')
 const map = require('../map')
 
 describe('maxBy', () => {
-  it('Finds the item that is the max by a property denoted by path', async () => {
+  it('Finds the element that is the max by a property denoted by path', async () => {
     const array = [{ a: 1 }, { a: 2 }, { a: 3 }]
-    const maxItem = maxBy(array, 'a')
-    assert.deepEqual(maxItem, { a: 3 })
+    const maxElement = maxBy(array, 'a')
+    assert.deepEqual(maxElement, { a: 3 })
   })
 
   it('composes in a lazy way', async () => {
     const numbers = [1, 2, 3]
-    const maxItem = pipe(numbers, [
+    const maxElement = pipe(numbers, [
       map(number => number ** 2),
       map(number => ({ a: { b: { c: number } } })),
       maxBy('a.b.c'),
     ])
-    assert.deepEqual(maxItem, { a: { b: { c: 9 } } })
+    assert.deepEqual(maxElement, { a: { b: { c: 9 } } })
   })
 
   it('returns undefined for empty array', async () => {

package/x/pluck.test.js

@@ -4,7 +4,7 @@ const pluck = require('./pluck')
 const createAbc = v => ({ a: { b: { c: v } } })
 
 describe('pluck', () => {
-  it('creates a new collection by getting a path from every item of an old collection', async () => {
+  it('creates a new collection by getting a path from every element of an old collection', async () => {
     const nested = [1, 2, 3].map(createAbc)
     assert.deepEqual(
       pluck('a.b.c')(nested),

package/x/prepend.d.ts

@@ -5,7 +5,7 @@ export = prepend;
  * @synopsis
  * ```coffeescript [specscript]
  * prepend(
- *   item string|Array,
+ *   element string|Array,
  * )(value string|Array) -> string|array
  * ```
  *
@@ -35,4 +35,4 @@ export = prepend;
  *
  * @since 1.7.3
  */
-declare function prepend(item: any): (value: any) => string | any[];
+declare function prepend(element: any): (value: any) => string | any[];

package/x/prepend.js

@@ -7,7 +7,7 @@ const isArray = require('../_internal/isArray')
  * @synopsis
  * ```coffeescript [specscript]
  * prepend(
- *   item string|Array,
+ *   element string|Array,
  * )(value string|Array) -> string|array
  * ```
  *
@@ -38,20 +38,20 @@ const isArray = require('../_internal/isArray')
  * @since 1.7.3
  */
 
-const prepend = item => function prependFunc(value) {
+const prepend = element => function prependFunc(value) {
 
     if (isArray(value)) {
-      if (isArray(item)){
-        return [...item, ...value]
+      if (isArray(element)){
+        return [...element, ...value]
       }
-      return [item, ...value]
+      return [element, ...value]
     }
 
     if (isString(value)){
-      if (!isString(item)){
-        throw new TypeError(`${item} is not a string`)
+      if (!isString(element)){
+        throw new TypeError(`${element} is not a string`)
       }
-      return `${item}${value}`
+      return `${element}${value}`
     }
 
     throw new TypeError(`${value} is not an Array or string`)

package/x/size.d.ts

@@ -8,7 +8,7 @@ export = size;
  * ```
  *
  * @description
- * Get the count of items in a value.
+ * Get the count of elements in a value.
  *
  * ```javascript [playground]
  * import size from 'https://unpkg.com/rubico/dist/x/size.es.js'

package/x/size.js

@@ -9,7 +9,7 @@ const objectKeysLength = require('../_internal/objectKeysLength')
  * ```
  *
  * @description
- * Get the count of items in a value.
+ * Get the count of elements in a value.
  *
  * ```javascript [playground]
  * import size from 'https://unpkg.com/rubico/dist/x/size.es.js'

package/x/unionWith.js

@@ -56,12 +56,12 @@ const arrayIncludesWith = function (array, value, comparator) {
 const arrayUniqWithAsync = async function (array, comparator, result, index) {
   const length = array.length
   while (++index < length) {
-    const item = array[index],
-      itemAlreadyExists = arrayIncludesWith(result, item, comparator)
+    const element = array[index],
+      elementAlreadyExists = arrayIncludesWith(result, element, comparator)
     if (!(
-      isPromise(itemAlreadyExists) ? await itemAlreadyExists : itemAlreadyExists
+      isPromise(elementAlreadyExists) ? await elementAlreadyExists : elementAlreadyExists
     )) {
-      result.push(item)
+      result.push(element)
     }
   }
   return result
@@ -86,14 +86,14 @@ const arrayUniqWith = function (array, comparator) {
     result = []
   let index = -1
   while (++index < length) {
-    const item = array[index],
-      itemAlreadyExists = arrayIncludesWith(result, item, comparator)
-    if (isPromise(itemAlreadyExists)) {
-      return itemAlreadyExists.then(funcConcatSync(
-        curry3(thunkConditional, __, noop, thunkify2(arrayPush, result, item)),
+    const element = array[index],
+      elementAlreadyExists = arrayIncludesWith(result, element, comparator)
+    if (isPromise(elementAlreadyExists)) {
+      return elementAlreadyExists.then(funcConcatSync(
+        curry3(thunkConditional, __, noop, thunkify2(arrayPush, result, element)),
         thunkify4(arrayUniqWithAsync, array, comparator, result, index)))
-    } else if (!itemAlreadyExists) {
-      result.push(item)
+    } else if (!elementAlreadyExists) {
+      result.push(element)
     }
   }
   return result

package/x/unionWith.test.js

@@ -101,7 +101,7 @@ describe('unionWith', () => {
       const result = await p
       assert.deepEqual(result, new Set([1, 2, 3]))
     })
-    it('predicate item => item.name; values Set<[{...}, {...}, {...}]>; result Promise|<Set<[{...}, {...}]>>', async () => {
+    it('predicate element => element.name; values Set<[{...}, {...}, {...}]>; result Promise|<Set<[{...}, {...}]>>', async () => {
       const people = new Set([{ name: 'John' }, { name: 'John' }, { name: 'Jim' }])
       const result = unionWith((personA, personB) => personA.name === personB.name)(people)
       assert.deepEqual(result, new Set([{ name: 'John' }, { name: 'Jim' }]))
@@ -190,7 +190,7 @@ describe('unionWith', () => {
       {
         const subject = unionWith(() => Promise.resolve(false))(gen)
         const arr = []
-        for await (const item of subject) arr.push(item)
+        for await (const element of subject) arr.push(element)
         assert.deepEqual(arr, [1, 2, 3, 1, 2, 3, 5, 5, 5])
       }
       {
@@ -206,12 +206,12 @@ describe('unionWith', () => {
       const gen = async function*() { yield numbersAsyncGeneratorFunc; yield numbersGeneratorFunc; yield* [5, 5, 5] }
       const subject = unionWith(() => false)(gen)
       const arr = []
-      for await (const item of subject) arr.push(item)
+      for await (const element of subject) arr.push(element)
       assert.deepEqual(arr, [1, 2, 3, 1, 2, 3, 5, 5, 5])
       {
         const subject = unionWith(async () => true)(gen)
         const arr = []
-        for await (const item of subject) arr.push(item)
+        for await (const element of subject) arr.push(element)
         assert.deepEqual(arr, [1])
       }
     })
@@ -219,7 +219,7 @@ describe('unionWith', () => {
       const gen = async function*() {}
       const subject = unionWith(() => false)(gen)
       const arr = []
-      for await (const item of subject) arr.push(item)
+      for await (const element of subject) arr.push(element)
       assert.deepEqual(arr, [])
     })
   })

package/global.d.ts

@@ -1 +0,0 @@
-export {};