Javascript 为返回包装函数的函数的vanilla函数添加d.ts

在我的vanilla JS代码中有一个复杂的函数（参见后面的简单示例），它获取

export

d，我想向它添加一个

d.ts

到目前为止，我编写

.d.ts

的尝试还没有将类型从中间阶段转发到最后阶段

函数看起来是这样的（我在保持相同结构的同时尽可能简化了它）

示例用法

const A = factory(1, 2);
const fn = (a1, a2) => a1 + ' world' + a2; // (a1: string, a2: string) => string
const B = A(fn); // (i: string, j: string) => Promise<string>
B('hello', '!'); // warns 3 and returns a Promise<string> "hello world!"

但是,

• 当查看

  B

  时，关于

  fn

  的所有类型信息都丢失了，而当我期望

  （字符串，字符串）=>承诺时，我只剩下
  任何[]=>承诺

• 返回类型的描述重复多次

我也尝试过用interface-y的方式编写，但这也有同样的问题，类型丢失，我不知道你会如何引用它们

declare function factory(x: number): wrapper;
declare function factory(x: number, y: number): wrapper;
interface wrapper {
    (fn: function): wrapped;
}
interface wrapped {
    (...args: any): Promise<any>;
}

声明函数工厂（x:number）：包装器；
声明函数工厂（x:number，y:number）：包装器；
接口包装器{
（fn：功能）：包装；
}
界面包裹{
（…args:any）：承诺；
}

如果我正确理解了这个问题，您希望最终函数的参数与作为参数传递的函数的参数相同。虽然不能对任意数量的参数执行此操作，但您可以为最多包含4个参数的函数定义重载（例如），并在以后需要时添加更多参数：

declare function factory(x: number): Promiseify;
declare function factory(x: number, y: number): Promiseify;

interface Promiseify {
    <T>(fn: () => T): () => Promise<T>;
    <T, U1>(fn: (arg1: U1) => T): (arg1: U1) => Promise<T>;
    <T, U1, U2>(fn: (arg1: U1, arg2: U2) => T): (arg1: U1, arg2: U2) => Promise<T>;
    <T, U1, U2, U3>(fn: (arg1: U1, arg2: U2, arg3: U3) => T): (arg1: U1, arg2: U2, arg3: U3) => Promise<T>;
    <T, U1, U2, U3, U4>(fn: (arg1: U1, arg2: U2, arg3: U3, arg4: U4) => T): (arg1: U1, arg2: U2, arg3: U3, arg4: U4) => Promise<T>;
}
const A = factory(1, 2);
const fn = (a1: string, a2: number) => a1 + ' world' + a2; // (a1: string, a2: number) => string
const B = A(fn); // (arg1: string, arg2: number) => Promise<string>
B('hello', 1); // ok 
B('hello', '1'); // error

申报功能工厂（x:编号）：承诺；
申报功能工厂（x:编号，y:编号）：承诺；
接口承诺{
（fn:（）=>T:（）=>承诺；
（fn:（arg1:U1）=>T:（arg1:U1）=>Promise；
（fn:（arg1:U1，arg2:U2）=>T:（arg1:U1，arg2:U2）=>Promise；
（fn:（arg1:U1，arg2:U2，arg3:U3）=>T:（arg1:U1，arg2:U2，arg3:U3）=>Promise；
（fn:（arg1:U1，arg2:U2，arg3:U3，arg4:U4）=>T:（arg1:U1，arg2:U2，arg3:U3，arg4:U4）=>Promise；
}
常数A=工厂（1,2）；
常量fn=（a1:string，a2:number）=>a1+“世界”+a2；//（a1:字符串，a2:数字）=>字符串
常数B=A（fn）；//（arg1:string，arg2:number）=>Promise
（你好，1）；//好啊
B（'hello'，'1'）；//错误

如果我理解正确，您希望结果函数的参数与作为参数传递的函数的参数相同？遗憾的是，您不能任意执行，但对于合理的已知长度，这看起来效果很好，谢谢！

declare function factory(x: number): Promiseify;
declare function factory(x: number, y: number): Promiseify;

interface Promiseify {
    <T>(fn: () => T): () => Promise<T>;
    <T, U1>(fn: (arg1: U1) => T): (arg1: U1) => Promise<T>;
    <T, U1, U2>(fn: (arg1: U1, arg2: U2) => T): (arg1: U1, arg2: U2) => Promise<T>;
    <T, U1, U2, U3>(fn: (arg1: U1, arg2: U2, arg3: U3) => T): (arg1: U1, arg2: U2, arg3: U3) => Promise<T>;
    <T, U1, U2, U3, U4>(fn: (arg1: U1, arg2: U2, arg3: U3, arg4: U4) => T): (arg1: U1, arg2: U2, arg3: U3, arg4: U4) => Promise<T>;
}
const A = factory(1, 2);
const fn = (a1: string, a2: number) => a1 + ' world' + a2; // (a1: string, a2: number) => string
const B = A(fn); // (arg1: string, arg2: number) => Promise<string>
B('hello', 1); // ok 
B('hello', '1'); // error