Class Typescript:无法导出属于通用接口且包含其他通用接口的模块

我正在尝试为Bluebird编写一个CommonJS声明文件，这是一个直接导出通用promise类的promise库。但是，该库还将其他几个泛型类导出为静态成员（PromiseInspection），似乎不可能使用typescript对此进行建模

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

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

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

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

声明模块“蓝鸟3”{
出口接口承诺检查{
// ...
}
出口接口承诺{
构造函数（）；
检查（）：承诺检查；
}
export new（）；//语法错误
导出函数cast（值：U）：承诺；
}

这几乎是可行的，当然不可能以这种方式构造构造函数

4.名称空间污染方式（有效，有缺点）

接口承诺检查{
// ...
}
接口承诺{
构造函数（）；
检查（）：承诺检查；
}
声明模块“Bluebird 4”{
接口承诺{
新的（）：承诺；
承诺检验：承诺检验的类型；
铸造（价值：U）：承诺；
}
出口=承诺；
}

工作正常，但它同时污染了Promise和PromiseInspection的全局名称空间。这可能没问题，但我宁愿避免它，因为它通常被认为是不可接受的

5.与声明合并（让我90%的方式…）

声明模块“蓝鸟5”{
模块承诺{
出口接口承诺检查{
值（）：T；
// ...
}
出口
功能转换（值：U）：承诺；
}
阶级承诺{
新的（）：承诺；
检查（）：Promise.Promise检查；
}
出口=承诺；
}

差不多了-除了现在我不允许用

接口承诺

替换

类承诺

，使

承诺

无法恢复。如果我尝试执行此操作，将显示以下代码：

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

import Promise=require（'bluebird'）；
var x=新承诺（）；
x、 检查（）.value（）.toExponential（）；

失败，错误为“无效的“新”表达式”

-此名称空间当前污染全局名称空间（使用解决方案4）

---

有没有更好的方法来实现这一点，或者我是否遇到了语言限制？

查看您的代码时，我注意到您缺少一些

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中定义打字时使用接口：

声明模块蓝鸟{
出口接口承诺检查{
// ...
}
出口接口承诺{
构造函数（）；
检查（）：承诺检查；
}
导出接口承诺{
新的（）；
全部（承诺：承诺[]）：承诺；
}
}
声明模块“蓝鸟”{
出口=蓝鸟；
}

如果失败了，您是否尝试过使用另一个promises库作为您打字的基础？你可以做得比看着我更糟

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

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;
}

声明函数Q（promise:Q.IPromise）：Q.promise；
声明函数Q（promise:JQueryPromise）：Q.promise；
声明函数Q（值：T）：Q.承诺；
声明模块Q{
//…这里的功能等
}
声明模块“q”{
出口=Q；
}

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;
}

声明模块“蓝鸟”{
模块承诺{
出口接口承诺检查{
值（）：T；
}
}
接口承诺{
检查（）：Promise.Promise检查；
}
风险值承诺：{
新的（）：承诺；
铸造（价值：U）：承诺；
}
出口=承诺；
}

所以基本上：

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

此外，他的评论是：

通过这种方式编写，您对标识符承诺的三种含义中的每一种都有一个单独的声明：作为名称空间（仅包含类型的模块）、类型（碰巧是泛型的）和值

---

是的，我确实使用了Q作为基础，但是Q将其promise类导出为Q.promise，而Bluebird将类构造函数本身导出。。。编辑：关于缺少的导出语句，我添加了一个指向实际bluebird.d.ts的链接-bluebird不是一个包含“Promise”类的模块。该模块是Promise类，但也有一个本身是泛型类的静态meber PromiseInspection。我将在Illustrated usage example中添加一个用法示例，说明我为什么使用

export=Interface

或

export=Class

Hi Gorgi，BB定义文件的状态如何？“我在DefinitelyTyped上没有看到拉取请求，我想使用它。@SeanClarkHess看起来像是有人打败了我。查看我的版本在node中工作得更好，可以在这里找到-棒极了。您是否已经提出拉取请求？如果不是，你应该！谢谢大家!@SeanClarkHess-我在ts 0.9.5和node中遇到了一些问题，仅仅使用返回承诺的东西就需要导入承诺库。我决定放弃

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;
}

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

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;
}

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;
}

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;
}

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;
}