Hur använder man Typescript interna moduler med AMD-moduler

Jag är inte säker på om jag strukturerar mitt TypeScript felaktigt, så jag kanske ställer fel fråga här.

Jag har 2 relaterade klasser och 1 gränssnitt i separata filer i samma mapp.

Jag har packat in dem i en modul eftersom det känns som det jag borde göra när man kommer från C#.

Det här är allt AngularJS så det gör sin egen DI vilket kan vara viktigt men förmodligen inte är det.

Fil 1:

export module Module1{
    export interface IService{
    }
}

Fil2:

export module Module1{
    export class Implementation implements IInterface{
    ...
    }
}

Fil 3 är Angular-kod som använder den Angular-injicerade instansen av IInterface. Om jag importerar Fil2 med require("./File2") fungerar det, men jag skulle hellre importera hela Module1, något i stil med nedan, så att jag inte behöver kräva varje klass individuellt (eftersom detta uppenbarligen är ett förenklat fall).

import authModule = require('Module1');

var assetStreamApp = angular.module("[])
    .run(['IInterface'], (instance: IInterface) => {
        instance.doSomething();
    });

Är detta möjligt?

Jag vill inte behöva importera varje fil individuellt och sedan välja en annan alias för varje "modul" för att namnge typerna när det känns som att jag borde kunna göra det en gång.

Redigera: Efter lite mer läsning tror jag att jag har förstått en del av terminologin. Jag vill använda TypeScript interna moduler i ett projekt men också använda AMD-moduler som delningspunkter så att jag kan använda Webpacks koddelning.

Svar #1

Idealiskt sett bör du bara använda externa moduler och inte blanda interna med externa moduler.

Detta har diskuterats i detalj här och här.

Jag skulle rekommendera att göra... IService.ts:

interface IService {
}

export = IService;

Implementation.ts:

import IInterface = require("./IInterface");

class Implementation implements IInterface{
...
}

export = Implementation;

Och importera dem sedan på ett lämpligt sätt till din fil:

import IService = require("./IService");
import Implementation = require("./Implementation");

// use IService and Implementation here

Kombinera flera moduler till en modul

Det sagt, om du verkligen ville, kunde du använda IService.ts och Implementation.ts ovan och sedan skapa en fil som heter Module1.ts där du importerar och sedan exporterar dina moduler så här:

export import IService = require("./IService");
export import Implementation = require("./Implementation");

Då kan du använda det i din kod på följande sätt:

import Module1 = require("./Module1");

// use Module1.IService or Module1.Implementation here

Att kombinera flera moduler med ES6-moduler

Förresten ville jag påpeka att det är väldigt praktiskt att göra detta om du använder ES6-moduler...

IService.ts:

interface IService {
}

export default IService;

Implementation.ts:

import IInterface from "./IInterface";

export default class Implementation implements IInterface {
...
}

Module1.ts:

// re-export the modules
export {default as IService} from "./IService";
export {default as Implementation} from "./Implementation";

Då när du använder denna modul kan du enkelt få åtkomst till det du vill ha ur den. Här är några exempel på importuttalanden:

// import only IService
import {IService} from "./Module1";
// import IService and Implementation
import {IService, Implementation} from "./Module1";
// or implement everything on a Module1 object
import * as Module1 from "./Module1";