La forma de ver y recopilar todas las fuentes mecanografiado?

Mecanografiado 1.5 beta ha introducido soporte para un archivo de configuración llamado tsconfig.json. En ese archivo se puede configurar el compilador, definir reglas de formato de código y lo más importante para usted, le proporcione información sobre los archivos de TS en su proyecto.

Una vez configurado correctamente, sólo tiene que ejecutar el comando TSC y lo han compilar todo el código de transcripción en su proyecto.

Si usted quiere tener que ver los archivos de cambios, entonces puede simplemente añadir --watch al comando TSC.

He aquí un ejemplo de archivos tsconfig.json

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

En el ejemplo anterior, incluyo todos los archivos .ts en mi proyecto (de forma recursiva). Tenga en cuenta que también puede excluir archivos usando una propiedad "excluir" con una matriz.

Para obtener más información, consulte la documentación: http://www.typescriptlang.org/docs/handbook/tsconfig-json.html

Técnicamente hablando usted tiene algunas opciones aquí:

Si está utilizando un IDE como Sublime texto e integrada MSN plugin para la imprenta: http://blogs.msdn.com/b/interoperability/archive/2012/10/01/sublime-text-vi-emacs-typescript-enabled. aspx puede crear un sistema de construcción, que compila la .tsfuente de .jsforma automática. Aquí está la explicación de cómo puede hacerlo: Cómo configurar un sistema de compilación sublime de mecanografiado .

Se puede definir incluso para compilar el código fuente al destino .jsarchivo en Guardar archivo. Hay un paquete sublime alojado en GitHub: https://github.com/alexnj/SublimeOnSaveBuild que hacen que esto suceda, solamente es necesario incluir la tsextensión del SublimeOnSaveBuild.sublime-settingsarchivo.

Otra posibilidad sería la de compilar cada archivo en la línea de comandos. Incluso puede compilar varios archivos a la vez separándolos con espacios, así: tsc foo.ts bar.ts. Compruebe en este tema: ¿Cómo puedo pasar múltiples archivos de origen para el compilador mecanografiado? , Pero creo que la primera opción es más práctico.

Ver en el uso del ronco para automatizar esto, hay numerosos tutoriales por ahí, pero aquí es un comienzo rápido.

Para una estructura de carpetas como:

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

Usted puede ver y trabajar con texto mecanografiado fácilmente de la carpeta con el ejemplo:

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

Y un archivo ronco:

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

El compilador TSC sólo ver esos archivos que se pasan en la línea de comandos. Será no ver archivos que están incluidos mediante una /// <sourcefile>referencia. Si su trabajo con la fiesta, se puede usar para encontrar encontrar de forma recursiva todos los *.tsarchivos y compilarlos:

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

se puede ver todos los archivos como este

tsc *.ts --watch

0.9.1.1 TSC no parecen tener un reloj función.

se puede usar un PowerShell script como el que hice en este post:

ver de forma automática y compilar archivos de texto mecanografiado

Hoy he diseñado esta hormiga macrodef por el mismo problema que el suyo:

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

Utilizarlo en su fichero de construcción con:

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

Se utiliza en el proyecto PureMVC de mecanografiado que estoy trabajando en el momento usando WebStorm.