在typescript .d中定义闭包函数返回类型的更好方法.ts文件

Question

我在我的typescript定义文件.d.ts中声明这个函数。它返回一个复杂的预定义对象。同样需要帮助。

我使用了npx -p typescript tsc src/handler.js --declaration --allowJs --emitDeclarationOnly --outDir types的那种命令，它给了我一个。d。handler.js的Ts文件如下:

handler.js

function handler() {
const myconst = 10;
function setupHandler (config) {
config.value = myconst;
return { ...config }
}
function setProcess(cnf) {
let proc = setupHandler(cnf);
return true;
}
return {
setup: setupHandler,
process: {
set: setProcess,
options: {
value: myconst
}
}
}
}

现在生成的handler.d.ts文件如下所示:

handler.d.ts

export = handler;
declare function handler(): any;

我尝试了以下方法，但不确定这是否是正确的方法来获得正确的工作类型。有什么建议吗?

我要找的是:

创建。d。Ts文件，该文件将能够显示闭包函数的返回对象值/类型(预定义)。这主要用于文档和代码智能感知目的

export = handler;
declare function setupHandler(config: any): any;
declare function setProcess(config: any): any;
declare interface handlerreturn {
setup: typeof setupHandler,
process: {
set: typeof setProcess,
options: {
value: number
}
}
}
declare function handler(): handlerreturn;

有更好的处理方法吗?因为它是闭包函数，所以函数保持这种方式。

UPDATE on comments:

实际文件:https://github.com/cgi-js/cgi-js/blob/main/src/process.js

配置对象的结构与文件process属性对象一样:https://github.com/cgi-js/cgi-js/blob/main/src/configs.js

process.d.ts(alternate try):

export default handler;
export type setup = () => void;
export type setProcess = (config: any) => void;
export type getProcess = () => void;
export type registerHandlers = () => void;
export type exec = () => void;
export type execFile = () => void;
export type fork = () => void;
export type spawn = () => void;
export type executeProcess = () => void;
export type executeAction = () => void;
export type kill = () => void;

export type handlerreturn = {
set: () => void,
process: {
set: setProcess,
get: getProcess,
registerHandlers: registerHandlers,
exec: exec,
execFile: execFile,
fork: fork,
spawn: spawn,
executeProcess: executeProcess,
executeAction: executeAction,
kill: kill,
}
}

/**
*
* handler
* Process Execution and Management handler
*
*
* @returns { Object } Process module functions
*      Module Object ==> { Process Object }
*
*              setup [function]
*              process [object]: {
*                  set [function],
*                  get [function],
*                  registerHandlers [function],
*                  exec [function],
*                  execFile [function],
*                  fork [function],
*                  spawn [function],
*                  executeProcess [function],
*                  executeAction [function],
*                  kill [function]
*              }
*
*/
declare function handler(): {
set: () => void,
process: {
set: () => void,
get: () => void,
registerHandlers: () => void,
exec: () => void,
execFile: () => void,
fork: () => void,
spawn: () => void,
executeProcess: () => void,
executeAction: () => void,
kill: () => void,
}
};
// Alternate process.d.ts file
// declare function handler(): handlerreturn;

Answer 1

使用any本质上违背了TypeScript的目的——它类似于根本不做任何类型检查。除非你绝对有必要，否则不要使用它。

遍历handler返回的对象…你有一个函数，它接受一个对象，并加上一个value，这是一个数字。除非您对这是什么类型的对象有特定的想法，否则为了灵活起见，请使用泛型，以便返回类型可以与传入的类型一致。你也可能不想改变对象，而是返回一个新对象，它是旧对象的克隆，但具有新值。用途:

function setupHandler (config) {
return { ...config, value: myconst }
}

和

type SetupHandler = <T extends {}>(config: T) => T & { value: number };

setProcess调用setupHandler，但setProcess不使用调用的结果，并返回true，这看起来像一个错误，但如果这真的是你的代码，那么它很简单…

type SetProcess = (config: object) => true;

而value只是一个数字。

使用这些类型来定义handler的返回对象。

declare const handler: () => {
setup: SetupHandler;
process: {
set: SetProcess;
options: {
value: number; // or 10, if specificity is desired
}
}
};

如果愿意，还可以将类型内联放在返回的对象类型中，而不是事先定义它们。