Typescript 类型：根据其他参数检查正确的回调类型

Question

I have a JS function

const fn = (cb, param) => {
  cb(param);
};

Which is intended to be called 2 ways (in TS):

const cb0 = () => {};
fn(cb0);

const cb1 = (param: string) => { };
fn(cb1, 'str')

fn expectations are correctly described by this type:

interface IFn {
  (cb: (param: string) => void, param: string): void;
  (cb: () => void): void;
}

fnI(cb0); // ok
// fnI(cb1); // correctly does not compile, callback needs an argument
fnI(cb1, 's'); // ok

So it checks types at caller sites. However, I can't convert fn to Typescript so it would not require a type cast. Moreover, it seems TS refuses to infer argument types since IFn declares overloads. The best I can do is:

const fn: IFn = <IFn>((cb: (param?: string) => void, param?: string) => {
  cb(param);
});

The problem is the implementation signature is less restrictive and the following implementation clearly violates assertions of IFn but the violation can't be detected by type checker.

const fn: IFn = <IFn>((cb: (param?: string) => void, param?: string) => {
  cb(param === undefined ? 'some other string' : undefined);
});

So the question is: Is it possible to define fn signature or IFn so the above assertions violation inside of the implementation would be found by TypeScript?

Obviously, I'm not interested in runtime checks.

Answer 1

Try this:

interface IFn {
  (cb: (param: string) => void, param: string): void;
  (cb: () => void): void;
}

const fn: IFn = (
  ...args: [(param: string) => void, string] | [() => void]
) => {
  switch (args.length) {
    case 2: {
      const cb = args[0];
      const param = args[1];

      cb(param);
      break;
    }
    case 1: {
      const cb = args[0];

      cb();
      break;
    }
  }
};

Playground