Ao usar o plug-in TypeScript para vs.net, como faço para declarar um módulo de importação de arquivo TypeScript em outros arquivos TypeScript?

arquivo 1:

module moo
{
    export class foo .....
}

arquivo 2:

//what goes here?

class bar extends moo.foo
{
}

Na versão 1.8 do TypeScript, você pode usar importinstruções simples , como no ES6:

import { ZipCodeValidator } from "./ZipCodeValidator";

let myValidator = new ZipCodeValidator();

https://www.typescriptlang.org/docs/handbook/modules.html

Resposta antiga: No TypeScript versão 1.5, você pode usar tsconfig.json: http://www.typescriptlang.org/docs/handbook/tsconfig-json.html

Elimina completamente a necessidade de referenciar o estilo de comentário.

Resposta mais antiga:

Você precisa fazer referência ao arquivo na parte superior do arquivo atual.

Você pode fazer isso assim:

/// <reference path="../typings/jquery.d.ts"/>
/// <reference path="components/someclass.ts"/>

class Foo { }

etc.

Esses caminhos são relativos ao arquivo atual.

Seu exemplo:

/// <reference path="moo.ts"/>

class bar extends moo.foo
{
}

O Typecript distingue dois tipos diferentes de módulos: Módulos internos são usados ​​para estruturar seu código internamente. No tempo de compilação, você precisa colocar módulos internos no escopo usando caminhos de referência:

/// <reference path='moo.ts'/>

class bar extends moo.foo {
}

Por outro lado, módulos externos são usados ​​para referenciar arquivos de origem externos que devem ser carregados em tempo de execução usando CommonJS ou AMD . No seu caso, para usar o carregamento de módulo externo, você deve fazer o seguinte:

moo.ts

export class foo {
    test: number;
} 

app.ts

import moo = module('moo');
class bar extends moo.foo {
  test2: number;
}

Observe a maneira diferente de colocar o código no escopo. Com módulos externos, você deve usar modulecom o nome do arquivo de origem que contém a definição de módulo. Se você quiser usar os módulos AMD, precisará chamar o compilador da seguinte maneira:

tsc --module amd app.ts

Isso então é compilado para

var __extends = this.__extends || function (d, b) {
    function __() { this.constructor = d; }
    __.prototype = b.prototype;
    d.prototype = new __();
}
define(["require", "exports", 'moo'], function(require, exports, __moo__) {
    var moo = __moo__;

    var bar = (function (_super) {
        __extends(bar, _super);
        function bar() {
            _super.apply(this, arguments);

        }
        return bar;
    })(moo.foo);
})    

Se você estiver usando módulos AMD, as outras respostas não funcionarão no TypeScript 1.0 (a mais nova no momento da redação).

Você tem diferentes abordagens disponíveis, dependendo de quantas coisas deseja exportar de cada .tsarquivo.

Exportações múltiplas

Foo.ts

export class Foo {}
export interface IFoo {}

Bar.ts

import fooModule = require("Foo");

var foo1 = new fooModule.Foo();
var foo2: fooModule.IFoo = {};

Exportação única

Foo.ts

class Foo
{}

export = Foo;

Bar.ts

import Foo = require("Foo");

var foo = new Foo();

Se você deseja usar módulos e deseja que ele seja compilado em um único arquivo JavaScript, faça o seguinte:

tsc -out _compiled/main.js Main.ts

Main.ts

///<reference path='AnotherNamespace/ClassOne.ts'/>
///<reference path='AnotherNamespace/ClassTwo.ts'/>

module MyNamespace
{
    import ClassOne = AnotherNamespace.ClassOne;
    import ClassTwo = AnotherNamespace.ClassTwo;

    export class Main
    {
        private _classOne:ClassOne;
        private _classTwo:ClassTwo;

        constructor()
        {
            this._classOne = new ClassOne();
            this._classTwo = new ClassTwo();
        }
    }
}

ClassOne.ts

///<reference path='CommonComponent.ts'/>

module AnotherNamespace
{
    export class ClassOne
    {
        private _component:CommonComponent;

        constructor()
        {
            this._component = new CommonComponent();
        }
    }
}

CommonComponent.ts

module AnotherNamespace
{
    export class CommonComponent
    {
        constructor()
        {
        }
    }
}

Você pode ler mais aqui: http://www.codebelt.com/typescript/javascript-namespacing-with-typescript-internal-modules/

Eu evitaria usar agora, /// <reference path='moo.ts'/>mas para bibliotecas externas, onde o arquivo de definição não está incluído no pacote.

A reference pathsolução resolve erros no editor, mas isso realmente não significa que o arquivo precise ser importado. Portanto, se você estiver usando um fluxo de trabalho gulp ou JSPM, eles poderão tentar compilar separadamente cada arquivo em vez de tsc -outum arquivo.

Do Typecript 1.5

Basta prefixar o que você deseja exportar no nível do arquivo (escopo raiz)

aLib.ts

{
export class AClass(){} // exported i.e. will be available for import
export valueZero = 0; // will be available for import
}

Você também pode adicionar posteriormente, no final do arquivo, o que deseja exportar

{
class AClass(){} // not exported yet
valueZero = 0; // not exported yet
valueOne = 1; // not exported (and will not in this example)

export {AClass, valueZero} // pick the one you want to export
}

Ou até misture os dois juntos

{
class AClass(){} // not exported yet
export valueZero = 0; // will be available for import
export {AClass} // add AClass to the export list
}

Para a importação, você tem 2 opções, primeiro você escolhe novamente o que deseja (uma por uma)

anotherFile.ts

{
import {AClass} from "./aLib.ts"; // you import only AClass
var test = new AClass();
}

Ou as exportações inteiras

{
import * as lib from "./aLib.ts"; // you import all the exported values within a "lib" object
var test = new lib.AClass();
}

Nota sobre as exportações: exportar duas vezes o mesmo valor gerará um erro {export valueZero = 0; exportar {valueZero}; // valueZero já está exportado…}

Desde o TypeScript, 1.8+você pode usar uma importdeclaração simples e simples como:

import { ClassName } from '../relative/path/to/file';

ou a versão curinga:

import * as YourName from 'global-or-relative';

Leia mais: https://www.typescriptlang.org/docs/handbook/modules.html

usou uma referência como "///<reference path="web.ts" /> e, em seguida, nas propriedades do projeto do VS2013 para criar "app.ts", "Compilação de texto datilografado" -> "Combine a saída de javascript no arquivo:" (marcado) -> "app.js"

import {className} from 'filePath';

lembre-se também. A classe que você está importando, que deve ser exportada no arquivo .ts.

Processo fácil e rápido no Visual Studio

Arraste e solte o arquivo com a extensão .ts da janela da solução para o editor, ele gerará um código de referência embutido como ..

/// <reference path="../../components/someclass.ts"/>