定义闭合函数的返回类型的更好方法

Question

我正在在Typescript定义文件.D.TS中声明该函数。它返回一个复杂的预定义对象。需要同样的帮助。

我使用了npx -p typeScript TSC SRC/Handler.js - declaration -declaration -allowjs -emitdeclarationly -outdir types命令类型，它为我提供了一个.d.ts文件。 js是以下类似的内容：

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.t.ts文件现在看起来像这样。

Handler.D.TS

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

我已经尝试了以下内容，但不确定这是否是正确工作的正确方法。有什么建议吗？

目标我试图达到的是：

创建一个.d.ts文件，该文件将能够显示闭合功能的返回对象值/类型（预定）。这主要用于文档和代码Intellisense用途

    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;

是否有更好的处理方法？由于它是闭合函数，因此该函数被保留。

评论更新：

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

配置对象结构如文件process属性对象所示：此处： https://github.com/cgi-js/ cgi-js/blob/main/src/configs.js

process.d.ts（替代尝试）：

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

使用任何实质上都会击败打字稿的目的 - 类似于根本不进行任何类型检查。除非您绝对必须使用，否则不要使用它，这几乎永远不会。

浏览处理程序返回的对象...您具有一个函数，该函数获取对象，并添加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只是一个数字。

使用这些类型定义处理程序的返回对象。

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

您还可以将内联类型放在返回的对象类型中，而不必事先定义它们。