Come guardare e compilare tutte le fonti tipografico?

Dattiloscritto 1.5 beta ha introdotto il supporto per un file di configurazione chiamato tsconfig.json. In questo file è possibile configurare il compilatore, definire regole di formattazione del codice e più importante per voi, fornirgli le informazioni sui file TS nel progetto.

Una volta configurato correttamente, si può semplicemente eseguire il comando TSC e lo hanno compilare tutto il codice dattiloscritto nel progetto.

Se si vuole avere guardare i file per le modifiche allora si può semplicemente aggiungere --watch al comando TSC.

Ecco un file di esempio tsconfig.json

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

Nell'esempio di cui sopra, includo tutti i file .ts nel mio progetto (ricorsivamente). Si noti che è possibile anche escludere i file utilizzando una "escludere" la proprietà di una serie.

Per ulteriori informazioni, fare riferimento alla documentazione: http://www.typescriptlang.org/docs/handbook/tsconfig-json.html

Tecnicamente parlando avete alcune opzioni qui:

Se si utilizza un IDE come Sublime Text e integrato il plugin di MSN per tipografico: http://blogs.msdn.com/b/interoperability/archive/2012/10/01/sublime-text-vi-emacs-typescript-enabled. aspx è possibile creare un sistema di compilazione che compilare il .tssorgente per .jsautomaticamente. Ecco la spiegazione di come si può fare: Come configurare un sistema di compilazione Sublime per dattiloscritto .

È possibile definire anche per compilare il codice sorgente alla destinazione .jsfile sul file di salvataggio. C'è un pacchetto di sublime ospitato su GitHub: https://github.com/alexnj/SublimeOnSaveBuild che rendono questo accada, hai solo bisogno di includere l' tsestensione nel SublimeOnSaveBuild.sublime-settingsfile.

Un'altra possibilità sarebbe quella di compilare ogni file nella riga di comando. È possibile compilare anche più file contemporaneamente, separandoli con spazi come così: tsc foo.ts bar.ts. Controllare questa discussione: Come posso passare più file di origine al compilatore dattiloscritto? , Ma penso che la prima opzione è più a portata di mano.

Considerare di usare grugnito per automatizzare questo, ci sono numerosi tutorial in giro, ma ecco un rapido avvio.

Per una struttura di cartelle come:

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

È possibile guardare e lavorare con dattiloscritto facilmente dalla cartella ad esempio con:

npm install
grunt

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

E un file grugnito:

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

Il compilatore TSC guarderà solo i file che si passa sulla riga di comando. Sarà Non guardare i file che sono inclusi utilizzano un /// <sourcefile>riferimento. Se il vostro lavoro con la bash, si potrebbe utilizzare la funzione Trova per trovare ricorsivamente tutti *.tsi file e compilarli:

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

è possibile guardare tutti i file come questo

tsc *.ts --watch

TSC 0.9.1.1 non sembra avere un orologio funzione.

si potrebbe usare un PowerShell script come quello che ho fatto in questo post:

guardare in modo automatico e compilare i file dattiloscritto

Oggi ho progettato questo Ant MacroDef per lo stesso problema come la tua:

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

Usalo nel file di compilazione con:

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

E 'utilizzato nel progetto PureMVC per dattiloscritto su cui sto lavorando al momento utilizzando WebStorm.