Wie zu sehen und alle Typoskript Quellen zu kompilieren?

Typoskript 1.5 Beta hat Unterstützung für eine Konfigurationsdatei eingeführt aufgerufen tsconfig.json. In dieser Datei können Sie die Compiler konfigurieren, Code-Formatierung Regeln definieren, und was noch wichtiger ist für Sie, ihn Informationen über die TS-Dateien in Ihrem Projekt.

Einmal richtig konfiguriert ist, können Sie einfach den tsc Befehl ausführen und haben es kompilieren alle Typoskript Code in Ihrem Projekt.

Wenn Sie haben wollen, die Dateien für Änderungen sehen, dann können Sie einfach auf den tsc Befehl hinzufügen --watch.

Hier ist ein Beispiel tsconfig.json Datei

{
"compilerOptions": {
    "target": "es5",
    "module": "commonjs",
    "declaration": false,
    "noImplicitAny": false,
    "removeComments": true,
    "noLib": false
},
"include": [
    "**/*"
],
"exclude": [
    "node_modules",
    "**/*.spec.ts"
]}

In dem obigen Beispiel bin ich alle .ts Dateien in meinem Projekt (rekursiv). Beachten Sie, dass Sie auch Dateien mit Hilfe eines „ausschließen“ Eigenschaft mit einem Array ausschließen.

Weitere Informationen finden Sie in der Dokumentation: http://www.typescriptlang.org/docs/handbook/tsconfig-json.html

Technisch hier sprechen Sie ein paar Optionen:

Wenn Sie ein IDE wie Sublime Text und integrierte MSN - Plugin für Typoskript verwenden: http://blogs.msdn.com/b/interoperability/archive/2012/10/01/sublime-text-vi-emacs-typescript-enabled. aspx können Sie ein Build - System erstellen, das die kompilieren .tsQuelle .jsautomatisch. Hier ist die Erklärung , wie Sie es tun können: Wie ein Sublime - Build - System für Typoskript konfigurieren .

Sie können sogar den Quellcode zu kompilieren Ziel definieren .jsDatei auf Datei speichern. Es ist ein erhabenes Paket auf GitHub: https://github.com/alexnj/SublimeOnSaveBuild , die dies geschieht, nur müssen Sie die umfassen tsErweiterung in der SublimeOnSaveBuild.sublime-settingsDatei.

Eine andere Möglichkeit wäre, jede Datei in der Befehlszeile zu kompilieren. Sie können wie so durch Trennen sie mit Leerzeichen auf einmal sogar mehrere Dateien zusammenstellen : tsc foo.ts bar.ts. Prüfen Sie diesen thread: Wie kann ich mehrere Quelldateien , die Mitschrift Compiler übergeben? , Aber ich denke , die erste Option handlicher ist.

Schauen Sie in Grunzen mit, dies zu automatisieren, gibt es zahlreiche Tutorials um, aber hier ist ein Quick-Start.

Für eine Ordnerstruktur wie:

blah/
blah/one.ts
blah/two.ts
blah/example/
blah/example/example.ts
blah/example/package.json
blah/example/Gruntfile.js
blah/example/index.html

Sie können mit leicht aus dem Beispielordner mit Typoskript beobachten und arbeiten:

npm install
grunt

Mit package.json:

{
  "name": "PROJECT",
  "version": "0.0.1",
  "author": "",
  "description": "",
  "homepage": "",
  "private": true,
  "devDependencies": {
    "typescript": "~0.9.5",
    "connect": "~2.12.0",
    "grunt-ts": "~1.6.4",
    "grunt-contrib-watch": "~0.5.3",
    "grunt-contrib-connect": "~0.6.0",
    "grunt-open": "~0.2.3"
  }
}

Und eine Grunzen-Datei:

module.exports = function (grunt) {

  // Import dependencies
  grunt.loadNpmTasks('grunt-contrib-watch');
  grunt.loadNpmTasks('grunt-contrib-connect');
  grunt.loadNpmTasks('grunt-open');
  grunt.loadNpmTasks('grunt-ts');

  grunt.initConfig({
    pkg: grunt.file.readJSON('package.json'),
    connect: {
      server: {  // <--- Run a local server on :8089
        options: {
          port: 8089,
          base: './'
        }
      }
    },
    ts: {
      lib: { // <-- compile all the files in ../ to PROJECT.js
        src: ['../*.ts'],
        out: 'PROJECT.js',
        options: {
          target: 'es3',
          sourceMaps: false,
          declaration: true,
          removeComments: false
        }
      },
      example: {  // <--- compile all the files in . to example.js
        src: ['*.ts'],
        out: 'example.js',
        options: {
          target: 'es3',
          sourceMaps: false,
          declaration: false,
          removeComments: false
        }
      }
    },
    watch: { 
      lib: { // <-- Watch for changes on the library and rebuild both
        files: '../*.ts',
        tasks: ['ts:lib', 'ts:example']
      },
      example: { // <--- Watch for change on example and rebuild
        files: ['*.ts', '!*.d.ts'],
        tasks: ['ts:example']
      }
    },
    open: { // <--- Launch index.html in browser when you run grunt
      dev: {
        path: 'http://localhost:8089/index.html'
      }
    }
  });

  // Register the default tasks to run when you run grunt
  grunt.registerTask('default', ['ts', 'connect', 'open', 'watch']);
}

