rubico 2.6.5 → 2.7.0

package/tryCatch.js

@@ -75,6 +75,11 @@ const _tryCatch = function (tryer, catcher, args) {
  *   console.error(`${a} + ${b} + ${c}: ${error.message}`)
  * })
  * ```
+ *
+ * See also:
+ *  * [pipe](/docs/pipe)
+ *  * [switchCase](/docs/switchCase)
+ *  * [all](/docs/all)
  */
 
 const tryCatch = function (...args) {

package/x/append.js

@@ -35,6 +35,9 @@ const isArray = require('../_internal/isArray')
  * }
  * ```
  *
+ * See also:
+ *  * [callProp](/docs/callProp)
+ *
  * @since 1.7.3
  */
 

package/x/callProp.js

@@ -15,6 +15,11 @@
  * const priceRoundedDown = callProp('toFixed', 2)(5.992)
  * console.log('priceRoundedDown:', priceRoundedDown) // '5.99'
  * ```
+ *
+ * See also:
+ *  * [append](/docs/append)
+ *  * [defaultsDeep](/docs/defaultsDeep)
+ *
  */
 const callProp = (property, ...args) => function callingProp(object) {
   return object[property](...args)

package/x/defaultsDeep.d.ts

@@ -26,11 +26,11 @@ export = defaultsDeep;
  * })
  *
  * console.log(defaultUser({
- *   name: 'George',
+ *   name: 'John',
  *   images: [{ url: 'https://via.placeholder.com/150/0000FF/808080%20?Text=Digital.com' }],
  * }))
  * // {
- * //   name: 'George',
+ * //   name: 'John',
  * //   images: [
  * //    { url: 'https://via.placeholder.com/150/0000FF/808080%20?Text=Digital.com' },
  * //    { url: 'https://via.placeholder.com/150' },

package/x/defaultsDeep.js

@@ -91,11 +91,11 @@ const objectDefaultsDeepFromObject = function (object, defaultObject) {
  * })
  *
  * console.log(defaultUser({
- *   name: 'George',
+ *   name: 'John',
  *   images: [{ url: 'https://via.placeholder.com/150/0000FF/808080%20?Text=Digital.com' }],
  * }))
  * // {
- * //   name: 'George',
+ * //   name: 'John',
  * //   images: [
  * //    { url: 'https://via.placeholder.com/150/0000FF/808080%20?Text=Digital.com' },
  * //    { url: 'https://via.placeholder.com/150' },
@@ -103,6 +103,11 @@ const objectDefaultsDeepFromObject = function (object, defaultObject) {
  * //   ],
  * // }
  * ```
