时间戳

首页 > 解决方案 > 如何为具有大量私有类的功能模块组织 Typescript 类型定义？

typescript - 如何为具有大量私有类的功能模块组织 Typescript 类型定义？

问题描述

我正在为我不拥有的名为fessonia的库编写类型定义。我有一些这样做的经验，但是这个库的组织方式与我使用过的其他库不同，我不知道如何处理它。

这个图书馆index.js很小：

const getFessonia = (opts = {}) => {
  require('./lib/util/config')(opts);
  const Fessonia = {
    FFmpegCommand: require('./lib/ffmpeg_command'),
    FFmpegInput: require('./lib/ffmpeg_input'),
    FFmpegOutput: require('./lib/ffmpeg_output'),
    FilterNode: require('./lib/filter_node'),
    FilterChain: require('./lib/filter_chain')
  };
  return Fessonia;
}

module.exports = getFessonia;

它导出一个返回对象的函数，该对象的每个成员都是一个类。（到目前为止，我在 lib 中遇到的每个文件都使用默认导出。）我从模块函数模板开始，但我很难在我的一些指导原则之间找到和谐：

import getFessonia from '@tedconf/fessonia';
// note the type assignment
const config: getFessonia.ConfigOpts = {
    debug: true,
};
const { FFmpegCommand, FFmpegInput, FFmpegOutput } = getFessonia(config);

到目前为止，我采用的方法是.d.ts为每个.js文件创建有用的类型定义所需的文件，然后将它们导入index.d.ts并根据需要在命名空间中重新导出getFessonia。例如，为了为opts参数提供类型定义，我需要 read lib/util/config，它有一个默认的 export getConfig。它的类型文件最终看起来像这样：

import getLogger from './logger';

export = getConfig;

/**
 * Get the config object, optionally updated with new options
 */
declare function getConfig(options?: Partial<getConfig.Config>): getConfig.Config;

declare namespace getConfig {
    export interface Config {
      ffmpeg_bin: string;
      ffprobe_bin: string;
      debug: boolean;
      log_warnings: boolean;
      logger: getLogger.Logger;
    }
}

...我index.d.ts像这样使用它：

import getConfig from './lib/util/config';

export = getFessonia;

/**
 * Main function interface to the library. Returns object of classes when called.
 */
declare function getFessonia(opts?: Partial<getFessonia.ConfigOpts>): getFessonia.Fessonia;

declare namespace getFessonia {
    export interface Fessonia {
        // TODO
        FFmpegCommand: any;
        FFmpegInput: any;
        FFmpegOutput: any;
        FilterNode: any;
        FilterChain: any;
    }
    // note I've just aliased and re-exported this
    export type ConfigOpts = Partial<getConfig.Config>;
}

我认为我可能走错路的原因：

import getFessonia from '@tedconf/fessonia';

const { FFmpegCommand, FFmpegInput, FFmpegOutput } = getFessonia();
// note the deep nesting
const outputOptions: getFessonia.FFmpeg.Output.Options = { /* some stuff */ };
const output = new FFmpegOutput('some/path', outputOptions);

你做到了最后！感谢您阅读本文。虽然我怀疑没有一个“正确”的答案，但我期待阅读其他人采用的方法，并且很高兴有人指出我可以通过示例学习的文章或相关代码存储库。谢谢！

标签： typescripttype-definition

解决方案

@alex-wayne的评论帮助我重置了大脑。谢谢你。

出于某种原因，我正在编写类型定义，就好像库对默认导出的使用意味着我也无法从我的.d.ts文件中导出其他内容。可能是睡眠不足！

无论如何，除了默认导出函数之外，getFessonia我最终导出了一个接口Fessonia来描述返回值以及同名的命名空间（更多关于 TypeScript 的组合行为）来为getFessonia的选项以及各种其他实体提供类型图书馆提供。index.d.ts最终看起来像：

import { FessoniaConfig } from './lib/util/config';
import FFmpegCommand from './lib/ffmpeg_command';
import FFmpegInput from './lib/ffmpeg_input';
import FFmpegOutput from './lib/ffmpeg_output';
import FilterChain from './lib/filter_chain';
import FilterNode from './lib/filter_node';

/** Main function interface to the library. Returns object of classes when called. */
export default function getFessonia(opts?: Partial<Fessonia.ConfigOpts>): Fessonia;

export interface Fessonia {
  FFmpegCommand: typeof FFmpegCommand;
  FFmpegInput: typeof FFmpegInput;
  FFmpegOutput: typeof FFmpegOutput;
  FilterChain: typeof FilterChain;
  FilterNode: typeof FilterNode;
}

// re-export only types (i.e., not constructors) to prevent direct instantiation
import type FFmpegCommandType from './lib/ffmpeg_command';
import type FFmpegError from './lib/ffmpeg_error';
import type FFmpegInputType from './lib/ffmpeg_input';
import type FFmpegOutputType from './lib/ffmpeg_output';
import type FilterNodeType from './lib/filter_node';
import type FilterChainType from './lib/filter_chain';
export namespace Fessonia {
    export type ConfigOpts = Partial<FessoniaConfig>;

    export {
      FFmpegCommandType as FFmpegCommand,
      FFmpegError,
      FFmpegInputType as FFmpegInput,
      FFmpegOutputType as FFmpegOutput,
      FilterChainType as FilterChain,
      FilterNodeType as FilterNode,
    };
}

对于作为Fessonia对象一部分的类，我的一般方法是为每个类创建一个类型定义（省略私有成员）并将其导出。如果类函数具有复杂类型的参数，我会为它们创建定义并将它们导出到与类同名的命名空间中，例如：

// abridged version of types/lib/ffmpeg_input.d.ts
export default FFmpegInput;

declare class FFmpegInput {
    constructor(url: FFmpegInput.UrlParam, options?: FFmpegInput.Options);
}

declare namespace FFmpegInput {
    export type Options = Map<string, FFmpegOption.OptionValue> | { [key: string]: FFmpegOption.OptionValue };
    export type UrlParam = string | FilterNode | FilterChain | FilterGraph;
}

由于重新导出底部的类型，下面的index.d.ts下游代码成为可能：

import getFessonia, { Fessonia } from '@tedconf/fessonia';

const { FFmpegCommand, FFmpegInput, FFmpegOutput } = getFessonia();
// note the type assignment
const outputOptions: Fessonia.FFmpegOutput.Options = { /* some stuff */ };
const output = new FFmpegOutput('some/path', outputOptions);
const cmd = new FFmpegCommand(commandOpts);

虽然这与我最初的想法并没有太大的不同，但它确实感觉像是一种改进。我不必发明太多新的组织结构；类型名称与代码库的结构一致（添加了Fessonia命名空间）。它是可读的。

我第一次输入这个库可以在 GitHub 上找到。

感谢所有评论并让我有不同想法的人。

推荐阅读