How to extend a function in TypeScript without repeating the signature types

Suppose you have a function, written in TypeScript, that is fine and complete. Now you want to write a function that works like that one but with just some slightly more parameters and other differences. It's not too different from a decorator function.

Extending the list of parameters

Let's imagine that you already have this function:

type Operation = "sum" | "sub" | "mul" | "div"

function calculator(a: number, b: number, op: Operation) {
  if (op === "sum") return a + b
  if (op === "sub") return a - b
  if (op === "mul") return a * b
  if (op === "div") return a / b
  throw new Error(op)
}

And this could, for the sake of argument, be in a different file and/or possibly outside your control. What you now want to do is write a new function that takes those same arguments, plus one more. And importantly, you don't want to have to spell out all the arguments one more time.

First, the WRONG way to solve this:

import { calculator } from './calculator' // The code in the snippet above

type Operation = "sum" | "sub" | "mul" | "div"

function doubleCalculator(a: number, b: number, op: Operation, c: number) {
  return calculator(calculator(a, b, op), c, op)
}

console.log(calculator(1, 2, "sum")) // 3
console.log(doubleCalculator(1, 2, "sum", 10)) // 13

Technically, it works, but you had to repeat the calculator function's signature.

The RIGHT way to solve this:

import { calculator } from './calculator' // The code in the snippet above

function doubleCalculator(c: number, ...args: Parameters<typeof calculator>) {
  return calculator(calculator(...args), c, args[2])
}

console.log(calculator(1, 2, "sum")) // 3
console.log(doubleCalculator(10, 1, 2, "sum")) // 13

The key in this is that the list of types could be cumbersomely large. In this example calculator there are just 3 parameters. But it could be 9 and most importantly, you might not care.

Not touching the parameters

Suppose you want to write a function that just calls another function but with some added logging. In this case, it's even easier :

import { calculator as _calculator } from "./base";

function calculator(...args: Parameters<typeof _calculator>) {
  console.warn(`About to ${args[2]} ${args[0]} and ${args[1]}`);
  return _calculator(...args);
}

console.log(calculator(1, 2, "sum")); 
// About to sum 1 and 2
// 3 

One parameter which is an object

Instead of a long list of parameters, let's imagine it's just 1 single parameter and it's an object.
Imagine we start with this:

type Operation = "sum" | "sub" | "mul" | "div";

type Props = {
  a: number;
  b: number;
  op: Operation;
};

export function calculator({ a, b, op }: Props) {
  if (op === "sum") return a + b;
  if (op === "sub") return a - b;
  if (op === "mul") return a * b;
  if (op === "div") return a / b;
  throw new Error(op);
}

Now, you want to "extend" that similarly to what we did before. Here's one way to solve that:

import { calculator } from "./calculator";

type Props = Parameters<typeof calculator>[0] & { c: number };

function doubleCalculator(props: Props) {
  const { c, ...rest } = props;
  return calculator({ a: calculator(rest), b: c, op: rest.op });
}

console.log(calculator({ a: 1, b: 2, op: "sum" })); // 3
console.log(doubleCalculator({ a: 1, b: 2, op: "sum", c: 10 })); // 13