Cuando uso el complemento TypeScript para vs.net, ¿cómo hago para que un módulo de importación de archivos TypeScript se declare en otros archivos TypeScript?

archivo 1:

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

archivo 2:

//what goes here?

class bar extends moo.foo
{
}

A partir de la versión 1.8 de TypeScript puede usar importdeclaraciones simples como en ES6:

import { ZipCodeValidator } from "./ZipCodeValidator";

let myValidator = new ZipCodeValidator();

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

Respuesta anterior: desde TypeScript versión 1.5 puede usar tsconfig.json: http://www.typescriptlang.org/docs/handbook/tsconfig-json.html

Elimina por completo la necesidad de hacer referencia al estilo de comentario.

Respuesta anterior:

Debe hacer referencia al archivo en la parte superior del archivo actual.

Puedes hacer esto así:

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

class Foo { }

etc.

Estas rutas son relativas al archivo actual.

Su ejemplo:

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

class bar extends moo.foo
{
}

Typecript distingue dos tipos diferentes de módulos: los módulos internos se utilizan para estructurar su código internamente. En tiempo de compilación, debe llevar los módulos internos al alcance utilizando rutas de referencia:

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

class bar extends moo.foo {
}

Por otro lado, los módulos externos se utilizan para hacer referencia a los archivos de origen externos que se cargarán en tiempo de ejecución utilizando CommonJS o AMD . En su caso, para utilizar la carga de módulos externos, debe hacer lo siguiente:

moo.ts

export class foo {
    test: number;
} 

app.ts

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

Tenga en cuenta la forma diferente de incluir el código en el alcance. Con los módulos externos, debe usar moduleel nombre del archivo fuente que contiene la definición del módulo. Si desea utilizar módulos AMD, debe llamar al compilador de la siguiente manera:

tsc --module amd app.ts

Esto luego se compila a

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

Si está utilizando módulos AMD, las otras respuestas no funcionarán en TypeScript 1.0 (la más nueva en el momento de la escritura).

Tiene diferentes enfoques disponibles, dependiendo de cuántas cosas desee exportar desde cada .tsarchivo.

Exportaciones múltiples

Foo.ts

export class Foo {}
export interface IFoo {}

Bar.ts

import fooModule = require("Foo");

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

Exportación única

Foo.ts

class Foo
{}

export = Foo;

Bar.ts

import Foo = require("Foo");

var foo = new Foo();

Si desea utilizar módulos y desea que se compile en un solo archivo JavaScript, puede hacer lo siguiente:

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()
        {
        }
    }
}

Puede leer más aquí: http://www.codebelt.com/typescript/javascript-namespacing-with-typescript-internal-modules/

Ahora evitaría usar /// <reference path='moo.ts'/>pero para bibliotecas externas donde el archivo de definición no está incluido en el paquete.

Los reference patherrores resuelve del editor, pero que en realidad no significa que las necesidades de archivos a importar. Por lo tanto, si está utilizando un flujo de trabajo de Gulp o JSPM, estos podrían intentar compilar por separado cada archivo en lugar de tsc -outun solo archivo.

De Typecript 1.5

Simplemente prefija lo que desea exportar a nivel de archivo (alcance raíz)

aLib.ts

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

También puede agregar más tarde al final del archivo lo que desea 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
}

O incluso mezclar ambos juntos

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

Para la importación tiene 2 opciones, primero elige de nuevo lo que desea (uno por uno)

anotherFile.ts

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

O todas las exportaciones

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

Nota sobre las exportaciones: exportar dos veces el mismo valor generará un error {export valueZero = 0; export {valueZero}; // valueZero ya se exportó ...}

Desde TypeScript 1.8+puede usar una importdeclaración simple simple como:

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

o la versión comodín:

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

Leer más: https://www.typescriptlang.org/docs/handbook/modules.html

usó una referencia como "///<reference path="web.ts" /> y luego en las propiedades del proyecto VS2013 para compilar "app.ts", "Typecript Build" -> "Combinar la salida de JavaScript en el archivo:" (marcado) -> "app.js"

import {className} from 'filePath';

recuerda también. La clase que está importando, que debe exportarse en el archivo .ts.

Proceso fácil y rápido en Visual Studio

Arrastre y suelte el archivo con la extensión .ts desde la ventana de la solución al editor, generará un código de referencia en línea como ...

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