Der tsc Compiler sieht nur die Dateien , die Sie auf der Kommandozeile übergeben. Es wird nicht Dateien sehen , die eine inklusive verwenden /// <sourcefile>Referenz. Wenn Ihr mit der bash arbeiten, könnten Sie rekursiv verwenden finden , um alle zu finden *.tsDateien und kompilieren sie:

find . -name "*.ts" | xargs tsc -w

Sie können alle Dateien wie diese Uhr

tsc *.ts --watch

tsc 0.9.1.1 scheint keinen zu haben , Uhr - Funktion.

Sie könnten ein verwenden Powershell - Skript , wie ich sie in diesem Beitrag gemacht:

Automatisch beobachten und Typoskript Dateien kompilieren

Heute entwarf ich diese Ant MacroDef für das gleiche Problem wie bei Ihnen:

    <!--
    Recursively read a source directory for TypeScript files, generate a compile list in the
    format needed by the TypeScript compiler adding every parameters it take.
-->
<macrodef name="TypeScriptCompileDir">

    <!-- required attribute -->
    <attribute name="src" />

    <!-- optional attributes -->
    <attribute name="out" default="" />
    <attribute name="module" default="" />
    <attribute name="comments" default="" />
    <attribute name="declarations" default="" />
    <attribute name="nolib" default="" />
    <attribute name="target" default="" />

    <sequential>

        <!-- local properties -->
        <local name="out.arg"/>
        <local name="module.arg"/>
        <local name="comments.arg"/>
        <local name="declarations.arg"/>
        <local name="nolib.arg"/>
        <local name="target.arg"/>
        <local name="typescript.file.list"/>
        <local name="tsc.compile.file"/>

        <property name="tsc.compile.file" value="@{src}compile.list" />

        <!-- Optional arguments are not written to compile file when attributes not set -->
        <condition property="out.arg" value="" else='--out "@{out}"'>
            <equals arg1="@{out}" arg2="" />
        </condition>

        <condition property="module.arg" value="" else="--module @{module}">
            <equals arg1="@{module}" arg2="" />
        </condition>

        <condition property="comments.arg" value="" else="--comments">
            <equals arg1="@{comments}" arg2="" />
        </condition>

        <condition property="declarations.arg" value="" else="--declarations">
            <equals arg1="@{declarations}" arg2="" />
        </condition>

        <condition property="nolib.arg" value="" else="--nolib">
            <equals arg1="@{nolib}" arg2="" />
        </condition>

        <!-- Could have been defaulted to ES3 but let the compiler uses its own default is quite better -->
        <condition property="target.arg" value="" else="--target @{target}">
            <equals arg1="@{target}" arg2="" />
        </condition>

        <!-- Recursively read TypeScript source directory and generate a compile list -->
        <pathconvert property="typescript.file.list" dirsep="\" pathsep="${line.separator}">

            <fileset dir="@{src}">
                <include name="**/*.ts" />
            </fileset>

            <!-- In case regexp doesn't work on your computer, comment <mapper /> and uncomment <regexpmapper /> -->
            <mapper type="regexp" from="^(.*)$" to='"\1"' />
            <!--regexpmapper from="^(.*)$" to='"\1"' /-->

        </pathconvert>


        <!-- Write to the file -->
        <echo message="Writing tsc command line arguments to : ${tsc.compile.file}" />
        <echo file="${tsc.compile.file}" message="${typescript.file.list}${line.separator}${out.arg}${line.separator}${module.arg}${line.separator}${comments.arg}${line.separator}${declarations.arg}${line.separator}${nolib.arg}${line.separator}${target.arg}" append="false" />

        <!-- Compile using the generated compile file -->
        <echo message="Calling ${typescript.compiler.path} with ${tsc.compile.file}" />
        <exec dir="@{src}" executable="${typescript.compiler.path}">
            <arg value="@${tsc.compile.file}"/>
        </exec>

        <!-- Finally delete the compile file -->
        <echo message="${tsc.compile.file} deleted" />
        <delete file="${tsc.compile.file}" />

    </sequential>

</macrodef>

Verwenden Sie in Ihrem Build-Datei mit:

    <!-- Compile a single JavaScript file in the bin dir for release -->
    <TypeScriptCompileDir
        src="${src-js.dir}"
        out="${release-file-path}"
        module="amd"
    />

Es wird im Projekt verwendet PureMVC für Typoskript Ich arbeite zur Zeit an mit WebStorm.