+ *
+ * See also:
+ *  * [callProp](/docs/callProp)
+ *  * [differenceWith](/docs/differenceWith)
+ *
  */
 const defaultsDeep = defaultCollection => function defaulting(value) {
   if (isArray(value) && isArray(defaultCollection)) {

package/x/differenceWith.js

@@ -96,6 +96,11 @@ const differenceWithArray = function (comparator, allValues, array) {
  *   differenceWith(isDeepEqual, [{ a: 1 }, { b: 2 }, { c: 3 }])([{ b: 2 }]),
  * ) // [{ a: 1 }, { c: 3 }]
  * ```
+ *
+ * See also:
+ *  * [defaultsDeep](/docs/defaultsDeep)
+ *  * [filterOut](/docs/filterOut)
+ *
  */
 const differenceWith = (
   comparator, allValues,

package/x/find.d.ts

@@ -23,12 +23,12 @@ export = find;
  * const users = [
  *   { name: 'John', age: 16 },
  *   { name: 'Jill', age: 32 },
- *   { name: 'George', age: 51 },
+ *   { name: 'John', age: 51 },
  * ]
  *
  * console.log(
  *   find(user => user.age > 50)(users),
- * ) // { name: 'George', age: 51 }
+ * ) // { name: 'John', age: 51 }
  * ```
  */
 declare function find(predicate: any): (value: any) => any;

package/x/find.js

@@ -30,12 +30,12 @@ const asyncIteratorFind = require('../_internal/asyncIteratorFind')
  * const users = [
  *   { name: 'John', age: 16 },
  *   { name: 'Jill', age: 32 },
- *   { name: 'George', age: 51 },
+ *   { name: 'John', age: 51 },
  * ]
  *
  * console.log(
  *   find(user => user.age > 50)(users),
- * ) // { name: 'George', age: 51 }
+ * ) // { name: 'John', age: 51 }
  * ```
  */
 const find = predicate => function finding(value) {

package/x/groupBy.d.ts

@@ -24,13 +24,13 @@ export = groupBy;
  *
  * console.log(
  *   groupBy('age')([
- *     { name: 'George', age: 22 },
+ *     { name: 'John', age: 22 },
  *     { name: 'Jane', age: 22 },
  *     { name: 'Henry', age: 23 },
  *   ]),
  * )
  * // Map {
- * //   22 => [{ name: 'George', age: 22 }, { name: 'Jane', age: 22 }],
+ * //   22 => [{ name: 'John', age: 22 }, { name: 'Jane', age: 22 }],
  * //   23 => [{ name: 'Henry', age: 23 }],
  * // }
  * ```

package/x/groupBy.js

@@ -59,13 +59,13 @@ const groupByResolver = resolver => function groupByResolverReducer(
  *
  * console.log(
  *   groupBy('age')([
- *     { name: 'George', age: 22 },
+ *     { name: 'John', age: 22 },
  *     { name: 'Jane', age: 22 },
  *     { name: 'Henry', age: 23 },
  *   ]),
  * )
  * // Map {
- * //   22 => [{ name: 'George', age: 22 }, { name: 'Jane', age: 22 }],
+ * //   22 => [{ name: 'John', age: 22 }, { name: 'Jane', age: 22 }],
  * //   23 => [{ name: 'Henry', age: 23 }],
  * // }
  * ```

package/x/pluck.d.ts

@@ -22,14 +22,14 @@ export = pluck;
  * import pluck from 'https://unpkg.com/rubico/dist/x/pluck.es.js'
  *
  * const users = [
- *   { name: 'George', age: 33 },
+ *   { name: 'John', age: 33 },
  *   { name: 'Jane', age: 51 },
  *   { name: 'Jim', age: 22 },
  * ]
  *
  * const usernames = pluck(users, 'name')
  *
- * console.log(usernames) // ['George', 'Jane', 'Jim']
+ * console.log(usernames) // ['John', 'Jane', 'Jim']
  * ```
  */
 declare function pluck(...args: any[]): any;

package/x/pluck.js

@@ -25,14 +25,14 @@ const get = require('../get')
  * import pluck from 'https://unpkg.com/rubico/dist/x/pluck.es.js'
  *
  * const users = [
- *   { name: 'George', age: 33 },
+ *   { name: 'John', age: 33 },
  *   { name: 'Jane', age: 51 },
  *   { name: 'Jim', age: 22 },
  * ]
  *
  * const usernames = pluck(users, 'name')
  *
- * console.log(usernames) // ['George', 'Jane', 'Jim']
+ * console.log(usernames) // ['John', 'Jane', 'Jim']
  * ```
  */
 const pluck = function (...args) {

package/x/unionWith.test.js

@@ -102,14 +102,14 @@ describe('unionWith', () => {
       assert.deepEqual(result, new Set([1, 2, 3]))
     })
     it('predicate item => item.name; values Set<[{...}, {...}, {...}]>; result Promise|<Set<[{...}, {...}]>>', async () => {
-      const people = new Set([{ name: 'George' }, { name: 'George' }, { name: 'Jim' }])
+      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: 'George' }, { name: 'Jim' }]))
+      assert.deepEqual(result, new Set([{ name: 'John' }, { name: 'Jim' }]))
       {
         const p = unionWith(async (personA, personB) => personA.name === personB.name)(people)
         assert(p instanceof Promise)
         const result = await p
-        assert.deepEqual(result, new Set([{ name: 'George' }, { name: 'Jim' }]))
+        assert.deepEqual(result, new Set([{ name: 'John' }, { name: 'Jim' }]))
       }
     })
     it('predicate () => false; values Set<[[1], 2, [3]]>; result Set<[1, 2, 3]>', async () => {