rambda 8.4.0 → 8.6.0

package/CHANGELOG.md

@@ -1,3 +1,25 @@
+8.6.0
+
+- Wrong typing for `R.dissocPath` - [Issue #709](https://github.com/selfrefactor/rambda/issues/709)
+
+- Add `R.sortWith` - [Issue #7097](https://github.com/selfrefactor/rambda/issues/707)
+
+- Update build dependencies
+
+8.5.0
+
+- Revert changes in `R.anyPass` introduced in `8.4.0` release. The reason is that the change was breaking the library older than `5.2.0` TypeScript.
+
+- Wrong `R.partial` TS definition  - [Issue #705](https://github.com/selfrefactor/rambda/issues/705)
+
+- Add `R.dropRepeatsBy`
+
+- Add `R.empty`
+
+- Add `R.eqBy`
+
+- Add `R.forEachObjIndexed`
+
 8.4.0
 
 - Add `R.dissocPath`

package/README.md

@@ -59,7 +59,7 @@ Also, `Rambda` provides you with included TS definitions:
 // Deno extension(https://marketplace.visualstudio.com/items?itemName=denoland.vscode-deno)
 // is installed and initialized
 import * as R from "https://deno.land/x/rambda/mod.ts";
-import * as Ramda from "https://x.nest.land/ramda@0.27.2/mod.ts";
+import * as Ramda from "https://deno.land/x/ramda/mod.ts";
 
 R.add(1)('foo') // => will trigger warning in VSCode as it should
 Ramda.add(1)('foo') // => will not trigger warning in VSCode
@@ -101,10 +101,6 @@ One of the main issues with `Ramda` is the slow process of releasing new version
   Click to see the full list of 0 Ramda methods not implemented in Rambda and their status.
 </summary>
 
-- dropRepeatsBy
-- empty
-- eqBy
-- forEachObjIndexed
 - gt
 - gte
 - hasIn
@@ -226,7 +222,7 @@ There are methods which are benchmarked only with `Ramda` and `Rambda`(i.e. no `
 
 Note that some of these methods, are called with and without curring. This is done in order to give more detailed performance feedback.
 
-The benchmarks results are produced from latest versions of *Rambda*, *Lodash*(4.17.21) and *Ramda*(0.29.0).
+The benchmarks results are produced from latest versions of *Rambda*, *Lodash*(4.17.21) and *Ramda*(0.29.1).
 
 </summary>
 
@@ -789,7 +785,7 @@ describe('R.any', () => {
 
 ```typescript
 
-anyPass<T, U extends T[]>(predicates: { [K in keyof U]: (x: T) => x is U[K]
+anyPass<T>(predicates: ((x: T) => boolean)[]): (input: T) => boolean
 ```
 
 It accepts list of `predicates` and returns a function. This function with its `input` will return `true`, if any of `predicates` returns `true` for this `input`.
@@ -801,7 +797,6 @@ It accepts list of `predicates` and returns a function. This function with its `
 <summary>All TypeScript definitions</summary>
 
 ```typescript
-anyPass<T, U extends T[]>(predicates: { [K in keyof U]: (x: T) => x is U[K]; }): (input: T) => input is U[number];
 anyPass<T>(predicates: ((x: T) => boolean)[]): (input: T) => boolean;
 anyPass<T>(predicates: ((...inputs: T[]) => boolean)[]): (...inputs: T[]) => boolean;
 ```
@@ -930,18 +925,18 @@ describe('anyPass', () => {
     filtered2 // $ExpectType number[]
   })
   it('functions as a type guard', () => {
-    const isString = (x: unknown): x is string => typeof x === 'string';
-    const isNumber = (x: unknown): x is number => typeof x === 'number';
-    const isBoolean = (x: unknown): x is boolean => typeof x === 'boolean';
-    
-    const isStringNumberOrBoolean = anyPass([isString, isNumber, isBoolean]);
+    const isString = (x: unknown): x is string => typeof x === 'string'
+    const isNumber = (x: unknown): x is number => typeof x === 'number'
+    const isBoolean = (x: unknown): x is boolean => typeof x === 'boolean'
+
+    const isStringNumberOrBoolean = anyPass([isString, isNumber, isBoolean])
 
-    isStringNumberOrBoolean // $ExpectType (input: unknown) => input is string | number | boolean
+    isStringNumberOrBoolean // $ExpectType (input: unknown) => boolean
 
-    const aValue: unknown = 1;
+    const aValue: unknown = 1
 
     if (isStringNumberOrBoolean(aValue)) {
-      aValue // $ExpectType string | number | boolean
+      aValue // $ExpectType unknown
     }
   })
 })
@@ -3438,6 +3433,10 @@ describe('R.dropRepeats', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#dropRepeats)
 
+### dropRepeatsBy
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#dropRepeatsBy)
+
 ### dropRepeatsWith
 
 <a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20list%20%3D%20%5B%7Ba%3A1%2Cb%3A2%7D%2C%20%7Ba%3A1%2Cb%3A3%7D%2C%20%7Ba%3A2%2C%20b%3A4%7D%5D%0Aconst%20result%20%3D%20R.dropRepeatsWith(R.prop('a')%2C%20list)%0A%0A%2F%2F%20%3D%3E%20%5B%7Ba%3A1%2Cb%3A2%7D%2C%20%7Ba%3A2%2C%20b%3A4%7D%5D">Try this <strong>R.dropRepeatsWith</strong> example in Rambda REPL</a>
@@ -3603,6 +3602,10 @@ describe('R.either', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#either)
 
+### empty
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#empty)
+
 ### endsWith
 
 ```typescript
@@ -3764,6 +3767,10 @@ describe('R.endsWith - string', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#endsWith)
 
+### eqBy
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#eqBy)
+
 ### eqProps
 
 It returns `true` if property `prop` in `obj1` is equal to property `prop` in `obj2` according to `R.equals`.
@@ -5422,36 +5429,46 @@ forEach<T, U>(fn: ObjectIterator<T, void>): (list: Dictionary<T>) => Dictionary<
 import { isArray } from './_internals/isArray.js'
 import { keys } from './_internals/keys.js'
 
-export function forEach(fn, list){
-  if (arguments.length === 1) return _list => forEach(fn, _list)
+export function forEachObjIndexedFn(fn, obj){
+  let index = 0
+  const listKeys = keys(obj)
+  const len = listKeys.length
 
-  if (list === undefined){
-    return
+  while (index < len){
+    const key = listKeys[ index ]
+    fn(
+      obj[ key ], key, obj
+    )
+    index++
   }
 
-  if (isArray(list)){
-    let index = 0
-    const len = list.length
+  return obj
+}
 
-    while (index < len){
-      fn(list[ index ])
-      index++
-    }
-  } else {
+export function forEachObjIndexed(fn, list){
+  if (arguments.length === 1) return _list => forEachObjIndexed(fn, _list)
+
+  if (list === undefined) return
+
+  return forEachObjIndexedFn(fn, list)
+}
+
+export function forEach(fn, iterable){
+  if (arguments.length === 1) return _list => forEach(fn, _list)
+
+  if (iterable === undefined) return
+
+  if (isArray(iterable)){
     let index = 0
-    const listKeys = keys(list)
-    const len = listKeys.length
+    const len = iterable.length
 
     while (index < len){
-      const key = listKeys[ index ]
-      fn(
-        list[ key ], key, list
-      )
+      fn(iterable[ index ])
       index++
     }
-  }
+  } else return forEachObjIndexedFn(fn, iterable)
 
-  return list
+  return iterable
 }
 ```
 
@@ -5582,6 +5599,10 @@ describe('R.forEach with objects', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#forEach)
 
+### forEachObjIndexed
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#forEachObjIndexed)
+
 ### fromPairs
 
 It transforms a `listOfPairs` to an object.
@@ -8780,7 +8801,7 @@ mergeWith<Output>(fn: (x: any, z: any) => any): <U, V>(a: U, b: V) => Output;
 ```javascript
 import { curry } from './curry.js'
 
-function mergeWithFn(
+export function mergeWithFn(
   mergeFn, aInput, bInput
 ){
   const a = aInput ?? {}
@@ -8788,21 +8809,15 @@ function mergeWithFn(
   const willReturn = {}
 
   Object.keys(a).forEach(key => {
-    if (b[ key ] === undefined){
-      willReturn[ key ] = a[ key ]
-    } else {
-      willReturn[ key ] = mergeFn(a[ key ], b[ key ])
-    }
+    if (b[ key ] === undefined) willReturn[ key ] = a[ key ]
+    else willReturn[ key ] = mergeFn(a[ key ], b[ key ])
   })
 
   Object.keys(b).forEach(key => {
     if (willReturn[ key ] !== undefined) return
 
-    if (a[ key ] === undefined){
-      willReturn[ key ] = b[ key ]
-    } else {
-      willReturn[ key ] = mergeFn(a[ key ], b[ key ])
-    }
+    if (a[ key ] === undefined) willReturn[ key ] = b[ key ]
+    else willReturn[ key ] = mergeFn(a[ key ], b[ key ])
   })
 
   return willReturn
@@ -8819,10 +8834,10 @@ export const mergeWith = curry(mergeWithFn)
 
 ```javascript
 import { concat } from './concat.js'
-import { mergeWith } from './mergeWith.js'
+import { mergeWithFn } from './mergeWith.js'
 
 test('happy', () => {
-  const result = mergeWith(
+  const result = mergeWithFn(
     concat,
     {
       a      : true,
@@ -8835,8 +8850,8 @@ test('happy', () => {
   )
   const expected = {
     a      : true,
-    values : [ 10, 20, 15, 35 ],
     b      : true,
+    values : [ 10, 20, 15, 35 ],
   }
   expect(result).toEqual(expected)
 })
@@ -8844,31 +8859,31 @@ test('happy', () => {
 // https://github.com/ramda/ramda/pull/3222/files#diff-d925d9188b478d2f1d4b26012c6dddac374f9e9d7a336604d654b9a113bfc857
 describe('acts as if nil values are simply empty objects', () => {
   it('if the first object is nil and the second empty', () => {
-    expect(mergeWith(
+    expect(mergeWithFn(
       concat, undefined, {}
     )).toEqual({})
   })
 
   it('if the first object is empty and the second nil', () => {
-    expect(mergeWith(
+    expect(mergeWithFn(
       concat, {}, null
     )).toEqual({})
   })
 
   it('if both objects are nil', () => {
-    expect(mergeWith(
+    expect(mergeWithFn(
       concat, undefined, null
     )).toEqual({})
   })
 
   it('if the first object is not empty and the second is nil', () => {
-    expect(mergeWith(
+    expect(mergeWithFn(
       concat, { a : 'a' }, null
     )).toEqual({ a : 'a' })
   })
 
   it('if the first object is nil and the second is not empty', () => {
-    expect(mergeWith(
+    expect(mergeWithFn(
       concat, undefined, { a : 'a' }
     )).toEqual({ a : 'a' })
   })
@@ -10073,18 +10088,7 @@ test('index lens', () => {
 
 ```typescript
 
-partial<
-  Args extends unknown[],
-  ArgsGiven extends [...Partial<Args>],
-  R
->(
-  fn: (...args: Args) => R,
-  ...args: ArgsGiven
-): Args extends [...{[K in keyof ArgsGiven]: Args[K]}, ...infer ArgsRemaining]
-  ? ArgsRemaining extends []
-    ? R
-    : (...args: ArgsRemaining) => R
-  : never
+partial<V0, V1, T>(fn: (x0: V0, x1: V1) => T, args: [V0]): (x1: V1) => T
 ```
 
 It is very similar to `R.curry`, but you can pass initial arguments when you create the curried function.
@@ -10099,31 +10103,22 @@ The name comes from the fact that you partially inject the inputs.
 <summary>All TypeScript definitions</summary>
 
 ```typescript
-partial<
-  Args extends unknown[],
-  ArgsGiven extends [...Partial<Args>],
-  R
->(
-  fn: (...args: Args) => R,
-  ...args: ArgsGiven
-): Args extends [...{[K in keyof ArgsGiven]: Args[K]}, ...infer ArgsRemaining]
-  ? ArgsRemaining extends []
-    ? R
-    : (...args: ArgsRemaining) => R
-  : never;
-
-partial<
-  Args extends readonly unknown[],
-  ArgsGiven extends [...Partial<Args>],
-  R
->(
-  fn: (...args: Args) => R,
-  args: ArgsGiven
-): Args extends [...{[K in keyof ArgsGiven]: Args[K]}, ...infer ArgsRemaining]
-  ? ArgsRemaining extends []
-    ? R
-    : (...args: ArgsRemaining) => R
-  : never;
+partial<V0, V1, T>(fn: (x0: V0, x1: V1) => T, args: [V0]): (x1: V1) => T;
+partial<V0, V1, V2, T>(fn: (x0: V0, x1: V1, x2: V2) => T, args: [V0, V1]): (x2: V2) => T;
+partial<V0, V1, V2, T>(fn: (x0: V0, x1: V1, x2: V2) => T, args: [V0]): (x1: V1, x2: V2) => T;
+partial<V0, V1, V2, V3, T>(
+  fn: (x0: V0, x1: V1, x2: V2, x3: V3) => T,
+  args: [V0, V1, V2],
+): (x2: V3) => T;
+partial<V0, V1, V2, V3, T>(
+  fn: (x0: V0, x1: V1, x2: V2, x3: V3) => T,
+  args: [V0, V1],
+): (x2: V2, x3: V3) => T;
+partial<V0, V1, V2, V3, T>(
+  fn: (x0: V0, x1: V1, x2: V2, x3: V3) => T,
+  args: [V0],
+): (x1: V1, x2: V2, x3: V3) => T;
+partial<T>(fn: (...a: any[]) => T, args: any[]): (...a: any[]) => T;
 ```
 
 </details>
@@ -10240,44 +10235,20 @@ describe('R.partial', () => {
       aBoolean: boolean,
       aNull: null
     ) {
-      return { aString, aNumber, aBoolean, aNull }
+      return {aString, aNumber, aBoolean, aNull}
     }
 
     // @ts-expect-error
-    partial(fn, 1);
-
-    const fn1 = partial(fn, 'a')
-
-    // @ts-expect-error
-    partial(fn1, 'b');
-
-    const fn2 = partial(fn1, 2)
-    const result = fn2(true, null)
-    result // $ExpectType { aString: string; aNumber: number; aBoolean: boolean; aNull: null; }
-  })
-
-  it('ramda', () => {
-    function fn(
-      aString: string,
-      aNumber: number,
-      aBoolean: boolean,
-      aNull: null
-    ) {
-      return { aString, aNumber, aBoolean, aNull }
-    }
-
-    // @ts-expect-error
-    partial(fn, 1);
+    partial(fn, 1)
 
     const fn1 = partial(fn, ['a'])
-
-    // @ts-expect-error
-    partial(fn1, ['b']);
+    partial(fn1, ['b'])
 
     const fn2 = partial(fn1, [2])
     const result = fn2(true, null)
     result // $ExpectType { aString: string; aNumber: number; aBoolean: boolean; aNull: null; }
-  })})
+  })
+})
 ```
 
 </details>
@@ -17452,6 +17423,28 @@ describe('R.zipWith', () => {
 
 ## ❯ CHANGELOG
 
+8.6.0
+
+- Wrong typing for `R.dissocPath` - [Issue #709](https://github.com/selfrefactor/rambda/issues/709)
+
+- Add `R.sortWith` - [Issue #7097](https://github.com/selfrefactor/rambda/issues/707)
+
+- Update build dependencies
+
+8.5.0
+
+- Revert changes in `R.anyPass` introduced in `8.4.0` release. The reason is that the change was breaking the library older than `5.2.0` TypeScript.
+
+- Wrong `R.partial` TS definition  - [Issue #705](https://github.com/selfrefactor/rambda/issues/705)
+
+- Add `R.dropRepeatsBy`
+
+- Add `R.empty`
+
+- Add `R.eqBy`
+
+- Add `R.forEachObjIndexed`
+
 8.4.0
 
 - Add `R.dissocPath`
@@ -17784,25 +17777,25 @@ Fix wrong versions in changelog
 
 > Most influential contributors(in alphabetical order)
 
-- [@farwayer](https://github.com/farwayer) - improving performance in R.find, R.filter; give the idea how to make benchmarks more reliable;
+- ![farwayer avatar](https://avatars.githubusercontent.com/farwayer) [@farwayer](https://github.com/farwayer) - improving performance in R.find, R.filter; give the idea how to make benchmarks more reliable;
 
-- [@thejohnfreeman](https://github.com/thejohnfreeman) - add R.assoc, R.chain;
+- ![thejohnfreeman avatar](https://avatars.githubusercontent.com/thejohnfreeman) [@thejohnfreeman](https://github.com/thejohnfreeman) - add R.assoc, R.chain;
 
-- [@peeja](https://github.com/peeja) - add several methods and fix mutiple issues; provides great MR documentation
+- ![peeja avatar](https://avatars.githubusercontent.com/peeja) [@peeja](https://github.com/peeja) - add several methods and fix mutiple issues; provides great MR documentation
 
-- [@helmuthdu](https://github.com/helmuthdu) - add R.clone; help improve code style;
+- ![helmuthdu avatar](https://avatars.githubusercontent.com/helmuthdu) [@helmuthdu](https://github.com/helmuthdu) - add R.clone; help improve code style;
 
-- [@jpgorman](https://github.com/jpgorman) - add R.zip, R.reject, R.without, R.addIndex;
+- ![jpgorman avatar](https://avatars.githubusercontent.com/jpgorman) [@jpgorman](https://github.com/jpgorman) - add R.zip, R.reject, R.without, R.addIndex;
 
-- [@ku8ar](https://github.com/ku8ar) - add R.slice, R.propOr, R.identical, R.propIs and several math related methods; introduce the idea to display missing Ramda methods;
+- ![ku8ar avatar](https://avatars.githubusercontent.com/ku8ar) [@ku8ar](https://github.com/ku8ar) - add R.slice, R.propOr, R.identical, R.propIs and several math related methods; introduce the idea to display missing Ramda methods;
 
-- [@romgrk](https://github.com/romgrk) - add R.groupBy, R.indexBy, R.findLast, R.findLastIndex;
+- ![romgrk avatar](https://avatars.githubusercontent.com/romgrk) [@romgrk](https://github.com/romgrk) - add R.groupBy, R.indexBy, R.findLast, R.findLastIndex;
 
-- [@squidfunk](https://github.com/squidfunk) - add R.assocPath, R.symmetricDifference, R.difference, R.intersperse;
+- ![squidfunk avatar](https://avatars.githubusercontent.com/squidfunk) [@squidfunk](https://github.com/squidfunk) - add R.assocPath, R.symmetricDifference, R.difference, R.intersperse;
 
-- [@synthet1c](https://github.com/synthet1c) - add all lenses methods; add R.applySpec, R.converge;
+- ![synthet1c avatar](https://avatars.githubusercontent.com/synthet1c) [@synthet1c](https://github.com/synthet1c) - add all lenses methods; add R.applySpec, R.converge;
 
-- [@vlad-zhukov](https://github.com/vlad-zhukov) - help with configuring Rollup, Babel; change export file to use ES module exports;
+- ![vlad-zhukov avatar](https://avatars.githubusercontent.com/vlad-zhukov) [@vlad-zhukov](https://github.com/vlad-zhukov) - help with configuring Rollup, Babel; change export file to use ES module exports;
 
 > Rambda references
 
@@ -17814,20 +17807,16 @@ Fix wrong versions in changelog
 
 > Links to Rambda
 
-- [https://mailchi.mp/webtoolsweekly/web-tools-280](Web Tools Weekly)
-
 - [https://github.com/stoeffel/awesome-fp-js](awesome-fp-js)
 
+- [ https://mailchi.mp/webtoolsweekly/web-tools-280 ]( Web Tools Weekly #280 )
+
 - [https://github.com/docsifyjs/awesome-docsify](awesome-docsify)
 
 > Deprecated from `Used by` section
 
 - [SAP's Cloud SDK](https://github.com/SAP/cloud-sdk) - This repo doesn't uses `Rambda` since *October/2020* [commit that removes Rambda](https://github.com/SAP/cloud-sdk/commit/b29b4f915c4e4e9c2441e7b6b67cf83dac1fdac3)
 
-> Releases
-
-[Rambda's releases](https://github.com/selfrefactor/rambda/releases) before **6.4.0** were used mostly for testing purposes.
-
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#-additional-info)
 
 ## My other libraries