TypeScript - separando a saída do código

Question

estou tentando o TypeScript e acho muito útil.

Tenho um projeto bastante grande e estava pensando em reescrevê-lo usando texto datilografado.O principal problema aqui é o seguinte:

arquivo A.ts:

class A extends B {
    // A stuff
}

arquivo B.ts:

class B {
    // B stuff
}

Se eu compilar A.ts com este comando:

tsc --out compiledA.js A.ts

Receberei um erro do compilador porque ele não sabe como ameaçar o "B" após a extensão.

Então, uma "solução" seria incluir no A.ts (como primeira linha de código):

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

Compilando novamente A.ts com o mesmo comando

tsc --out compiledA.js A.ts

Resultará em A.js compilado contendo código B.ts e A.ts.(o que poderia ser muito bom)

No meu caso, só preciso compilar o código A.ts no arquivo compiladoA.js e não quero que o material B.ts esteja lá.

Na verdade, o que eu quero é:

• tsc --out A.js A.ts => compilar apenas o material A.ts
• tsc --out B.js B.ts => compilar apenas o material B.ts

Posso fazer isso removendo a palavra-chave "extends", mas, ao fazer isso, perderei a maior parte das qualidades do texto digitado.

Alguém pode me dizer se existe uma maneira de fazer isso?

Answer 1

Depois de alguma pesquisa, descobri que o problema foi introduzido pelo argumento --out no compilador.

A solução @silent__thought funciona perfeitamente se você quiser lidar com módulos.Caso contrário, você precisará usar a instrução require (veja a pergunta) e então compilar o arquivo "main.ts" sem o argumento --out

Answer 2

EDITAR: Como Andrea aponta, se você omitir o --out parâmetro você obterá o comportamento esperado, ou seja,nenhuma combinação de arquivos de origem.Deixarei esta solução alternativa abaixo, caso possa ajudar outra pessoa.

---

Acredito que você terá que usar a sintaxe do módulo externo (CommonJS ou AMD) para fazer isso.

Usando seu exemplo:

a.ts

import B = module("b")

class A extends B.B {
    // A stuff
}

b.ts

export class B {
    // B stuff
}

Ajuntar com tsc --out compiledA.js A.ts.

Isto resulta em a.js importando b.js usando o sistema CommonJS.Os arquivos resultantes ficam assim:

a.ts

var __extends = this.__extends || function (d, b) {
    function __() { this.constructor = d; }
    __.prototype = b.prototype;
    d.prototype = new __();
}
var B = require("./b")
var A = (function (_super) {
    __extends(A, _super);
    function A() {
        _super.apply(this, arguments);

    }
    return A;
})(B.B);

b.ts

var B = (function () {
    function B() { }
    return B;
})();
exports.B = B;