10.3.4 Improve R.mapParallelAsync typings to allow optional batchSize parameter

CHANGELOG.md

@@ -1,3 +1,15 @@
+10.3.4
+
+- Fix wrong typing for `R.sortByDescending` - [Issue #797](https://github.com/selfrefactor/rambda/issues/797)
+
+- Improve `R.mapParallelAsync` typings to allow optional `batchSize` parameter.
+
+- Change order of inputs in `R.mapPropObject`
+
+- Change REPL links in documentation
+
+- Remove `jsr.json`
+
 10.3.3
 
 - Fix wrong typing for `R.reject` - [Issue #779](https://github.com/selfrefactor/rambda/issues/779)

deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@rambda/rambda",
-  "version": "10.3.3",
+  "version": "10.3.4",
   "exports": "./mod.ts",
   "imports": {
     "rambda": "./mod.ts"

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) {

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) {

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) {

files/DEV_NOTES.md

@@ -7,6 +7,31 @@ export function splitEvery(sliceLength: number): {
   <T>(input: T[]): (T[])[];
 };
 ---
+Suggested new methods for Rambda library:
+
+
+15. `sortByMultiple` - Sort by multiple criteria:
+```typescript
+export function sortByMultiple<T>(
+  criteria: Array<(a: T, b: T) => number>
+): (list: T[]) => T[];
+```
+
+These suggestions are based on:
+1. Common use cases in TypeScript projects
+2. Working well within `R.pipe` chains
+3. Having clear, single-purpose functionality
+4. Being type-safe
+5. Following the library's focus on object manipulation and array operations
+6. Complementing existing methods
+
+The suggestions avoid methods that:
+1. Have confusing or ambiguous behavior
+2. Don't work well in pipe chains
+3. Have multiple ways to be used
+4. Are better suited as part of application code
+5. Have complex TypeScript definitions that would be hard to maintain 
+---
 check wrong import
 
 from './[a-zA-Z]+'

files/README_START.md

@@ -21,7 +21,7 @@ const result = pipe(
 //=> [6, 8]
 ```
 
-You can test this example in <a href="https://rambda.now.sh/?const%20result%20%3D%20R.pipe(%0A%20%20%5B1%2C%202%2C%203%2C%204%5D%2C%0A%20%20R.filter(x%20%3D%3E%20x%20%3E%202)%2C%0A%20%20R.map(x%20%3D%3E%20x%20*%202)%2C%0A)%0A%2F%2F%20%3D%3E%20%5B6%2C%208%5D">Rambda's REPL</a>
+You can test this example in <a href="https://rambda.netlify.app/?const%20result%20%3D%20R.pipe(%0A%20%20%5B1%2C%202%2C%203%2C%204%5D%2C%0A%20%20R.filter(x%20%3D%3E%20x%20%3E%202)%2C%0A%20%20R.map(x%20%3D%3E%20x%20*%202)%2C%0A)%0A%2F%2F%20%3D%3E%20%5B6%2C%208%5D">Rambda's REPL</a>
 
 * [API](#api)
 * [Changelog](#-changelog)

files/index.d.ts

@@ -1050,21 +1050,20 @@ export function transformPropObject<T extends object, K extends keyof T, Value>(
 /*
 Method: mapPropObject
 
-Explanation: It maps over a property of object that is a list.
+Explanation: Convenience method, when one needs to maps over a object property that is a list.
 
 Example:
 
 ```
 
 const result = pipe(
 	{ a: [1,2,3], b: 'foo' },
-	mapPropObject(x => {
-		x // $ExpectType { a: number; b: string; }
+	mapPropObject('a',x => {
 		return {
 			a: x,
 			flag: x > 2,
 		}
-	}, 'a'),
+	}),
 )
 // => { a: [{ a: 1, flag: false },{ a: 2, flag: false }, { a: 3, flag: true }], b: 'foo' }
 ```
@@ -1075,12 +1074,20 @@ Notes:
 
 */
 // @SINGLE_MARKER
-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;
@@ -2536,7 +2543,7 @@ Notes:
 
 */
 // @SINGLE_MARKER
-export function sortByDescending<T>(sortFn: (a: T, b: T) => number): (list: T[]) => T[];
+export function sortByDescending<T>(sortFn: (x: T) => Ord): (list: T[]) => T[];
 
 /*
 Method: sortByPath
@@ -4429,6 +4436,7 @@ export function mapAsync<T extends IterableContainer, U>(
 Method: mapParallelAsync
 
 Explanation: 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.
 
 Example:
 
@@ -4441,11 +4449,9 @@ Notes:
 
 */
 // @SINGLE_MARKER
-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>>;
 
 /*

index.d.cts

@@ -547,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;
@@ -1827,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.

index.d.ts

@@ -547,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;
@@ -1827,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.json

@@ -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.7.0",
-    "@vitest/coverage-v8": "4.0.0-beta.17",
+    "@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",
+    "ramda": "0.32.0",
     "remeda": "2.32.0",
-    "rollup": "4.52.4",
+    "rollup": "4.53.3",
     "types-ramda": "0.31.0",
-    "typescript": "6.0.0-dev.20251006",
-    "vitest": "4.0.0-beta.17"
+    "typescript": "6.0.0-dev.20251119",
+    "vitest": "4.0.10"
   },
   "jest": {
     "testEnvironment": "node",

source/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
+	}	
 }