Πώς να παρακολουθήσετε και να συγκεντρώσει όλες τις πηγές γραφομηχανή;

Γραφομηχανή 1.5 beta εισήγαγε υποστήριξη για ένα αρχείο ρυθμίσεων που καλείται tsconfig.json. Σε αυτό το αρχείο μπορείτε να διαμορφώσετε τον compiler, ορίζουν κανόνες μορφοποίησης κώδικα και το πιο σημαντικό για εσάς, του παρέχει πληροφορίες σχετικά με τα αρχεία TS στο έργο σας.

Αφού ρυθμιστεί σωστά, μπορείτε απλά να εκτελέσετε την εντολή TSC και έχουν συγκεντρώσει όλο τον κώδικα γραφομηχανή στο έργο σας.

Αν θέλετε να το παρακολουθήσετε τα αρχεία για τις αλλαγές τότε μπορείτε απλά να προσθέσετε --watch στην εντολή TSC.

Εδώ είναι ένα παράδειγμα αρχείου tsconfig.json

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

Στο παραπάνω παράδειγμα, θα περιλαμβάνει όλα τα αρχεία .ts στο έργο μου (αναδρομικά). Σημειώστε ότι μπορείτε επίσης να εξαιρέσετε αρχεία χρησιμοποιώντας ένα «αποκλείσει» ακίνητο με μια σειρά.

Για περισσότερες πληροφορίες, ανατρέξτε στην τεκμηρίωση: http://www.typescriptlang.org/docs/handbook/tsconfig-json.html

Από τεχνικής απόψεως έχετε μερικές επιλογές εδώ:

Εάν χρησιμοποιείτε ένα IDE όπως Sublime Κείμενο και ολοκληρωμένη MSN plugin για γραφομηχανή: http://blogs.msdn.com/b/interoperability/archive/2012/10/01/sublime-text-vi-emacs-typescript-enabled. aspx μπορείτε να δημιουργήσετε ένα σύστημα κατασκευής το οποίο συγκεντρώνει την .tsπηγή σε .jsαυτόματη. Εδώ είναι η εξήγηση πώς μπορείτε να το κάνετε: Πώς να ρυθμίσετε ένα Sublime σύστημα κατασκευής για την γραφομηχανή .

Μπορείτε να ορίσετε ακόμη και για τη σύνταξη του πηγαίου κώδικα στον προορισμό .jsτου αρχείου στο αρχείο αποθήκευση. Υπάρχει μια πανέμορφη συσκευασία που φιλοξενείται σε GitHub: https://github.com/alexnj/SublimeOnSaveBuild που να συμβεί αυτό, μόνο θα πρέπει να περιλαμβάνει την tsεπέκταση του SublimeOnSaveBuild.sublime-settingsαρχείου.

Μια άλλη δυνατότητα θα ήταν να καταρτίζουν κάθε αρχείο στη γραμμή εντολών. Μπορείτε να καταρτίζουν ακόμη και πολλαπλά αρχεία ταυτόχρονα διαχωρίζοντας τους με χώρους όπως έτσι: tsc foo.ts bar.ts. Επιλέξτε αυτό το νήμα: Πώς μπορώ να περάσει πολλαπλά αρχεία προέλευσης προς το μεταγλωττιστή γραφομηχανή; , Αλλά νομίζω ότι η πρώτη επιλογή είναι πιο βολικό.

Κοιτάξτε σε χρήση γρύλισμα για την αυτοματοποίηση αυτό, υπάρχουν πολλά μαθήματα γύρω, αλλά εδώ είναι μια γρήγορη εκκίνηση.

Για μια δομή φακέλων, όπως:

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

Μπορείτε να παρακολουθήσετε και να συνεργαστεί με γραφομηχανή εύκολα από το παράδειγμα φάκελο με:

npm install
grunt

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

Και ένα γρύλισμα αρχείο:

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

Ο compiler TSC θα παρακολουθήσουν μόνο τα αρχεία που περνάτε στη γραμμή εντολών. Θα δεν παρακολουθούν τα αρχεία που περιλαμβάνονται χρησιμοποιώντας μια /// <sourcefile>αναφορά. Αν εργασίας σας με το bash, θα μπορούσατε να χρησιμοποιήσετε βρει για να βρείτε αναδρομικά όλα τα *.tsαρχεία και την κατάρτισή τους:

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

μπορείτε να παρακολουθήσετε όλα τα αρχεία όπως αυτό

tsc *.ts --watch

TSC 0.9.1.1 δεν φαίνεται να έχουν ένα ρολόι χαρακτηριστικό.

μπορείτε να χρησιμοποιήσετε ένα PowerShell σενάριο σαν αυτό που έκανα σε αυτό το post:

Αυτόματη παρακολουθήσουν και να συγκεντρώσει τα αρχεία γραφομηχανή

Σήμερα έχω σχεδιάσει αυτό το Αντ MacroDef για το ίδιο πρόβλημα με τα δικά σας:

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

Χρησιμοποιήστε το σε αρχείο κατασκευή σας με:

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

Χρησιμοποιείται στο έργο PureMVC για γραφομηχανή δουλεύω κατά το χρόνο χρησιμοποιώντας Webstorm.