Wrap molti moduli interni per l'esportazione in dattiloscritto

Question

Sto cercando di usare dattiloscritto nel nodo e sono attualmente utilizzato per usare dattiloscritto tramite la sintassi ///<reference.../> utilizzando esclusivamente moduli interni. Tuttavia, con progetti più grandi questo può diventare ingombrante in quanto è possibile avere moduli che fanno riferimento ad altri moduli che hanno tutti riferimenti di interconnessione.

Quindi, per questo progetto nodo pensavo di cercare di raggruppare tutti logiche componenti come moduli interni/classi molto simile prima, quindi saranno tutti riferimento internamente tra loro, ma li espongono tramite un modulo esterno che esporrebbe classi sottostanti ecc

questo modo la sintassi sarebbero molto simili di nodi meccanismi che richiedono esistenti, come:

import database = require("my-external-db-module.ts"); 
var connection = new database.Connection(someUrl); 

anziché

///<reference path="my-internal-db-modules.ts" /> 
var connection = new Database.Connection(someUrl); 

E immagino la sintassi sarebbe qualcosa di simile:

///<reference path="all-my-internal-module-files-etc.ts" /> 
///<reference path="..." /> 
export module SomeExposingModule 
{ 
    // Not quite sure what to put in here to expose the internal modules 
} 

così ci sono alcun tipo di best practice in questo genere di cose o di qualsiasi altri che hanno fatto qualcosa di simile, o se tutti solo rispettare utilizzando moduli interni per cose complesse?

Answer 1

Non sono sicuro che questa sia una pratica negativa o meno, ma ecco come ho risolto il mio problema.

Prima un breve riassunto del problema nuovo:

ho più file logicamente raggruppate in uno spazio dei nomi, ad esempio Framework poi tutti i file sotto ci saranno Framework.*, come ad esempio Framework.Database o Framework.UnitOfWork. Quindi questi sono tutti compilati tramite tsc --out framework.js ... così ho ottenuto tutto questo prodotto in un file framework.js.

Ora suona bene, tuttavia non consente di esportare i moduli quando si utilizza --out perché si estende su più file, quindi per far funzionare il nodo ho bisogno di esportare i moduli in qualche modo, quindi ho praticamente aggiunto un dattiloscritto file che ancora manualmente questo per me nella compilazione:

// exporter.ts 
module.exports = Framework; 

fornendo così questo è l'ultimo file aggiunto alla compilation tsc vi ritroverete con qualcosa di simile:

// Framework.js 
var Framework; 
(function (Framework) { 
    // lots of good stuff 
})(Framework || (Framework = {})); 
module.exports = Framework; 

Quindi questo sarà esportare la moduli interni f ine e la dichiarazione di esportazione sarà ora inclusa a causa del file exporter.ts che ora è incluso.

Quindi non sono sicuro se questa è una pratica sbagliata, ma questo mi permette di avere il meglio di entrambi i mondi, un modulo riutilizzabile che è strutturato con spazi dei nomi e si sviluppa su una struttura di file ragionevole, e un singolo compilato modulo che può essere incluso per riferimenti o per nodojs richiede.

Quindi l'utilizzo sarà simile:

var Framework = require("./framework"); 
var database = new Framework.Database.DbConnection(); 

Answer 2

Quello che puoi fare è compilare un insieme di file TS in una combinazione .js + d.ts. per esempio. la seguente crea out.js e out.d.ts

tsc a.ts b.ts --out mod.js --declaration 

E poi (si spera) il seguente funzionerà:

///<reference path="mod.d.ts"> 
var mod = require('mod') 

Answer 3

Ci sono alcune idee che aiutano a smussare alcuni di questi problemi.

Se si dispone di molti riferimenti, è possibile utilizzare un file di riferimento per gestirli. Per esempio:

references.ts

///<reference path="a.ts" /> 
///<reference path="b.ts" /> 
///<reference path="c.ts" /> 
///<reference path="d.ts" /> 

Tutti gli altri file ...

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

Ora avete un elenco centrale di vostri riferimenti, che è molto più facile di tessitura elenchi di riferimenti a la parte superiore di ogni file.

Nel tuo caso specifico, sarei più incline a utilizzare le istruzioni import e ottenere NodeJS per caricare i moduli per me - e vorrei raggruppare i moduli utilizzando il file system.