Comment regarder et compiler toutes les sources dactylographiée?

beta tapuscrit 1.5 a introduit le support un fichier de configuration appelé tsconfig.json. Dans ce fichier, vous pouvez configurer le compilateur, définir le code de mise en forme des règles et surtout pour vous, fournir des informations sur les fichiers TS dans votre projet.

Une fois correctement configuré, vous pouvez simplement exécuter la commande tsc et avez le compiler tout le code d'enregistrement dans votre projet.

Si vous voulez avoir regarder les fichiers de changements, vous pouvez simplement ajouter --watch à la commande tsc.

Voici un exemple de fichier tsconfig.json

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

Dans l'exemple ci-dessus, j'inclure tous les fichiers .ts dans mon projet (récursive). Notez que vous pouvez également exclure des fichiers en utilisant une propriété « exclure » avec un tableau.

Pour plus d' informations, reportez - vous à la documentation: http://www.typescriptlang.org/docs/handbook/tsconfig-json.html

Techniquement parlant, vous avez quelques options:

Si vous utilisez un IDE comme Sublime Text et le plugin MSN intégré pour Tapuscrit: http://blogs.msdn.com/b/interoperability/archive/2012/10/01/sublime-text-vi-emacs-typescript-enabled. ASPX vous pouvez créer un système de construction qui compile la .tssource .jsautomatiquement. Voici l'explication comment vous pouvez le faire: Comment configurer un sublime système de construction pour tapuscrit .

Vous pouvez même définir pour compiler le code source à la destination .jsfichier sur Enregistrer le fichier. Il y a un paquet sublime hébergé sur GitHub: https://github.com/alexnj/SublimeOnSaveBuild qui ce faire, que vous devez inclure l' tsextension dans le SublimeOnSaveBuild.sublime-settingsfichier.

Une autre possibilité serait de compiler chaque fichier dans la ligne de commande. Vous pouvez compiler même plusieurs fichiers à la fois en les séparant par des espaces comme ceci: tsc foo.ts bar.ts. Vérifiez ce fil: Comment puis - je passer plusieurs fichiers source au compilateur dactylographiée? , Mais je pense que la première option est plus pratique.

Regarder dans grunt pour automatiser cela, il existe de nombreux tutoriels autour, mais voici un démarrage rapide.

Pour une structure de dossiers comme:

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

Vous pouvez regarder et travailler avec tapuscrit facilement à partir du dossier exemple avec:

npm install
grunt

Avec 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"
  }
}

Et un fichier grognement:

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']);
}

Le compilateur tsc ne regarder les fichiers que vous passez sur la ligne de commande. Il ne regarder des fichiers qui sont inclus à l' aide d' une /// <sourcefile>référence. Si votre travail avec le bash, vous pouvez utiliser pour trouver trouver récursive tous les *.tsfichiers et les compiler:

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

vous pouvez regarder tous les fichiers comme celui-ci

tsc *.ts --watch

tsc 0.9.1.1 ne semble pas avoir une montre caractéristique.

vous pouvez utiliser un PowerShell script comme celui que je fis à ce poste:

regarder automatiquement et compiler des fichiers tapuscrit

Aujourd'hui, je conçu cette Ant MacroDef pour le même problème que le vôtre:

    <!--
    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>

Utilisez-le dans votre fichier de construction avec:

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

Il est utilisé dans le projet PureMVC pour tapuscrit je travaille à l'heure à l' aide WebStorm.