rambda 8.5.0 → 9.0.0

package/index.d.ts

@@ -43,10 +43,7 @@ interface KeyValuePair<K, V> extends Array<K | V> {
   1: V;
 }
 
-export interface Lens {
-  <T, U>(obj: T): U;
-  set<T, U>(str: string, obj: T): U;
-}
+export type Lens<S, A> = (functorFactory: (a: A) => Functor<A>) => (s: S) => Functor<S>;
 
 type Arity1Fn = (x: any) => any;
 type Arity2Fn = (x: any, y: any) => any;
@@ -147,12 +144,12 @@ interface SchemaAsync {
   [key: string]: Promise<boolean>;
 }
 
-interface IsValid {
+export interface IsValid {
   input: object;
   schema: Schema;
 }
 
-interface IsValidAsync {
+export interface IsValidAsync {
   input: object;
   schema: Schema | SchemaAsync;
 }
@@ -174,8 +171,6 @@ type ApplyDiffAdd = {op:'add', path: string, value: any};
 type ApplyDiffRemove = {op:'remove', path: string};
 type ApplyDiffRule = ApplyDiffUpdate | ApplyDiffAdd | ApplyDiffRemove;
 
-type Resolved<T> = {status: 'fulfilled', value: T} | {status: 'rejected', reason: string|Error}
-
 
 export function F(): boolean;
 
@@ -190,6 +185,9 @@ export function add(a: number): (b: number) => number;
 export function addIndex(originalFn: any): (fn: any) => (list: any[]) => any[];
 export function addIndex(originalFn: any): (fn: any, list: any[]) => any[];
 
+/**
+ * Same as `R.addIndex`, but it will passed indexes are decreasing, instead of increasing.
+ */
 export function addIndexRight(originalFn: any): (fn: any) => (list: any[]) => any[];
 export function addIndexRight(originalFn: any): (fn: any, list: any[]) => any[];
 
@@ -234,10 +232,16 @@ export function any<T>(predicate: (x: T) => boolean): (list: T[]) => boolean;
 export function anyPass<T>(predicates: ((x: T) => boolean)[]): (input: T) => boolean;
 export function anyPass<T>(predicates: ((...inputs: T[]) => boolean)[]): (...inputs: T[]) => boolean;
 
+/**
+ * It takes a list of functions and a list of values. Then it returns a list of values obtained by applying each function to each value.
+ */
 export function ap<T, U>(fns: Array<(a: T) => U>[], vs: T[]): U[];
 export function ap<T, U>(fns: Array<(a: T) => U>): (vs: T[]) => U[];
 export function ap<R, A, B>(fn: (r: R, a: A) => B, fn1: (r: R) => A): (r: R) => B;
 
+/**
+ * It returns a new list, composed of consecutive `n`-tuples from a `list`.
+ */
 export function aperture<N extends number, T>(n: N, list: T[]): Array<Tuple<T, N>> | [];
 export function aperture<N extends number>(n: N): <T>(list: T[]) => Array<Tuple<T, N>> | [];
 
@@ -329,6 +333,9 @@ export function clone<T>(input: T[]): T[];
 export function collectBy<T, K extends PropertyKey>(keyFn: (value: T) => K, list: T[]): T[][];
 export function collectBy<T, K extends PropertyKey>(keyFn: (value: T) => K): (list: T[]) => T[][];
 
+/**
+ * It returns a comparator function that can be used in `sort` method.
+ */
 export function comparator<T>(pred: (a: T, b: T) => boolean): (x: T, y: T) => Ordering;
 
 /**
@@ -353,7 +360,7 @@ export function compose<TArgs extends any[], R1, R2, R3, R4, R5, R6, R7, TResult
       f2: (a: R1) => R2,
       f1: (...args: TArgs) => R1
   ]
-): (...args: TArgs) => TResult; // fallback overload if number of composed functions greater than 7
+): (...args: TArgs) => TResult;
 export function compose<TArgs extends any[], R1, R2, R3, R4, R5, R6, R7, TResult>(
   f7: (a: R6) => R7,
   f6: (a: R5) => R6,
@@ -505,7 +512,8 @@ export function differenceWith<T1, T2>(
 export function dissoc<T extends object, K extends keyof T>(prop: K, obj: T): Omit<T, K>;
 export function dissoc<K extends string | number>(prop: K): <T extends object>(obj: T) => Omit<T, K>;
 
-export function dissocPath<T>(x: T): T;
+export function dissocPath<T>(path: Path, obj: any): T;
+export function dissocPath<T>(path: Path): (obj: any) => T;
 
 export function divide(x: number, y: number): number;
 export function divide(x: number): (y: number) => number;
@@ -685,12 +693,19 @@ export function groupWith<T>(compareFn: (x: T, y: T) => boolean): (input: T[]) =
 export function groupWith<T>(compareFn: (x: T, y: T) => boolean, input: T[]): (T[])[];
 export function groupWith<T>(compareFn: (x: T, y: T) => boolean, input: string): string[];
 
+export function gt<T>(x: T): T;
+
+export function gte<T>(x: T): T;
+
 /**
  * It returns `true` if `obj` has property `prop`.
  */
 export function has<T>(prop: string, obj: T): boolean;
 export function has(prop: string): <T>(obj: T) => boolean;
 
+export function hasIn(searchProperty: string): <T>(obj: T) => boolean;
+export function hasIn<T>(searchProperty: string, obj: T): boolean;
+
 /**
  * It will return true, if `input` object has truthy `path`(calculated with `R.path`).
  */
@@ -779,6 +794,18 @@ export function indexOf<T>(valueToFind: T): (list: T[]) => number;
 export function init<T extends unknown[]>(input: T): T extends readonly [...infer U, any] ? U : [...T];
 export function init(input: string): string;
 
+/**
+ * It returns a new list by applying a `predicate` function to all elements of `list1` and `list2` and keeping only these elements where `predicate` returns `true`.
+ */
+export function innerJoin<T1, T2>(
+  pred: (a: T1, b: T2) => boolean,
+): (list1: T1[], list2: T2[]) => T1[];
+export function innerJoin<T1, T2>(
+  pred: (a: T1, b: T2) => boolean,
+  list1: T1[],
+): (list2: T2[]) => T1[];
+export function innerJoin<T1, T2>(pred: (a: T1, b: T2) => boolean, list1: T1[], list2: T2[]): T1[];
+
 /**
  * It loops through `listA` and `listB` and returns the intersection of the two according to `R.equals`.
  */
@@ -862,26 +889,57 @@ export function length<T>(input: T[]): number;
  * 
  * The setter should not mutate the data structure.
  */
-export function lens<T, U, V>(getter: (s: T) => U, setter: (a: U, s: T) => V): Lens;
+export function lens<S, A>(getter: (s: S) => A, setter: (a: A, s: S) => S): Lens<S, A>;
 
 /**
  * It returns a lens that focuses on specified `index`.
  */
-export function lensIndex(index: number): Lens;
+export function lensIndex<A>(n: number): Lens<A[], A>;
+export function lensIndex<A extends any[], N extends number>(n: N): Lens<A, A[N]>;
 
 /**
  * It returns a lens that focuses on specified `path`.
  */
-export function lensPath(path: RamdaPath): Lens;
-export function lensPath(path: string): Lens;
+export function lensPath<S, K0 extends keyof S = keyof S>(path: [K0]): Lens<S, S[K0]>;
+export function lensPath<S, K0 extends keyof S = keyof S, K1 extends keyof S[K0] = keyof S[K0]>(
+  path: [K0, K1],
+): Lens<S, S[K0][K1]>;
+export function lensPath<
+  S,
+  K0 extends keyof S = keyof S,
+  K1 extends keyof S[K0] = keyof S[K0],
+  K2 extends keyof S[K0][K1] = keyof S[K0][K1]
+>(path: [K0, K1, K2]): Lens<S, S[K0][K1][K2]>;
+export function lensPath<
+  S,
+  K0 extends keyof S = keyof S,
+  K1 extends keyof S[K0] = keyof S[K0],
+  K2 extends keyof S[K0][K1] = keyof S[K0][K1],
+  K3 extends keyof S[K0][K1][K2] = keyof S[K0][K1][K2]
+>(path: [K0, K1, K2, K3]): Lens<S, S[K0][K1][K2][K3]>;
+export function lensPath<
+  S,
+  K0 extends keyof S = keyof S,
+  K1 extends keyof S[K0] = keyof S[K0],
+  K2 extends keyof S[K0][K1] = keyof S[K0][K1],
+  K3 extends keyof S[K0][K1][K2] = keyof S[K0][K1][K2],
+  K4 extends keyof S[K0][K1][K2][K3] = keyof S[K0][K1][K2][K3]
+>(path: [K0, K1, K2, K3, K4]): Lens<S, S[K0][K1][K2][K3][K4]>;
+export function lensPath<
+  S,
+  K0 extends keyof S = keyof S,
+  K1 extends keyof S[K0] = keyof S[K0],
+  K2 extends keyof S[K0][K1] = keyof S[K0][K1],
+  K3 extends keyof S[K0][K1][K2] = keyof S[K0][K1][K2],
+  K4 extends keyof S[K0][K1][K2][K3] = keyof S[K0][K1][K2][K3],
+  K5 extends keyof S[K0][K1][K2][K3][K4] = keyof S[K0][K1][K2][K3][K4]
+>(path: [K0, K1, K2, K3, K4, K5]): Lens<S, S[K0][K1][K2][K3][K4][K5]>;
+export function lensPath<S = any, A = any>(path: Path): Lens<S, A>;
 
 /**
  * It returns a lens that focuses on specified property `prop`.
  */
-export function lensProp(prop: string): {
-  <T, U>(obj: T): U;
-  set<T, U, V>(val: T, obj: U): V;
-};
+export function lensProp<S, K extends keyof S = keyof S>(prop: K): Lens<S, S[K]>;
 
 /**
  * It returns the result of looping through `iterable` with `fn`.
@@ -1392,6 +1450,25 @@ export function reduce<T, TResult>(reducer: (prev: TResult, current: T) => TResu
 export function reduce<T, TResult>(reducer: (prev: TResult, current: T, i: number) => TResult): (initialValue: TResult, list: T[]) => TResult;
 export function reduce<T, TResult>(reducer: (prev: TResult, current: T, i: number) => TResult, initialValue: TResult): (list: T[]) => TResult;
 
+export function reduceBy<T, TResult>(
+  valueFn: (acc: TResult, elem: T) => TResult,
+): (a: TResult, b: (elem: T) => string, c: T[]) => { [index: string]: TResult }
+export function reduceBy<T, TResult>(
+  valueFn: (acc: TResult, elem: T) => TResult,
+  acc: TResult,
+): (a: (elem: T) => string, b: T[]) => { [index: string]: TResult }
+export function reduceBy<T, TResult>(
+  valueFn: (acc: TResult, elem: T) => TResult,
+  acc: TResult,
+  keyFn: (elem: T) => string,
+): (list: T[]) => { [index: string]: TResult };
+export function reduceBy<T, TResult>(
+  valueFn: (acc: TResult, elem: T) => TResult,
+  acc: TResult,
+  keyFn: (elem: T) => string,
+  list: T[],
+): { [index: string]: TResult };
+
 /**
  * It has the opposite effect of `R.filter`.
  */
@@ -1453,6 +1530,9 @@ export function sortBy<T>(sortFn: (a: T) => Ord, list: T[]): T[];
 export function sortBy<T>(sortFn: (a: T) => Ord): (list: T[]) => T[];
 export function sortBy(sortFn: (a: any) => Ord): <T>(list: T[]) => T[];
 
+export function sortWith<T>(fns: Array<(a: T, b: T) => number>): (list: T[]) => T[];
+export function sortWith<T>(fns: Array<(a: T, b: T) => number>, list: T[]): T[];
+
 /**
  * Curried version of `String.prototype.split`
  */
@@ -1683,9 +1763,13 @@ export function values<T extends object, K extends keyof T>(obj: T): T[K][];
 /**
  * It returns the value of `lens` focus over `target` object.
  */
-export function view<T, U>(lens: Lens): (target: T) => U;
-export function view<T, U>(lens: Lens, target: T): U;
+export function view<S, A>(lens: Lens<S, A>): (obj: S) => A;
+export function view<S, A>(lens: Lens<S, A>, obj: S): A;
 
+/**
+ * It pass `input` to `predicate` function and if the result is `true`, it will return the result of `whenTrueFn(input)`.
+ * If the `predicate` returns `false`, then it will simply return `input`.
+ */
 export function when<T, U>(predicate: (x: T) => boolean, whenTrueFn: (a: T) => U, input: T): T | U;
 export function when<T, U>(predicate: (x: T) => boolean, whenTrueFn: (a: T) => U): (input: T) => T | U;
 export function when<T, U>(predicate: (x: T) => boolean): ((whenTrueFn: (a: T) => U) => (input: T) => T | U);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rambda",
-  "version": "8.5.0",
+  "version": "9.0.0",
   "scripts": {
     "benchmark": "cd ../rambda-scripts && RAMBDA_RUN_ALL=ON RAMBDA_RUN_INDEXES=ON yarn benchmark",
     "benchmark:all": "yarn build:step && cd ../rambda-scripts && yarn benchmark:all",
@@ -38,30 +38,30 @@
   },
   "dependencies": {},
   "devDependencies": {
-    "@babel/core": "7.21.8",
+    "@babel/core": "7.23.3",
     "@babel/plugin-proposal-object-rest-spread": "7.20.7",
-    "@babel/preset-env": "7.21.5",
+    "@babel/preset-env": "7.23.3",
     "@definitelytyped/dtslint": "0.0.176",
-    "@rollup/plugin-babel": "6.0.3",
-    "@rollup/plugin-commonjs": "25.0.0",
-    "@rollup/plugin-node-resolve": "15.0.2",
-    "@rollup/plugin-replace": "5.0.2",
-    "@types/jest": "29.5.1",
+    "@rollup/plugin-babel": "6.0.4",
+    "@rollup/plugin-commonjs": "25.0.7",
+    "@rollup/plugin-node-resolve": "15.2.3",
+    "@rollup/plugin-replace": "5.0.5",
+    "@types/jest": "29.5.8",
     "combinate": "1.1.11",
     "cross-env": "7.0.3",
-    "fast-check": "^3.11.0",
+    "fast-check": "3.13.2",
     "helpers-fn": "1.8.1",
     "is-ci": "3.0.1",
-    "jest": "29.5.0",
-    "jest-extended": "3.2.4",
+    "jest": "29.7.0",
+    "jest-extended": "4.0.2",
     "lodash": "4.17.21",
-    "rambdax": "9.1.1",
-    "ramda": "0.29.0",
-    "rollup": "3.22.0",
+    "rambdax": "10.0.0",
+    "ramda": "0.29.1",
+    "rollup": "4.4.1",
     "rollup-plugin-cleanup": "3.2.1",
     "rollup-plugin-sourcemaps": "0.6.3",
     "rollup-plugin-uglify": "6.0.4",
-    "types-ramda": "0.29.2",
+    "types-ramda": "0.29.6",
     "typescript": "5.2.2"
   },
   "jest": {

package/rambda.js

@@ -69,10 +69,14 @@ export * from './src/findLastIndex.js'
 export * from './src/flatten.js'
 export * from './src/flip.js'
 export * from './src/forEach.js'
+export * from './src/forEachObjIndexed.js'
 export * from './src/fromPairs.js'
 export * from './src/groupBy.js'
 export * from './src/groupWith.js'
+export * from './src/gt.js'
+export * from './src/gte.js'
 export * from './src/has.js'
+export * from './src/hasIn.js'
 export * from './src/hasPath.js'
 export * from './src/head.js'
 export * from './src/identical.js'
@@ -83,6 +87,7 @@ export * from './src/includes.js'
 export * from './src/indexBy.js'
 export * from './src/indexOf.js'
 export * from './src/init.js'
+export * from './src/innerJoin.js'
 export * from './src/intersection.js'
 export * from './src/intersperse.js'
 export * from './src/is.js'
@@ -150,6 +155,7 @@ export * from './src/propSatisfies.js'
 export * from './src/props.js'
 export * from './src/range.js'
 export * from './src/reduce.js'
+export * from './src/reduceBy.js'
 export * from './src/reject.js'
 export * from './src/removeIndex.js'
 export * from './src/repeat.js'
@@ -159,6 +165,7 @@ export * from './src/set.js'
 export * from './src/slice.js'
 export * from './src/sort.js'
 export * from './src/sortBy.js'
+export * from './src/sortWith.js'
 export * from './src/split.js'
 export * from './src/splitAt.js'
 export * from './src/splitEvery.js'

package/src/forEach.js

@@ -1,33 +1,8 @@
 import { isArray } from './_internals/isArray.js'
-import { keys } from './_internals/keys.js'
-
-export function forEachObjIndexedFn(fn, obj){
-  let index = 0
-  const listKeys = keys(obj)
-  const len = listKeys.length
-
-  while (index < len){
-    const key = listKeys[ index ]
-    fn(
-      obj[ key ], key, obj
-    )
-    index++
-  }
-
-  return obj
-}
-
-export function forEachObjIndexed(fn, list){
-  if (arguments.length === 1) return _list => forEachObjIndexed(fn, _list)
-
-  if (list === undefined) return
-
-  return forEachObjIndexedFn(fn, list)
-}
+import { forEachObjIndexedFn } from './forEachObjIndexed.js'
 
 export function forEach(fn, iterable){
   if (arguments.length === 1) return _list => forEach(fn, _list)
-
   if (iterable === undefined) return
 
   if (isArray(iterable)){

package/src/forEachObjIndexed.js

@@ -0,0 +1,25 @@
+import { keys } from './_internals/keys.js'
+
+export function forEachObjIndexedFn(fn, obj){
+  let index = 0
+  const listKeys = keys(obj)
+  const len = listKeys.length
+
+  while (index < len){
+    const key = listKeys[ index ]
+    fn(
+      obj[ key ], key, obj
+    )
+    index++
+  }
+
+  return obj
+}
+
+export function forEachObjIndexed(fn, list){
+  if (arguments.length === 1) return _list => forEachObjIndexed(fn, _list)
+
+  if (list === undefined) return
+
+  return forEachObjIndexedFn(fn, list)
+}

package/src/gt.js

@@ -0,0 +1,6 @@
+export function gt(a, b){
+  if (arguments.length === 1)
+    return _b => gt(a, _b)
+
+  return a > b
+}

package/src/gte.js

@@ -0,0 +1,6 @@
+export function gte(a, b){
+  if (arguments.length === 1)
+    return _b => gte(a, _b)
+
+  return a >= b
+}

package/src/hasIn.js

@@ -0,0 +1,9 @@
+import { propFn } from "./prop";
+
+export function hasIn(searchProperty, obj) {
+  if (arguments.length === 1){
+    return (_obj) => hasIn(searchProperty, _obj);
+  }
+
+  return propFn(searchProperty, obj) !== undefined
+}

package/src/innerJoin.js

@@ -0,0 +1,41 @@
+import { curry } from './curry.js'
+
+function _includesWith(
+  pred, x, list
+){
+  let idx = 0
+  const len = list.length
+
+  while (idx < len){
+    if (pred(x, list[ idx ]))
+      return true
+
+    idx += 1
+  }
+
+  return false
+}
+function _filter(fn, list){
+  let idx = 0
+  const len = list.length
+  const result = []
+
+  while (idx < len){
+    if (fn(list[ idx ]))
+      result[ result.length ] = list[ idx ]
+
+    idx += 1
+  }
+
+  return result
+}
+
+export function innerJoinFn(
+  pred, xs, ys
+){
+  return _filter(x => _includesWith(
+    pred, x, ys
+  ), xs)
+}
+
+export const innerJoin = curry(innerJoinFn)

package/src/prop.js

@@ -1,7 +1,11 @@
-export function prop(propToFind, obj){
-  if (arguments.length === 1) return _obj => prop(propToFind, _obj)
-
+export function propFn(searchProperty, obj){
   if (!obj) return undefined
 
-  return obj[ propToFind ]
+  return obj[ searchProperty ]
+}
+
+export function prop(searchProperty, obj){
+  if (arguments.length === 1) return _obj => prop(searchProperty, _obj)
+
+  return propFn(searchProperty, obj)
 }

package/src/reduceBy.js

@@ -0,0 +1,29 @@
+import { clone } from './clone.js'
+import { curry } from './curry.js'
+import { has } from './has.js'
+import { reduce } from './reduce.js'
+
+function reduceByFunction(
+  valueFn, valueAcc, keyFn, acc, elt
+){
+  const key = keyFn(elt)
+  const value = valueFn(has(key, acc) ? acc[ key ] : clone(valueAcc), elt)
+
+  acc[ key ] = value
+
+  return acc
+}
+
+export function reduceByFn(
+  valueFn, valueAcc, keyFn, list
+){
+  return reduce(
+    (acc, elt) => reduceByFunction(
+      valueFn, valueAcc, keyFn, acc, elt
+    ),
+    {},
+    list
+  )
+}
+
+export const reduceBy = curry(reduceByFn)

package/src/sortWith.js

@@ -0,0 +1,27 @@
+function sortHelper(
+  a, b, listOfSortingFns
+){
+  let result = 0
+  let i = 0
+  while (result === 0 && i < listOfSortingFns.length){
+    result = listOfSortingFns[ i ](a, b)
+    i += 1
+  }
+
+  return result
+}
+
+export function sortWith(listOfSortingFns, list){
+  if (arguments.length === 1)
+    return _list => sortWith(listOfSortingFns, _list)
+
+  if (Array.isArray(list) === false)
+    return []
+
+  const clone = list.slice()
+  clone.sort((a, b) => sortHelper(
+    a, b, listOfSortingFns
+  ))
+
+  return clone
+}

package/src/values.js

@@ -2,6 +2,5 @@ import { type } from './type.js'
 
 export function values(obj){
   if (type(obj) !== 'Object') return []
-
   return Object.values(obj)
-}
+}