rambda 10.3.2 → 10.3.4

package/dist/rambda.cjs

@@ -1044,8 +1044,18 @@ function mapObjectAsync(fn) {
   }
 }
 
-function mapParallelAsync(fn) {
-  return async list =>  Promise.all(list.map((x, i) => fn(x, i)))
+function mapParallelAsync(fn, batchSize){
+	if(!batchSize) return async list =>  Promise.all(list.map(fn))
+
+	return async list => {
+		const result = [];
+		for(let i = 0; i < list.length; i += batchSize){
+			const batch = list.slice(i, i + batchSize);
+			const batchResult = await Promise.all(batch.map((x, j) => fn(x, i + j)));
+			result.push(...batchResult);
+		}
+		return result
+	}	
 }
 
 function mapPropObject(fn, prop) {

package/dist/rambda.js

@@ -1042,8 +1042,18 @@ function mapObjectAsync(fn) {
   }
 }
 
-function mapParallelAsync(fn) {
-  return async list =>  Promise.all(list.map((x, i) => fn(x, i)))
+function mapParallelAsync(fn, batchSize){
+	if(!batchSize) return async list =>  Promise.all(list.map(fn))
+
+	return async list => {
+		const result = [];
+		for(let i = 0; i < list.length; i += batchSize){
+			const batch = list.slice(i, i + batchSize);
+			const batchResult = await Promise.all(batch.map((x, j) => fn(x, i + j)));
+			result.push(...batchResult);
+		}
+		return result
+	}	
 }
 
 function mapPropObject(fn, prop) {

package/dist/rambda.umd.js

@@ -1048,8 +1048,18 @@
     }
   }
 
-  function mapParallelAsync(fn) {
-    return async list =>  Promise.all(list.map((x, i) => fn(x, i)))
+  function mapParallelAsync(fn, batchSize){
+  	if(!batchSize) return async list =>  Promise.all(list.map(fn))
+
+  	return async list => {
+  		const result = [];
+  		for(let i = 0; i < list.length; i += batchSize){
+  			const batch = list.slice(i, i + batchSize);
+  			const batchResult = await Promise.all(batch.map((x, j) => fn(x, i + j)));
+  			result.push(...batchResult);
+  		}
+  		return result
+  	}	
   }
 
   function mapPropObject(fn, prop) {

package/index.d.cts

@@ -506,23 +506,13 @@ export function lastIndexOf<T>(target: T): (list: T[]) => number;
 
 /**
  * It returns the result of looping through `iterable` with `fn`.
- * 
- * It works with both array and object.
  */
 export function map<T extends IterableContainer, U>(
-  fn: (value: T[number], index: number) => U,
+	fn: (value: T[number], index: number) => U,
 ): (data: T) => Mapped<T, U>;
 export function map<T extends IterableContainer, U>(
-  fn: (value: T[number]) => U,
+	fn: (value: T[number]) => U,
 ): (data: T) => Mapped<T, U>;
-export function map<T extends IterableContainer, U>(
-  fn: (value: T[number], index: number) => U,
-	data: T
-) : Mapped<T, U>;
-export function map<T extends IterableContainer, U>(
-  fn: (value: T[number]) => U,
-	data: T
-) : Mapped<T, U>;
 
 /**
  * Sequential asynchronous mapping with `fn` over members of `list`.
@@ -557,23 +547,30 @@ export function mapObjectAsync<T extends object, Value>(
 
 /**
  * Wrapper around `Promise.all` for asynchronous mapping with `fn` over members of `list`.
+ * There is optional `batchSize` parameter to allow parallel execution to run in batches. In this case, the whole batch must complete before the next batch starts.
  */
-export function mapParallelAsync<T extends IterableContainer, U>(
-  fn: (value: T[number], index: number) => Promise<U>,
-): (data: T) => Promise<Mapped<T, U>>;
 export function mapParallelAsync<T extends IterableContainer, U>(
   fn: (value: T[number]) => Promise<U>,
+	batchSize?: number,
 ): (data: T) => Promise<Mapped<T, U>>;
 
 /**
- * It maps over a property of object that is a list.
+ * Convenience method, when one needs to maps over a object property that is a list.
  */
-export function mapPropObject<T extends object, K extends keyof T, Value>(
+export function mapPropObject<T extends object, K extends keyof T, Value extends unknown>(
+	prop: K,
+	valueMapper: (
+		listItem: T[K] extends ReadonlyArray<infer ElementType> ? ElementType : never,
+		list: T[K] extends ReadonlyArray<any> ? T[K] : never,
+	) => Value,
+): (data: T) => T[K] extends ReadonlyArray<any>
+	? MergeTypes<Omit<T, K> & { [P in K]: Value[] }>
+	: never;
+export function mapPropObject<T extends object, K extends keyof T, Value extends unknown>(
+	prop: K,
   valueMapper: (
-    value: T[K] extends ReadonlyArray<infer ElementType> ? ElementType : never,
-    data: T[K],
+    listItem: T[K] extends ReadonlyArray<infer ElementType> ? ElementType : never,
   ) => Value,
-    prop: K,
 ): (data: T) => T[K] extends ReadonlyArray<any>
   ? MergeTypes<Omit<T, K> & { [P in K]: Value[] }>
   : never;
@@ -1233,8 +1230,8 @@ export function permutations<T>(list: T[]): T[][];
  * 
  * String annotation of `propsToPick` is one of the differences between `Rambda` and `Ramda`.
  */
-export function pick<K extends PropertyKey>(propsToPick: K[]): <T>(input: T) => MergeTypes<Pick<T, Exclude<keyof T, Exclude<keyof T, K>>>>;
-export function pick<S extends string>(propsToPick: S): <T>(input: T) => MergeTypes<Pick<T, Exclude<keyof T, Exclude<keyof T, ElementOf<PickStringToPickPath<S>>>>>>;
+export function pick<K extends PropertyKey>(propsToPick: K[]): <T extends Partial<Record<K, any>>>(input: K extends keyof T ? T : never) => MergeTypes<Pick<T, K>>;
+export function pick<S extends string, Keys extends PickStringToPickPath<S>>(propsToPick: S): <T extends Partial<Record<ElementOf<Keys>, any>>>(input: ElementOf<Keys> extends keyof T ? T : never) => ElementOf<Keys> extends keyof T ? MergeTypes<Pick<T, ElementOf<Keys>>> : never;
 
 /**
  * It performs left-to-right function composition, where first argument is the input for the chain of functions.
@@ -1791,10 +1788,6 @@ export function reduce<T, TResult>(reducer: (prev: TResult, current: T, i: numbe
 /**
  * It has the opposite effect of `R.filter`.
  */
-export function reject<T>(
-	predicate: (value: T) => boolean,
-  list: T[],
-): T[];
 export function reject<T>(
 	predicate: BooleanConstructor,
 ): (list: readonly T[]) => ("" | null | undefined | false | 0)[];
@@ -1841,7 +1834,7 @@ export function sort<T>(sortFn: (a: T, b: T) => number): (list: T[]) => T[];
  */
 export function sortBy<T>(sortFn: (x: T) => Ord): (list: T[]) => T[];
 
-export function sortByDescending<T>(sortFn: (a: T, b: T) => number): (list: T[]) => T[];
+export function sortByDescending<T>(sortFn: (x: T) => Ord): (list: T[]) => T[];
 
 /**
  * It sorts `list` by the value of `path` property.

package/index.d.ts

@@ -506,23 +506,13 @@ export function lastIndexOf<T>(target: T): (list: T[]) => number;
 
 /**
  * It returns the result of looping through `iterable` with `fn`.
- * 
- * It works with both array and object.
  */
 export function map<T extends IterableContainer, U>(
-  fn: (value: T[number], index: number) => U,
+	fn: (value: T[number], index: number) => U,
 ): (data: T) => Mapped<T, U>;
 export function map<T extends IterableContainer, U>(
-  fn: (value: T[number]) => U,
+	fn: (value: T[number]) => U,
 ): (data: T) => Mapped<T, U>;
-export function map<T extends IterableContainer, U>(
-  fn: (value: T[number], index: number) => U,
-	data: T
-) : Mapped<T, U>;
-export function map<T extends IterableContainer, U>(
-  fn: (value: T[number]) => U,
-	data: T
-) : Mapped<T, U>;
 
 /**
  * Sequential asynchronous mapping with `fn` over members of `list`.
@@ -557,23 +547,30 @@ export function mapObjectAsync<T extends object, Value>(
 
 /**
  * Wrapper around `Promise.all` for asynchronous mapping with `fn` over members of `list`.
+ * There is optional `batchSize` parameter to allow parallel execution to run in batches. In this case, the whole batch must complete before the next batch starts.
  */
-export function mapParallelAsync<T extends IterableContainer, U>(
-  fn: (value: T[number], index: number) => Promise<U>,
-): (data: T) => Promise<Mapped<T, U>>;
 export function mapParallelAsync<T extends IterableContainer, U>(
   fn: (value: T[number]) => Promise<U>,
+	batchSize?: number,
 ): (data: T) => Promise<Mapped<T, U>>;
 
 /**
- * It maps over a property of object that is a list.
+ * Convenience method, when one needs to maps over a object property that is a list.
  */
-export function mapPropObject<T extends object, K extends keyof T, Value>(
+export function mapPropObject<T extends object, K extends keyof T, Value extends unknown>(
+	prop: K,
+	valueMapper: (
+		listItem: T[K] extends ReadonlyArray<infer ElementType> ? ElementType : never,
+		list: T[K] extends ReadonlyArray<any> ? T[K] : never,
+	) => Value,
+): (data: T) => T[K] extends ReadonlyArray<any>
+	? MergeTypes<Omit<T, K> & { [P in K]: Value[] }>
+	: never;
+export function mapPropObject<T extends object, K extends keyof T, Value extends unknown>(
+	prop: K,
   valueMapper: (
-    value: T[K] extends ReadonlyArray<infer ElementType> ? ElementType : never,
-    data: T[K],
+    listItem: T[K] extends ReadonlyArray<infer ElementType> ? ElementType : never,
   ) => Value,
-    prop: K,
 ): (data: T) => T[K] extends ReadonlyArray<any>
   ? MergeTypes<Omit<T, K> & { [P in K]: Value[] }>
   : never;
@@ -1233,8 +1230,8 @@ export function permutations<T>(list: T[]): T[][];
  * 
  * String annotation of `propsToPick` is one of the differences between `Rambda` and `Ramda`.
  */
-export function pick<K extends PropertyKey>(propsToPick: K[]): <T>(input: T) => MergeTypes<Pick<T, Exclude<keyof T, Exclude<keyof T, K>>>>;
-export function pick<S extends string>(propsToPick: S): <T>(input: T) => MergeTypes<Pick<T, Exclude<keyof T, Exclude<keyof T, ElementOf<PickStringToPickPath<S>>>>>>;
+export function pick<K extends PropertyKey>(propsToPick: K[]): <T extends Partial<Record<K, any>>>(input: K extends keyof T ? T : never) => MergeTypes<Pick<T, K>>;
+export function pick<S extends string, Keys extends PickStringToPickPath<S>>(propsToPick: S): <T extends Partial<Record<ElementOf<Keys>, any>>>(input: ElementOf<Keys> extends keyof T ? T : never) => ElementOf<Keys> extends keyof T ? MergeTypes<Pick<T, ElementOf<Keys>>> : never;
 
 /**
  * It performs left-to-right function composition, where first argument is the input for the chain of functions.
@@ -1791,10 +1788,6 @@ export function reduce<T, TResult>(reducer: (prev: TResult, current: T, i: numbe
 /**
  * It has the opposite effect of `R.filter`.
  */
-export function reject<T>(
-	predicate: (value: T) => boolean,
-  list: T[],
-): T[];
 export function reject<T>(
 	predicate: BooleanConstructor,
 ): (list: readonly T[]) => ("" | null | undefined | false | 0)[];
@@ -1841,7 +1834,7 @@ export function sort<T>(sortFn: (a: T, b: T) => number): (list: T[]) => T[];
  */
 export function sortBy<T>(sortFn: (x: T) => Ord): (list: T[]) => T[];
 
-export function sortByDescending<T>(sortFn: (a: T, b: T) => number): (list: T[]) => T[];
+export function sortByDescending<T>(sortFn: (x: T) => Ord): (list: T[]) => T[];
 
 /**
  * It sorts `list` by the value of `path` property.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rambda",
-  "version": "10.3.2",
+  "version": "10.3.4",
   "scripts": {
     "out": "yarn populatedocs && yarn populatereadme && yarn build && yarn create-docsify",
     "build": "yarn build:main && yarn build:web && yarn build:esm",
@@ -16,7 +16,8 @@
     "test": "vitest run --watch -u",
     "test:typings": "dtslint --localTs ./node_modules/typescript/lib --expectOnly ./source",
     "create-docsify": "cd ../rambda-scripts && yarn create-docsify",
-    "deps": "run dep:next",
+    "deps": "run dep:next 10",
+    "x": "run dep:stable 10",
     "ts": "yarn test:typings"
   },
   "niketaScripts": {
@@ -40,18 +41,18 @@
   "devDependencies": {
     "@definitelytyped/dtslint": "0.0.182",
     "@types/mocha": "10.0.10",
-    "@types/node": "24.0.8",
-    "@vitest/coverage-v8": "4.0.0-beta.2",
+    "@types/node": "24.10.1",
+    "@vitest/coverage-v8": "4.0.10",
     "helpers-fn": "2.0.0",
     "lodash": "4.17.21",
     "radashi": "13.0.0-beta.ffa4778",
     "rambdax": "11.3.1",
-    "ramda": "0.31.3",
-    "remeda": "2.23.2",
-    "rollup": "4.44.1",
-    "types-ramda": "0.30.1",
-    "typescript": "5.9.0-dev.20250630",
-    "vitest": "4.0.0-beta.2"
+    "ramda": "0.32.0",
+    "remeda": "2.32.0",
+    "rollup": "4.53.3",
+    "types-ramda": "0.31.0",
+    "typescript": "6.0.0-dev.20251119",
+    "vitest": "4.0.10"
   },
   "jest": {
     "testEnvironment": "node",

package/src/mapParallelAsync.js

@@ -1,3 +1,13 @@
-export function mapParallelAsync(fn) {
-  return async list =>  Promise.all(list.map((x, i) => fn(x, i)))
+export function mapParallelAsync(fn, batchSize){
+	if(!batchSize) return async list =>  Promise.all(list.map(fn))
+
+	return async list => {
+		const result = []
+		for(let i = 0; i < list.length; i += batchSize){
+			const batch = list.slice(i, i + batchSize)
+			const batchResult = await Promise.all(batch.map((x, j) => fn(x, i + j)))
+			result.push(...batchResult)
+		}
+		return result
+	}	
 }