Cum de a viziona și compila toate sursele typescript?

Typescript 1.5 beta a introdus suport pentru un fișier de configurare numit tsconfig.json. În acest fișier puteți configura compilator, să definească reguli de formatare cod și mai important pentru tine, trebuie să furnizeze informații despre fișierele TS în proiectul dumneavoastră.

configurat corect O dată, puteți rula pur și simplu comanda TSC și să-l compilează toate codul typescript în proiectul dumneavoastră.

Dacă doriți să-l urmăriți fișierele pentru modificări, atunci puteți adăuga pur și simplu --watch la comanda TSC.

Iată un fișier tsconfig.json exemplu

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

In exemplul de mai sus, am să includă toate fișierele Ts în proiectul meu (recursiv). Rețineți că puteți exclude, de asemenea, fișiere folosind un „exclude“ proprietate cu o matrice.

Pentru mai multe informații, consultați documentația: http://www.typescriptlang.org/docs/handbook/tsconfig-json.html

Tehnic vorbind aveți câteva opțiuni aici:

Dacă utilizați un IDE ca Sublime Text și MSN plug -in pentru typescript integrat: http://blogs.msdn.com/b/interoperability/archive/2012/10/01/sublime-text-vi-emacs-typescript-enabled. aSPX puteți crea un sistem de acumulare care compila .tssursa la .jsautomat. Aici este explicația modul în care puteți face acest lucru: Cum se configurează un sistem Build Sublim pentru masina de scris .

Puteți defini chiar și pentru a compila codul sursă la destinație .jsfișier de pe Salvare fișier. Există un pachet de sublimă găzduit pe GitHub: https://github.com/alexnj/SublimeOnSaveBuild care face acest lucru, doar trebuie să includeți tsextensia în SublimeOnSaveBuild.sublime-settingsfișierul.

O altă posibilitate ar fi de a compila fiecare fișier în linia de comandă. Puteți compila chiar mai multe fișiere simultan prin separarea lor cu spații , cum ar fi , astfel: tsc foo.ts bar.ts. Verificați acest thread: Cum pot trece mai multe fișiere sursă pentru compilator typescript? , Dar cred că prima opțiune este mult mai la îndemână.

Uită-te în utilizarea geamăt pentru a automatiza acest lucru, există numeroase tutoriale în jurul valorii, dar aici e un start rapid.

Pentru o structură de dosar cum ar fi:

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

Puteți urmări și de a lucra cu dactilografiat cu ușurință de exemplu dosar cu:

npm install
grunt

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

Și un fișier mormăit:

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

Compilatorul TSC va urmări doar acele fișiere pe care le trec pe linia de comandă. Acesta va nu viziona fișierele care sunt incluse folosind o /// <sourcefile>referință. Dacă echipamentul de lucru cu bash, ați putea utiliza pentru a găsi găsi recursiv toate *.tsfișierele și să le compila:

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

puteți viziona toate fișierele de acest gen

tsc *.ts --watch

TSC 0.9.1.1 nu pare să aibă un ceas caracteristică.

ai putea folosi un PowerShell script ca l - am făcut la acest post:

ceas automat și compila fișierele typescript

Astăzi am proiectat acest Ant MacroDef pentru aceeași problemă ca a ta:

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

Folosiți-l în fișierul construi cu:

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

Acesta este utilizat în cadrul proiectului PureMVC pentru typescript lucrez la momentul folosind Webstorm.