打字稿：无法导出作为通用接口并包含其他通用接口的模块

Question

我正在尝试为 Bluebird 编写一个 CommonJS 声明文件，这是一个直接导出通用 Promise 类的 Promise 库。但是，该库还将其他几个泛型类导出为静态成员 (PromiseInspection)，并且似乎无法使用 typescript 对其进行建模。

编辑：使用示例，说明模块的导出类如何工作：

import Promise = require('bluebird');
var promise:Promise<number> = Promise.cast(5);
var x:Promise.PromiseInspection<number> = promise.inspect();

我尝试了几种策略 - 简化示例如下：

1。显而易见的方式

declare module "bluebird" {
    class PromiseInspection<T> {
        // ...
    }
    class Promise<T> {
        PromiseInspection: typeof PromiseInspection; // error
        constructor<T>();
        inspect():PromiseInspection<T>; // error
        static cast<U>(value:U):Promise<U>; 
        // ...
    }
    export = Promise;
}

失败，错误无法使用私有类型PromiseInspection 作为公共属性

2。使用静态接口

declare module "bluebird2" {
    interface PromiseInspection<T> {
        // ...  
    }
    interface Promise<T> {
        constructor<T>();
        inspect():PromiseInspection<T>;
    }
    interface PromiseStatic {
        new<T>();
        PromiseInspection:typeof PromiseInspection;
        cast<U>(value:U):Promise<U>; // error
    }
    export = PromiseStatic;
}

同样失败，但这次私有类型是 Promise

3。尝试直接从模块中导出构造函数

declare module "bluebird3" {
    export interface PromiseInspection<T> {
        // ...
    }
    export interface Promise<T> {
        constructor<T>();
        inspect():PromiseInspection<T>;
    }

    export new<T>(); // syntax error
    export function cast<U>(value:U):Promise<U>; 
}

这几乎可以工作，当然构造函数不可能那样做。

4。命名空间污染方式（有效，有缺点）

interface PromiseInspection<T> {
    // ...
}
interface Promise<T> {
    constructor<T>();
    inspect():PromiseInspection<T>;
}

declare module "bluebird4" {    
    interface PromiseStatic {
        new<T>():Promise<T>;
        PromiseInspection: typeof PromiseInspection;
        cast<U>(value:U):Promise<U>;
    }
    export = PromiseStatic;
}

有效，但它使用 Promise 和 PromiseInspection 污染了全局命名空间。这可能没问题，但我宁愿避免它，因为在 CommonJS 中它通常被认为是不可接受的。

5。声明合并（让我完成了 90% 的工作......）

declare module "bluebird5" {
    module Promise {
        export interface PromiseInspection<T> {
            value(): T;
            // ...
        }
        export
        function cast<U>(value: U): Promise<U> ;
    }

    class Promise<T> {
        new <T> (): Promise <T> ;
        inspect(): Promise.PromiseInspection <T> ;
    }

    export = Promise;
}

差不多了 - 除了现在我不能用interface Promise<T> 替换class Promise<T>，这使得Promise<T> 无法扩展。如果我尝试这样做，以下代码：

import Promise = require('bluebird');
var x = new Promise<number>();
x.inspect().value().toExponential();

失败并出现错误“无效的'new'表达式”

Link to the actual, work-in-progress bluebird.d.ts - 这个当前污染了全局命名空间（使用解决方案 4）

有没有更好的方法来做到这一点，还是我遇到了语言限制？

Answer 1

Anders Hejlsberg 在 CodePlex 上发布了一个答案，所以我将在此处添加它。声明合并解决方案很接近 - 但我还需要一个“var”声明来声明静态接口，因为它是唯一可以接受构造函数的接口。

declare module "bluebird" {
    module Promise {
        export interface PromiseInspection<T> {
            value(): T;
        }
    }
    interface Promise<T> {
        inspect(): Promise.PromiseInspection <T> ;
    }

    var Promise: {
        new<U>(): Promise<U>;
        cast<U>(value: U): Promise<U> ;
    }
    export = Promise;
}

所以基本上：

• 模块声明中的接口成员（只要它们仅声明类型，即非物理）
• 主界面中的实例成员
• var 声明中的静态函数成员、构造函数和其他“物理”成员。

另外，他的评论：

以这种方式编写它，您对标识符 Promise 的三个含义中的每一个都有一个单独的声明：作为命名空间（仅包含类型的模块）、作为类型（恰好是泛型）和作为值。

Answer 2

查看您的代码，我注意到您缺少一些 export 语句。下面的代码可以编译 - 它适合吗？

declare module bluebird {
    export class PromiseInspection<T> {
        // ...
    }
    export class Promise<T> {
        constructor<T>();
        inspect():PromiseInspection<T>;
        static all<T>(promises:Promise<T>[]):Promise<T[]>;
    }
}

declare module "bluebird" {
    export = bluebird;
}

虽然我通常喜欢在定义类型时使用接口，如 #2：

declare module bluebird {
    export interface PromiseInspection<T> {
        // ...
    }
    export interface Promise<T> {
        constructor<T>();
        inspect():PromiseInspection<T>;
    }
    export interface PromiseStatic {
        new<T>();
        all<T>(promises:Promise<T>[]):Promise<T[]>;
    }
}

declare module "bluebird" {
    export = bluebird;
}

您是否尝试过使用另一个 Promise 库作为输入的基础？你可以做的比看https://github.com/borisyankov/DefinitelyTyped/blob/master/q/Q.d.ts更糟糕

粗略地说，它们看起来有点像这样：

declare function Q<T>(promise: Q.IPromise<T>): Q.Promise<T>;
declare function Q<T>(promise: JQueryPromise<T>): Q.Promise<T>;
declare function Q<T>(value: T): Q.Promise<T>;

declare module Q {
    //… functions etc in here
}

declare module "q" {
    export = Q;
}