Include original input when mapping errors

scripts/build-npm.ts

@@ -1,6 +1,6 @@
 // ex. scripts/build_npm.ts
 import { build, emptyDir } from 'https://deno.land/x/dnt@0.40.0/mod.ts'
-import pkg from '../deno.json' assert { type: 'json' }
+import pkg from '../deno.json' with { type: 'json' }
 
 await emptyDir('./npm')
 

src/combinators.ts

@@ -338,27 +338,30 @@ function catchFailure<
 }
 
 /**
- * Creates a new function that will apply a transformation over the list of Errors of a Failure from a given function. When the given function succeeds, its result is returned without changes.
+ * Creates a new function that will apply a transformation over the list of Errors of a Failure from a given function. When the given function succeeds, its result is returned without changes. The mapper receives the original input.
  *
  * @example
  *
  * ```ts
  * import { mapErrors } from 'composable-functions'
  *
  * const increment = ({ id }: { id: number }) => id + 1
- * const incrementWithErrorSummary = mapErrors(increment, (result) => ({
- *   errors: [{ message: 'Errors count: ' + result.errors.length }],
+ * const incrementWithErrorSummary = mapErrors(increment, (result, {id}) => ({
+ *   errors: [{ message: 'Errors count: ' + result.errors.length + ' for id: ' + String(id) }],
  * }))
  * ```
  */
 function mapErrors<Fn extends Function>(
   fn: Fn,
-  mapper: (err: Error[]) => Error[] | Promise<Error[]>,
+  mapper: (
+    err: Error[],
+    ...originalInput: Parameters<Extract<Fn, Internal.AnyFn>>
+  ) => Error[] | Promise<Error[]>,
 ): Fn extends Internal.AnyFn ? Composable<Fn> : never {
   const callable = (async (...args) => {
     const res = await composable(fn)(...args)
     if (res.success) return success(res.data)
-    const mapped = await composable(mapper)(res.errors)
+    const mapped = await composable(mapper)(res.errors, ...(args as never))
     if (mapped.success) {
       return failure(mapped.data)
     } else {

src/tests/map-errors.test.ts

@@ -59,6 +59,21 @@ describe('mapErrors', () => {
     assertEquals(res.errors[0].message, 'a is 1!!!')
   })
 
+  it('maps using the original input', async () => {
+    const fn = mapErrors(faultyAdd, (_, a, b) => {
+      throw new Error('result would be ' + (a + b))
+    })
+    const res = await fn(1, 2)
+
+    type _FN = Expect<
+      Equal<typeof fn, Composable<(a: number, b: number) => number>>
+    >
+    type _R = Expect<Equal<typeof res, Result<number>>>
+
+    assertEquals(res.success, false)
+    assertEquals(res.errors[0].message, 'result would be 3')
+  })
+
   it('accepts an async mapper', async () => {
     const fn = mapErrors(
       faultyAdd,