La forma de extender el módulo a través de múltiples archivos de AMD?

La especificación permite definir internos módulos en varios archivos (en esencia, los módulos internos se refieren al diseño del módulo de JavaScript). Externos módulos, tales como módulos de AMD o CommonJS, el trabajo sobre la idea de que cada archivo es el "módulo de código" real, y la namespacing / nombrar dentro de ella es irrelevante, ya que el módulo se cargará en su propio nuevo objeto de todos modos.

Se puede escribir el siguiente código para cargar el módulo Contact.ts interior del módulo ContactView.ts:

// file ContactView.ts    
import mod = module("./Contact");

export module Contacts {
   export class ContactView {
      model: mod.Contacts.Contact;  // <---  will be recognized
   }
}

Y eso debería funcionar bastante bien, pero si quería tener acceso a los contenidos de los dos módulos en otra área (por ejemplo, para hacer un nuevo contacto del mismo), que tendría que importar esencialmente dos:

import c = module("./Contact");
import cv = module("./ContactView");

Que creo que es lo suficientemente fina, porque usted está indicando claramente sus dependencias. La desventaja es que ellos no van comparten un objeto padre común, así que tener a ambos estar en una "Contacto" módulo de patrón probablemente no es de gran utilidad.

Otra opción es exportar "Contacto" junto con "ContactView", de la siguiente manera (otorgado este código es un poco tonto porque ya está haciendo exactamente eso a través de la propiedad del modelo de ContactView, pero nunca menos ...):

export module Contacts {
   export class ContactView {
       model: mod.Contacts.Contact;
       constructor() {
           this.model = new mod.Contacts.Contact();
       }
    }

    export var Contact = mod.Contacts.Contact;
}

Por lo que sería capaz de acceder a él después de haber cargado ContactView.

EDIT: Por cierto, no está limitado a los módulos sólo se exportan a través de "Nombre módulo de exportación {...}", se puede exportar nada como el propio archivo es el módulo. Por lo que podría tener un archivo que acaba de "función de exportación foo () {...}" sin ningún tipo de código del módulo de patrón de envolverlo.

Edit2: Parece que AMD podría tener funcionalidad para cargar varias dependencias y la construcción de "módulos" de esos, pero no tengo idea de cómo funcionaría en el TS, aquí hay un enlace que va sobre eso: http://www.adobe.com /devnet/html5/articles/javascript-architecture-requirejs-dependency-management.html (módulos constructor).

Luché con la misma pregunta por un tiempo, y sólo quería compartir lo que estoy haciendo en el caso de cualquier otra persona vaga por esta pregunta.

En primer lugar, yo he definido un archivo de referencia que declara todos los archivos en mi módulo:

/// <reference path="_contacts.dependencies.ts" />
/// <reference path="../contacts/Contact.ts" />
/// <reference path="../contacts/ContactView.ts" />
/// <reference path="../contacts/ContactModel.ts" />

Tenga en cuenta que las rutas especificadas en el archivo son en relación con la ubicación del archivo de referencia en sí ( _contacts.ts), a diferencia de un .jsarchivo de referencia. Mi estructura de directorios es el siguiente:

modules
    references // all of the reference files
        knockout 
        underscore
        // ... a subfolder for every 3rd party library used
    contacts
    commerce 
    // ... other modules at same level as contacts

Volver a la referencia de archivo en sí. La primera línea incluye un archivo de referencia separado indicando todas las bibliotecas externos utilizados por el módulo, como el subrayado, el momento o cualquier otra biblioteca existente tiene un .d.tsarchivo de definición de. Las líneas restantes son los archivos que componen el módulo.

Dentro de cada archivo que forma parte del módulo, que hacen referencia al archivo anterior:

/// <reference path="../references/_contacts.ts" />
module Contacts {
    export class Contact { 
        public model: ContactModel;
        // ...
    }
} 

Del mismo modo, se puede crear un archivo de referencia único para listar todos los módulos:

/// <reference path="_address.ts" />
/// <reference path="_contacts.ts" />
/// <reference path="_commerce.ts" />

Y simplemente apuntar a esto desde los archivos de origen.

Esto no resuelve el problema del código emitido estar en archivos separados, sin embargo. Para ese problema que estoy usando una herramienta de minimización de JavaScript, que es capaz de agrupar múltiples archivos en un solo archivo fuente. Dependiendo de la configuración de compilación y las necesidades de casos de uso, puede que tenga que aplicar un poco de envoltorio sobre el código generado para que funcione como un módulo de AMD (no demasiado familiarizados con esa parte).